def include_cell_prototype(nml_doc, cell_nml2_path): """ Add a NeuroML2 file containing a cell definition """ nml_doc.includes.append(neuroml.IncludeType(cell_nml2_path))
def main(): """Main""" nml2_cell_dir = '../NeuroML2/' net_ref = "ManyCells" net_doc = neuroml.NeuroMLDocument(id=net_ref) net = neuroml.Network(id=net_ref) net_doc.networks.append(net) cell_dirs = [ f for f in os.listdir('.') if (os.path.isdir(f) and os.path.isfile(f + '/.provenance.json')) ] clear_neuron() inputs_list = [] for index, cell_dir in enumerate(cell_dirs): inputs_list.append((index, cell_dir, nml2_cell_dir, len(cell_dirs))) # Parallelise the generation of the files using multiprocessing if the # -parallel option is specified if parallel: import multiprocessing pool = multiprocessing.Pool(maxtasksperchild=1) # pylint: disable=E1123 nml_cell_files = pool.map(process_celldir, inputs_list, chunksize=1) else: nml_cell_files = map(process_celldir, inputs_list) for nml_cell_file, pop in nml_cell_files: net.populations.append(pop) net_doc.includes.append(neuroml.IncludeType(nml_cell_file)) count = len(cell_dirs) if not make_zips: net_file = '%s/%s.net.nml' % (nml2_cell_dir, net_ref) neuroml.writers.NeuroMLWriter.write(net_doc, net_file) print("Written network with %i cells in network to: %s" % (count, net_file)) pynml.nml2_to_svg(net_file)
# Define timedSynapticInput tsi = neuroml.TimedSynapticInput(id="timedSynapticInput", synapse=syn1.id, spike_target="./%s" % syn1.id) tsi.spikes.append(neuroml.Spike(id="0", time="100ms")) tsi.spikes.append(neuroml.Spike(id="1", time="500ms")) tsi.spikes.append(neuroml.Spike(id="2", time="700ms")) tsi.spikes.append(neuroml.Spike(id="3", time="705ms")) nml_doc.timed_synaptic_inputs.append(tsi) # Include cell cell_id = 'pyr_4_sym' nml_doc.includes.append(neuroml.IncludeType('%s.cell.nml' % cell_id)) # Create network net = neuroml.Network(id=ref + "_network") nml_doc.networks.append(net) # Create populations size0 = 3 pyr_cells_pop0 = neuroml.Population(id="PoissonFiringSynCells", size=size0, component=cell_id) net.populations.append(pyr_cells_pop0) size1 = 3 pyr_cells_pop1 = neuroml.Population(id="SpikeArrayCells", size=size1,
def generate_Vm_vs_time_plot(NML2_file, cell_id, # inj_amp_nA = 80, # delay_ms = 20, # inj_dur_ms = 0.5, sim_dur_ms = 1000, dt = 0.05, temperature = "35", spike_threshold_mV=0., plot_voltage_traces=False, show_plot_already=True, simulator="jNeuroML_NEURON", include_included=True): # simulation parameters nogui = '-nogui' in sys.argv # Used to supress GUI in tests for Travis-CI ref = "iMC1_cell_1_origin" print_comment_v("Generating Vm(mV) vs Time(ms) plot for cell %s in %s using %s"% # (Inj %snA / %sms dur after %sms delay)"% (cell_id, NML2_file, simulator))#, inj_amp_nA, inj_dur_ms, delay_ms)) sim_id = 'Vm_%s'%ref duration = sim_dur_ms ls = LEMSSimulation(sim_id, sim_dur_ms, dt) ls.include_neuroml2_file(NML2_file, include_included=include_included) ls.assign_simulation_target('network') nml_doc = nml.NeuroMLDocument(id=cell_id) nml_doc.includes.append(nml.IncludeType(href=NML2_file)) net = nml.Network(id="network", type='networkWithTemperature', temperature='%sdegC'%temperature) nml_doc.networks.append(net) #input_id = ("input_%s"%str(inj_amp_nA).replace('.','_')) #pg = nml.PulseGenerator(id=input_id, # delay="%sms"%delay_ms, # duration='%sms'%inj_dur_ms, # amplitude='%spA'%inj_amp_nA) #nml_doc.pulse_generators.append(pg) pop_id = 'single_cell' pop = nml.Population(id=pop_id, component='iMC1_cell_1_origin', size=1, type="populationList") inst = nml.Instance(id=0) pop.instances.append(inst) inst.location = nml.Location(x=0, y=0, z=0) net.populations.append(pop) # Add these to cells #input_list = nml.InputList(id='il_%s'%input_id, # component=pg.id, # populations=pop_id) #input = nml.Input(id='0', target='../hhpop/0/hhcell', # destination="synapses") #input_list.input.append(input) #net.input_lists.append(input_list) sim_file_name = '%s.sim.nml'%sim_id pynml.write_neuroml2_file(nml_doc, sim_file_name) ls.include_neuroml2_file(sim_file_name) disp0 = 'Voltage_display' ls.create_display(disp0,"Voltages", "-90", "50") ls.add_line_to_display(disp0, "V", "hhpop/0/hhcell/v", scale='1mV') of0 = 'Volts_file' ls.create_output_file(of0, "%s.v.dat"%sim_id) ls.add_column_to_output_file(of0, "V", "hhpop/0/hhcell/v") lems_file_name = ls.save_to_file() if simulator == "jNeuroML": results = pynml.run_lems_with_jneuroml(lems_file_name, nogui=True, load_saved_data=True, plot=plot_voltage_traces, show_plot_already=False) elif simulator == "jNeuroML_NEURON": results = pynml.run_lems_with_jneuroml_neuron(lems_file_name, nogui=True, load_saved_data=True, plot=plot_voltage_traces, show_plot_already=False) if show_plot_already: from matplotlib import pyplot as plt plt.show() #plt.plot("t","V") #plt.title("Vm(mV) vs Time(ms) plot for cell %s in %s using %s (Inj %snA / %sms dur after %sms delay)"% # (cell_id, nml2_file, simulator, inj_amp_nA, inj_dur_ms, delay_ms)) #plt.xlabel('Time (ms)') #plt.ylabel('Vmemb (mV)') #plt.legend(['Test'], loc='upper right') return of0
def generate_hippocampal_net(network_id, conndata="430", nrn_runname="TestRun", validate=True, randomSeed=12345, generate_LEMS_simulation=False, duration=100, dt=0.01, temperature="34.0 degC"): seed(randomSeed) cell_types = [ 'axoaxonic', 'bistratified', 'cck', 'cutsuridis', 'ivy', 'ngf', 'olm', 'poolosyn', 'pvbasket', 'sca' ] synapse_types = ['exp2Synapses', 'customGABASynapses'] ###### Create network doc ##### nml_doc = neuroml.NeuroMLDocument(id=network_id) for cell in cell_types: nml_doc.includes.append( neuroml.IncludeType(href="../cells/%s.cell.nml" % cell)) for synapse in synapse_types: nml_doc.includes.append( neuroml.IncludeType(href="../synapses/%s.synapse.nml" % synapse)) nml_doc.includes.append(neuroml.IncludeType(href="stimulations.nml")) # Create network net = neuroml.Network(id=network_id, type="networkWithTemperature", temperature=temperature) from neuroml import __version__ net.notes = "Network generated using libNeuroML v%s" % __version__ nml_doc.networks.append(net) # Create populations print("Creating populations...") dCellIDs, dNumCells = create_populations(net, cell_types, nrn_runname, randomSeed) # Create synapses print("Connecting cells...") add_synapses(net, conndata, nrn_runname, dCellIDs, dNumCells, write_synapse_file=False) # initialise voltage print("Initialising cell voltage..") # TODO: this shouldn't be hard coded ... dClamps = {} dClamps["axoaxonic"] = -65.0127 dClamps["bistratified"] = -67.0184 dClamps["cck"] = -70.6306 dClamps["ivy"] = -59.9512 dClamps["ngf"] = -59.9512 dClamps["olm"] = -71.1411 dClamps["poolosyn"] = -62.9601 dClamps["pvbasket"] = -65.0246 dClamps["sca"] = -70.5652 init_voltage(nml_doc, net, dClamps, dNumCells) ####### 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_' + network_id, duration, dt) # Point to network as target of simulation ls.assign_simulation_target(net.id) # Incude generated/existing NeuroML2 files channel_types = [ 'CavL', 'CavN', 'HCN', 'HCNolm', 'HCNp', 'KCaS', 'Kdrfast', 'Kdrfastngf', 'Kdrp', 'Kdrslow', 'KvA', 'KvAdistp', 'KvAngf', 'KvAolm', 'KvAproxp', 'KvCaB', 'KvGroup', 'Nav', 'Navaxonp', 'Navbis', 'Navcck', 'Navngf', 'Navp', 'leak_chan' ] for channel in channel_types: ls.include_neuroml2_file("../channels/%s.channel.nml" % channel, include_included=False) ls.include_neuroml2_file("../channels/Capool.nml", include_included=False) for cell in cell_types: ls.include_neuroml2_file("../cells/%s.cell.nml" % cell, include_included=False) for synapse in synapse_types: ls.include_neuroml2_file("../synapses/%s.synapse.nml" % synapse, include_included=False) ls.include_neuroml2_file("stimulations.nml", include_included=False) ls.include_neuroml2_file(nml_file, include_included=False) ###### Specify Display and output files ##### max_traces = 9 # the 10th color in NEURON is white ... for cell_type, numCells in dNumCells.iteritems(): PC = False if numCells > 0: of = "of_%s" % cell_type ls.create_output_file(of, "%s.v.dat" % cell_type) if cell_type == 'poolosyn' or cell_type == 'cutsuridis': # TODO: ensure that only one of them is used for modelling pyramidal cells (in a given simulation) PC = True ls.create_event_output_file("spikes_PC", "PC.spikes.dat") ls.create_display("disp_PC", "Voltages Pyramidal cells", "-80", "50") cell_id = "%scell" % cell_type pop_id = "pop_%s" % cell_type for i in range(numCells): quantity = "%s/%i/%s/v" % (pop_id, i, cell_id) ls.add_column_to_output_file(of, "v_%i" % i, quantity) if PC: ls.add_selection_to_event_output_file( "spikes_PC", i, select='%s/%i/%s' % (pop_id, i, cell_id), event_port='spike') if i < max_traces: ls.add_line_to_display("disp_PC", "PC %i: V[mV]" % i, quantity, "1mV", pynml.get_next_hex_color()) # Save to LEMS file print("Writing LEMS file...") lems_file_name = ls.save_to_file() else: ls = None lems_file_name = '' print("-----------------------------------") return ls, lems_file_name
def generate_network_for_sweeps(cell_type, dataset_id, cell_file_name, cell_id, target_dir, data_dir="../../data"): target_sweep_numbers = DH.DATASET_TARGET_SWEEPS[dataset_id] net_id = "network_%s_%s"%(dataset_id, cell_type) net = neuroml.Network(id=net_id, type="networkWithTemperature", temperature=DH.SIMULATION_TEMPERATURE) net_doc = neuroml.NeuroMLDocument(id=net.id) net_doc.networks.append(net) net_doc.includes.append(neuroml.IncludeType(cell_file_name)) number_cells = len(target_sweep_numbers) pop = neuroml.Population(id="Pop0", component=cell_id, size=number_cells, type="populationList") net.populations.append(pop) for i in range(number_cells): location = neuroml.Location(x=100*i,y=0,z=0) pop.instances.append(neuroml.Instance(id=i,location=location)) print target_sweep_numbers f = "%s/%s_analysis.json"%(data_dir,dataset_id) with open(f, "r") as json_file: data = json.load(json_file) id = data['data_set_id'] sweeps = data['sweeps'] print("Looking at data analysis in %s (dataset: %s)"%(f,id)) index = 0 for s in target_sweep_numbers: current = float(sweeps['%i'%s]["sweep_metadata"]["aibs_stimulus_amplitude_pa"]) print("Sweep %s (%s pA)"%(s, current)) stim_amp = "%s pA"%current input_id = ("input_%i"%s) pg = neuroml.PulseGenerator(id=input_id, delay="270ms", duration="1000ms", amplitude=stim_amp) net_doc.pulse_generators.append(pg) input_list = neuroml.InputList(id=input_id, component=pg.id, populations=pop.id) input = neuroml.Input(id='0', target="../%s/%i/%s"%(pop.id, index, cell_id), destination="synapses") index+=1 input_list.input.append(input) net.input_lists.append(input_list) net_file_name = '%s/%s.net.nml'%(target_dir,net_id) print("Saving generated network to: %s"%net_file_name) pynml.write_neuroml2_file(net_doc, net_file_name) return net_file_name
segment_groups=chan['section'], cond_density='%s S_per_cm2'%float(chan['value']), erev=erev, ion = ion) membrane_properties.channel_densities.append(cd) else: if not ca_dynamics.has_key(model_id): ca_dynamics[model_id] = {} ca_dynamics[model_id][str(chan['name'])] = chan['value'] inc_chans =[] for cd in membrane_properties.channel_densities: if not cd.ion_channel in inc_chans: nml_doc.includes.append( neuroml.IncludeType(href="%s.channel.nml" % cd.ion_channel)) inc_chans.append(cd.ion_channel) for cdn in membrane_properties.channel_density_nernsts: if not cdn.ion_channel in inc_chans: nml_doc.includes.append( neuroml.IncludeType(href="%s.channel.nml" % cdn.ion_channel)) inc_chans.append(cdn.ion_channel) resistivities = [] resistivities.append(neuroml.Resistivity(value="%s ohm_cm"%cell_info['passive'][0]['ra'], segment_groups='all')) species = [] species.append(neuroml.Species(id='ca', \ ion='ca', \ initial_concentration='0.0001 mM', \ initial_ext_concentration='2 mM', \
def create_GoC_network(duration, dt, seed, runid, run=False): ### ---------- Load Params noPar = True pfile = Path('params_file.pkl') if pfile.exists(): print('Reading parameters from file:') file = open('params_file.pkl', 'rb') params_list = pkl.load(file) if len(params_list) > runid: p = params_list[runid] file.close() if noPar: p = inp.get_simulation_params(runid) ### ---------- Component types goc_filename = 'GoC.cell.nml' # Golgi cell with channels goc_file = pynml.read_neuroml2_file(goc_filename) goc_type = goc_file.cells[0] goc_ref = nml.IncludeType(href=goc_filename) gj = nml.GapJunction(id="GJ_0", conductance="426pS") # GoC synapse ### --------- Populations # Build network to specify cells and connectivity net = nml.Network(id="gocNetwork", type="networkWithTemperature", temperature="23 degC") # Create GoC population goc_pop = nml.Population(id=goc_type.id + "Pop", component=goc_type.id, type="populationList", size=p["nGoC"]) for goc in range(p["nGoC"]): inst = nml.Instance(id=goc) goc_pop.instances.append(inst) inst.location = nml.Location(x=p["GoC_pos"][goc, 0], y=p["GoC_pos"][goc, 1], z=p["GoC_pos"][goc, 2]) net.populations.append(goc_pop) # Create NML document for network specification net_doc = nml.NeuroMLDocument(id=net.id) net_doc.networks.append(net) net_doc.includes.append(goc_ref) net_doc.gap_junctions.append(gj) ### ------------ Connectivity ### 1. Input Current to one cell ctr = 0 for goc in p["Test_GoC"]: for jj in range(p["nSteps"]): input_id = 'stim_{}'.format(ctr) istep = nml.PulseGenerator( id=input_id, delay='{} ms'.format(p["iDuration"] * jj + p["iRest"] * (jj + 1)), duration='{} ms'.format(p["iDuration"]), amplitude='{} pA'.format(p["iAmp"][jj])) net_doc.pulse_generators.append(istep) input_list = nml.InputList(id='ilist_{}'.format(ctr), component=istep.id, populations=goc_pop.id) curr_inj = nml.Input('0', target="../%s[%i]" % (goc_pop.id, goc), destination="synapses") input_list.input.append(curr_inj) net.input_lists.append(input_list) ctr += 1 ### 2. Electrical coupling between GoCs GoCCoupling = nml.ElectricalProjection(id="gocGJ", presynaptic_population=goc_pop.id, postsynaptic_population=goc_pop.id) net.electrical_projections.append(GoCCoupling) dend_id = [1, 2, 5] for jj in range(p["GJ_pairs"].shape[0]): conn = nml.ElectricalConnectionInstanceW( id=jj, pre_cell='../{}/{}/{}'.format(goc_pop.id, p["GJ_pairs"][jj, 0], goc_type.id), pre_segment=dend_id[p["GJ_loc"][jj, 0]], pre_fraction_along='0.5', post_cell='../{}/{}/{}'.format(goc_pop.id, p["GJ_pairs"][jj, 1], goc_type.id), post_segment=dend_id[p["GJ_loc"][jj, 1]], post_fraction_along='0.5', synapse=gj.id, weight=p["GJ_wt"][jj]) GoCCoupling.electrical_connection_instance_ws.append(conn) ### -------------- Write files net_filename = 'gocNetwork.nml' pynml.write_neuroml2_file(net_doc, net_filename) simid = 'sim_gocnet_' + goc_type.id + '_run_{}'.format(runid) ls = LEMSSimulation(simid, duration=duration, dt=dt, simulation_seed=seed) ls.assign_simulation_target(net.id) ls.include_neuroml2_file(net_filename) ls.include_neuroml2_file(goc_filename) # Specify outputs eof0 = 'Events_file' ls.create_event_output_file(eof0, "%s.v.spikes" % simid, format='ID_TIME') for jj in range(goc_pop.size): ls.add_selection_to_event_output_file( eof0, jj, '{}/{}/{}'.format(goc_pop.id, jj, goc_type.id), 'spike') of0 = 'Volts_file' ls.create_output_file(of0, "%s.v.dat" % simid) ctr = 0 for jj in p["Test_GoC"]: ls.add_column_to_output_file( of0, jj, '{}/{}/{}/v'.format(goc_pop.id, ctr, goc_type.id)) ctr += 1 #Create Lems file to run lems_simfile = ls.save_to_file() if run: res = pynml.run_lems_with_jneuroml_neuron(lems_simfile, max_memory="2G", nogui=True, plot=False) else: res = pynml.run_lems_with_jneuroml_neuron(lems_simfile, max_memory="2G", only_generate_scripts=True, compile_mods=False, nogui=True, plot=False) return res
def create_GoC_network(duration, dt, seed, N_goc=0, N_mf=15, run=False, prob_type='Boltzmann', GJw_type='Vervaeke2010'): ### ---------- Component types goc_filename = 'GoC.cell.nml' # Golgi cell with channels goc_file = pynml.read_neuroml2_file(goc_filename) goc_type = goc_file.cells[0] goc_ref = nml.IncludeType(href=goc_filename) MFSyn_filename = 'MF_GoC_Syn.nml' # small conductance synapse for background inputs mfsyn_file = pynml.read_neuroml2_file(MFSyn_filename) MFSyn_type = mfsyn_file.exp_three_synapses[0] mfsyn_ref = nml.IncludeType(href=MFSyn_filename) MF20Syn_filename = 'MF_GoC_SynMult.nml' # multi-syn conductance for strong/coincident transient input mf20syn_file = pynml.read_neuroml2_file(MF20Syn_filename) MF20Syn_type = mf20syn_file.exp_three_synapses[0] mf20syn_ref = nml.IncludeType(href=MF20Syn_filename) mf_type2 = 'spikeGeneratorPoisson' # Spike source for background inputs mf_poisson = nml.SpikeGeneratorPoisson( id="MF_Poisson", average_rate="5 Hz") # Not tuned to any data - qqq ! mf_bursttype = 'transientPoissonFiringSynapse' # Burst of MF input (as explicit input) mf_burst = nml.TransientPoissonFiringSynapse(id="MF_Burst", average_rate="100 Hz", delay="2000 ms", duration="500 ms", synapse=MF20Syn_type.id, spike_target='./{}'.format( MF20Syn_type.id)) gj = nml.GapJunction(id="GJ_0", conductance="426pS") # GoC synapse ### --------- Populations # Build network to specify cells and connectivity net = nml.Network(id="gocNetwork", type="networkWithTemperature", temperature="23 degC") ### Golgi cells if N_goc > 0: GoC_pos = nu.GoC_locate(N_goc) else: GoC_pos = nu.GoC_density_locate() N_goc = GoC_pos.shape[0] # Create GoC population goc_pop = nml.Population(id=goc_type.id + "Pop", component=goc_type.id, type="populationList", size=N_goc) for goc in range(N_goc): inst = nml.Instance(id=goc) goc_pop.instances.append(inst) inst.location = nml.Location(x=GoC_pos[goc, 0], y=GoC_pos[goc, 1], z=GoC_pos[goc, 2]) net.populations.append(goc_pop) ### MF population MF_Poisson_pop = nml.Population(id=mf_poisson.id + "_pop", component=mf_poisson.id, type="populationList", size=N_mf) MF_pos = nu.GoC_locate(N_mf) for mf in range(N_mf): inst = nml.Instance(id=mf) MF_Poisson_pop.instances.append(inst) inst.location = nml.Location(x=MF_pos[mf, 0], y=MF_pos[mf, 1], z=MF_pos[mf, 2]) net.populations.append(MF_Poisson_pop) # Create NML document for network specification net_doc = nml.NeuroMLDocument(id=net.id) net_doc.networks.append(net) net_doc.includes.append(goc_ref) net_doc.includes.append(mfsyn_ref) net_doc.includes.append(mf20syn_ref) net_doc.spike_generator_poissons.append(mf_poisson) net_doc.transient_poisson_firing_synapses.append(mf_burst) net_doc.gap_junctions.append(gj) ### ------------ Connectivity ### background excitatory inputs: MF to GoC populations MFProjection = nml.Projection(id="MFtoGoC", presynaptic_population=MF_Poisson_pop.id, postsynaptic_population=goc_pop.id, synapse=MFSyn_type.id) net.projections.append(MFProjection) #Get list of MF->GoC synapse mf_synlist = nu.randdist_MF_syn(N_mf, N_goc, pConn=0.3) # Not tuned to any data - qqq! nMFSyn = mf_synlist.shape[1] for syn in range(nMFSyn): mf, goc = mf_synlist[:, syn] conn2 = nml.Connection( id=syn, pre_cell_id='../{}/{}/{}'.format(MF_Poisson_pop.id, mf, mf_poisson.id), post_cell_id='../{}/{}/{}'.format(goc_pop.id, goc, goc_type.id), post_segment_id='0', post_fraction_along="0.5") #on soma MFProjection.connections.append(conn2) ### Add few burst inputs n_bursts = 4 gocPerm = np.random.permutation( N_goc) # change to central neurons later -qqq !!! ctr = 0 for gg in range(4): goc = gocPerm[gg] for jj in range(n_bursts): inst = nml.ExplicitInput( id=ctr, target='../{}/{}/{}'.format(goc_pop.id, goc, goc_type.id), input=mf_burst.id, synapse=MF20Syn_type.id, spikeTarget='./{}'.format(MF20Syn_type.id)) net.explicit_inputs.append(inst) ctr += 1 ### Electrical coupling between GoCs # get GJ connectivity GJ_pairs, GJWt = nu.GJ_conn(GoC_pos, prob_type, GJw_type) #tmp1, tmp2 = valnet.gapJuncAnalysis( GJ_pairs, GJWt ) #print("Number of gap junctions per cell: ", tmp1) #print("Net GJ conductance per cell:", tmp2) # Add electrical synapses GoCCoupling = nml.ElectricalProjection(id="gocGJ", presynaptic_population=goc_pop.id, postsynaptic_population=goc_pop.id) nGJ = GJ_pairs.shape[0] for jj in range(nGJ): conn = nml.ElectricalConnectionInstanceW( id=jj, pre_cell='../{}/{}/{}'.format(goc_pop.id, GJ_pairs[jj, 0], goc_type.id), pre_segment='1', pre_fraction_along='0.5', post_cell='../{}/{}/{}'.format(goc_pop.id, GJ_pairs[jj, 1], goc_type.id), post_segment='1', post_fraction_along='0.5', synapse=gj.id, weight=GJWt[jj]) GoCCoupling.electrical_connection_instance_ws.append(conn) net.electrical_projections.append(GoCCoupling) ### -------------- Write files net_filename = 'gocNetwork.nml' pynml.write_neuroml2_file(net_doc, net_filename) #lems_filename = 'instances.xml' #pynml.write_lems_file( lems_inst_doc, lems_filename, validate=False ) simid = 'sim_gocnet' + goc_type.id ls = LEMSSimulation(simid, duration=duration, dt=dt, simulation_seed=seed) ls.assign_simulation_target(net.id) ls.include_neuroml2_file(net_filename) ls.include_neuroml2_file(goc_filename) ls.include_neuroml2_file(MFSyn_filename) ls.include_neuroml2_file(MF20Syn_filename) #ls.include_lems_file( lems_filename, include_included=False) # Specify outputs eof0 = 'Events_file' ls.create_event_output_file(eof0, "%s.v.spikes" % simid, format='ID_TIME') for jj in range(goc_pop.size): ls.add_selection_to_event_output_file( eof0, jj, '{}/{}/{}'.format(goc_pop.id, jj, goc_type.id), 'spike') of0 = 'Volts_file' ls.create_output_file(of0, "%s.v.dat" % simid) for jj in range(goc_pop.size): ls.add_column_to_output_file( of0, jj, '{}/{}/{}/v'.format(goc_pop.id, jj, goc_type.id)) #Create Lems file to run lems_simfile = ls.save_to_file() if run: res = pynml.run_lems_with_jneuroml_neuron(lems_simfile, max_memory="2G", nogui=True, plot=False) else: res = pynml.run_lems_with_jneuroml_neuron(lems_simfile, max_memory="2G", only_generate_scripts=True, compile_mods=False, nogui=True, plot=False) return res
net_nml_doc = neuroml.NeuroMLDocument(id=net.id) for ic in nml_doc.ion_channel_hhs: ic_nml_doc = neuroml.NeuroMLDocument(id=ic.id) ic_nml_doc.ion_channel_hhs.append(ic) nml_file = '%s.channel.nml' % ic.id writers.NeuroMLWriter.write(ic_nml_doc, nml_file) print('Saved ion channel to own file at %s' % nml_file) for cell in nml_doc.cells: cell_nml_doc = neuroml.NeuroMLDocument(id=cell.id) cell_nml_doc.cells.append(cell) cd_added = [] for cd in cell.biophysical_properties.membrane_properties.channel_densities: if not cd.ion_channel in cd_added: inc = neuroml.IncludeType('%s.channel.nml' % cd.ion_channel) cell_nml_doc.includes.append(inc) cd_added.append(cd.ion_channel) nml_file = '%s.cell.nml' % cell.id inc = neuroml.IncludeType(nml_file) net_nml_doc.includes.append(inc) writers.NeuroMLWriter.write(cell_nml_doc, nml_file) print('Saved cell to own file at %s' % nml_file) syn_nml_doc = neuroml.NeuroMLDocument(id='HNN_Synapses') for syn in nml_doc.exp_two_synapses: syn_nml_doc.exp_two_synapses.append(syn) nml_file = '%s.nml' % syn_nml_doc.id writers.NeuroMLWriter.write(syn_nml_doc, nml_file) print('Saved synapses to own file at %s' % nml_file)
intracellular_properties = neuroml.IntracellularProperties( resistivities=resistivities) bp = neuroml.BiophysicalProperties( id="biophys", intracellular_properties=intracellular_properties, membrane_properties=membrane_properties) cell.biophysical_properties = bp cell.id = 'BC2_na_k' nml_doc2 = neuroml.NeuroMLDocument(id=cell.id) nml_doc2.includes.append(neuroml.IncludeType('pas.channel.nml')) nml_doc2.includes.append( neuroml.IncludeType('channelConvert/Na_BC.channel.nml')) nml_doc2.includes.append( neuroml.IncludeType('channelConvert/K_BC.channel.nml')) nml_doc2.cells.append(cell) nml_file = cell.id + '.cell.nml' writers.NeuroMLWriter.write(nml_doc2, nml_file) print("Saved modified morphology file to: " + nml_file) ###### Validate the NeuroML ###### from neuroml.utils import validate_neuroml2
import neuroml import neuroml.writers as writers import pprint pp = pprint.PrettyPrinter(depth=6) if __name__ == '__main__': root_dir = 'test_data/ca1' cell_file = 'cells/olm.cell.nml' cell_comp = 'olmcell' reference = 'TestOLMChannels' nml_doc = neuroml.NeuroMLDocument(id=reference) incl = neuroml.IncludeType(cell_file) nml_doc.includes.append(incl) net = neuroml.Network(id=reference) net.notes = "A test network model: %s" % reference net.temperature = '35degC' nml_doc.networks.append(net) pop = neuroml.Population(id="%sPop" % cell_comp, component=cell_comp, size=1, type="populationList") inst = neuroml.Instance(id=0) pop.instances.append(inst)
def create_GoC_network(duration=2000, dt=0.025, seed=123, runid=0, run=False): keepFile = open('useParams_FI_14_25.pkl', 'rb') runid = pkl.load(keepFile)[runid] keepFile.close() ### ---------- Component types gocID = 'Golgi_040408_C1_' + format(runid, '05d') goc_filename = '{}.cell.nml'.format(gocID) goc_type = pynml.read_neuroml2_file(goc_filename).cells[0] ### --------- Populations # Build network to specify cells and connectivity net = nml.Network(id='MorphoNet_' + format(runid, '05d'), type="networkWithTemperature", temperature="23 degC") # Create GoC population goc_pop = nml.Population(id=goc_type.id + "Pop", component=goc_type.id, type="populationList", size=1) inst = nml.Instance(id=0) goc_pop.instances.append(inst) inst.location = nml.Location(x=0, y=0, z=0) net.populations.append(goc_pop) # Create NML document for network specification net_doc = nml.NeuroMLDocument(id=net.id) net_doc.networks.append(net) net_doc.includes.append(nml.IncludeType(href=goc_filename)) ### -------------- Write files net_filename = 'Morpho1_' + format(runid, '05d') + '.nml' pynml.write_neuroml2_file(net_doc, net_filename) simid = 'sim_morpho1_' + goc_type.id ls = LEMSSimulation(simid, duration=duration, dt=dt, simulation_seed=seed) ls.assign_simulation_target(net.id) ls.include_neuroml2_file(net_filename) ls.include_neuroml2_file(goc_filename) # Specify outputs eof0 = 'Events_file' ls.create_event_output_file(eof0, "%s.v.spikes" % simid, format='ID_TIME') for jj in range(goc_pop.size): ls.add_selection_to_event_output_file( eof0, jj, '{}/{}/{}'.format(goc_pop.id, jj, goc_type.id), 'spike') of0 = 'Volts_file' ls.create_output_file(of0, "%s.v.dat" % simid) for jj in range(goc_pop.size): ls.add_column_to_output_file( of0, jj, '{}/{}/{}/v'.format(goc_pop.id, jj, goc_type.id)) #Create Lems file to run lems_simfile = ls.save_to_file() if run: res = pynml.run_lems_with_jneuroml_neuron(lems_simfile, max_memory="2G", nogui=True, plot=False) else: res = pynml.run_lems_with_jneuroml_neuron(lems_simfile, max_memory="2G", only_generate_scripts=True, compile_mods=False, nogui=True, plot=False) return res
def create_GoC_network(duration=2000, dt=0.025, seed=123, runid=0, run=False, minI=-75, maxI=200, iStep=25, iDur=400, iRest=500): file = open('useParams_SpontFreq_7_pm_2.pkl', 'rb') use_params = pkl.load(file)["useParams"] file.close() runid = use_params[0][runid] print('Using parameter set = ', runid) ### ---------- Component types gocID = 'GoC_' + format(runid, '05d') goc_filename = '{}.cell.nml'.format(gocID) goc_type = pynml.read_neuroml2_file(goc_filename).cells[0] ### --------- Populations # Build network to specify cells and connectivity net = nml.Network(id='GoCNet_' + format(runid, '05d'), type="networkWithTemperature", temperature="23 degC") # Create GoC population goc_pop = nml.Population(id=goc_type.id + "Pop", component=goc_type.id, type="populationList", size=1) inst = nml.Instance(id=0) goc_pop.instances.append(inst) inst.location = nml.Location(x=0, y=0, z=0) net.populations.append(goc_pop) # Create NML document for network specification net_doc = nml.NeuroMLDocument(id=net.id) net_doc.networks.append(net) net_doc.includes.append(nml.IncludeType(href=goc_filename)) # Add Current Injection ctr = 0 goc = 0 p = { "iAmp": np.arange(minI, maxI + iStep / 2, iStep), "iDuration": iDur, "iRest": iRest } p["nSteps"] = p["iAmp"].shape[0] for jj in range(p["nSteps"]): input_id = 'stim_{}'.format(ctr) istep = nml.PulseGenerator(id=input_id, delay='{} ms'.format(p["iDuration"] * jj + p["iRest"] * (jj + 1)), duration='{} ms'.format(p["iDuration"]), amplitude='{} pA'.format(p["iAmp"][jj])) net_doc.pulse_generators.append(istep) input_list = nml.InputList(id='ilist_{}'.format(ctr), component=istep.id, populations=goc_pop.id) curr_inj = nml.Input('0', target="../%s[%i]" % (goc_pop.id, goc), destination="synapses") input_list.input.append(curr_inj) net.input_lists.append(input_list) ctr += 1 ### -------------- Write files net_filename = 'GoCNet_istep_' + format(runid, '05d') + '.nml' pynml.write_neuroml2_file(net_doc, net_filename) simid = 'sim_gocnet_istep_' + goc_type.id ls = LEMSSimulation(simid, duration=duration, dt=dt, simulation_seed=seed) ls.assign_simulation_target(net.id) ls.include_neuroml2_file(net_filename) ls.include_neuroml2_file(goc_filename) # Specify outputs eof0 = 'Events_file' ls.create_event_output_file(eof0, "%s.v.spikes" % simid, format='ID_TIME') for jj in range(goc_pop.size): ls.add_selection_to_event_output_file( eof0, jj, '{}/{}/{}'.format(goc_pop.id, jj, goc_type.id), 'spike') of0 = 'Volts_file' ls.create_output_file(of0, "%s.v.dat" % simid) for jj in range(goc_pop.size): ls.add_column_to_output_file( of0, jj, '{}/{}/{}/v'.format(goc_pop.id, jj, goc_type.id)) #Create Lems file to run lems_simfile = ls.save_to_file() if run: res = pynml.run_lems_with_jneuroml_neuron(lems_simfile, max_memory="2G", nogui=True, plot=False) else: res = pynml.run_lems_with_jneuroml_neuron(lems_simfile, max_memory="2G", only_generate_scripts=True, compile_mods=False, nogui=True, plot=False) return res
notes = '' notes+="\n\nExport of a cell model obtained from the BBP Neocortical Microcircuit Collaboration Portal into NeuroML2"+\ "\n\n******************************************************\n* This export to NeuroML2 has not yet been fully validated!!"+ \ "\n* Use with caution!!\n******************************************************\n\n" if len(ignore_chans) > 0: notes += "Ignored channels = %s\n\n" % ignore_chans notes+="For more information on this cell model see: "+\ "https://bbp.epfl.ch/nmc-portal/microcircuit#/metype/%s/details\n\n"%cell_info['me-type'] cell.notes = notes for channel in incl_chans: nml_doc.includes.append(neuroml.IncludeType(href="%s" % channel)) if make_zips: print("Copying %s to zip folder" % channel) shutil.copyfile('../../NeuroML2/%s' % channel, '%s/%s' % (nml2_cell_dir, channel)) pynml.write_neuroml2_file(nml_doc, nml_cell_loc) stim_ref = 'stepcurrent3' stim_ref_hyp = '%s_hyp' % stim_ref stim_sim_duration = 3000 stim_hyp_amp, stim_amp = get_stimulus_amplitudes(bbp_ref) stim_del = '700ms' stim_dur = '2000ms'
def create_GoC_network( duration, dt, seed, runid, run=False): ### ---------- Load Params noPar = True pfile = Path('params_file.pkl') if pfile.exists(): print('Reading parameters from file:') file = open('params_file.pkl','rb') params_list = pkl.load(file) if len(params_list)>runid: p = params_list[runid] file.close() if noPar: p = inp.get_simulation_params( runid ) ### ---------- Component types goc_filename = 'GoC.cell.nml' # Golgi cell with channels goc_file = pynml.read_neuroml2_file( goc_filename ) goc_type = goc_file.cells[0] goc_ref = nml.IncludeType( href=goc_filename ) MFSyn_filename = 'MF_GoC_Syn.nml' # small conductance synapse for background inputs mfsyn_file = pynml.read_neuroml2_file( MFSyn_filename ) MFSyn_type = mfsyn_file.exp_three_synapses[0] mfsyn_ref = nml.IncludeType( href=MFSyn_filename ) MF20Syn_filename = 'MF_GoC_SynMult.nml' # multi-syn conductance for strong/coincident transient input mf20syn_file = pynml.read_neuroml2_file( MF20Syn_filename ) MF20Syn_type = mf20syn_file.exp_three_synapses[0] mf20syn_ref = nml.IncludeType( href=MF20Syn_filename ) mf_type2 = 'spikeGeneratorPoisson' # Spike source for background inputs mf_poisson = nml.SpikeGeneratorPoisson( id = "MF_Poisson", average_rate="5 Hz" ) # Not tuned to any data - qqq ! mf_bursttype = 'transientPoissonFiringSynapse' # Burst of MF input (as explicit input) mf_burst = nml.TransientPoissonFiringSynapse( id="MF_Burst", average_rate="100 Hz", delay="2000 ms", duration="500 ms", synapse=MF20Syn_type.id, spike_target='./{}'.format(MF20Syn_type.id) ) gj = nml.GapJunction( id="GJ_0", conductance="426pS" ) # GoC synapse ### --------- Populations # Build network to specify cells and connectivity net = nml.Network( id="gocNetwork", type="networkWithTemperature" , temperature="23 degC" ) # Create GoC population goc_pop = nml.Population( id=goc_type.id+"Pop", component = goc_type.id, type="populationList", size=p["nGoC"] ) for goc in range( p["nGoC"] ): inst = nml.Instance( id=goc ) goc_pop.instances.append( inst ) inst.location = nml.Location( x=p["GoC_pos"][goc,0], y=p["GoC_pos"][goc,1], z=p["GoC_pos"][goc,2] ) net.populations.append( goc_pop ) ### MF population MF_Poisson_pop = nml.Population(id=mf_poisson.id+"_pop", component=mf_poisson.id, type="populationList", size=p["nMF"]) for mf in range( p["nMF"] ): inst = nml.Instance(id=mf) MF_Poisson_pop.instances.append( inst ) inst.location = nml.Location( x=p["MF_pos"][mf,0], y=p["MF_pos"][mf,1], z=p["MF_pos"][mf,2] ) net.populations.append( MF_Poisson_pop ) # Create NML document for network specification net_doc = nml.NeuroMLDocument( id=net.id ) net_doc.networks.append( net ) net_doc.includes.append( goc_ref ) net_doc.includes.append( mfsyn_ref ) net_doc.includes.append( mf20syn_ref ) net_doc.spike_generator_poissons.append( mf_poisson ) net_doc.transient_poisson_firing_synapses.append( mf_burst ) net_doc.gap_junctions.append(gj) ### ------------ Connectivity ### 1. Background excitatory inputs: MF to GoC populations MFProjection = nml.Projection(id="MFtoGoC", presynaptic_population=MF_Poisson_pop.id, postsynaptic_population=goc_pop.id, synapse=MFSyn_type.id) net.projections.append(MFProjection) # MF_> GoC synapses (with syn_count equivalent to integer scaling of Mf synapse strength) nMFSyn = p["MF_GoC_pairs"].shape[1] ctr=0 for syn in range( nMFSyn ): mf, goc = p["MF_GoC_pairs"][:, syn] for syn_count in range(p["MF_GoC_wt"][ctr]): conn2 = nml.Connection(id=ctr, pre_cell_id='../{}/{}/{}'.format(MF_Poisson_pop.id, mf, mf_poisson.id), post_cell_id='../{}/{}/{}'.format(goc_pop.id, goc, goc_type.id), post_segment_id='0', post_fraction_along="0.5") #on soma MFProjection.connections.append(conn2) ctr+=1 ### 2. Perturbation as High Freq MF Inputs ctr=0 for goc in p["Burst_GoC"]: for jj in range( p["nBurst"] ): # Each Perturbed GoC gets nBurst random Burst sources inst = nml.ExplicitInput( id=ctr, target='../{}/{}/{}'.format(goc_pop.id, goc, goc_type.id), input=mf_burst.id, synapse=MF20Syn_type.id, spikeTarget='./{}'.format(MF20Syn_type.id)) net.explicit_inputs.append( inst ) ctr += 1 ### 3. Electrical coupling between GoCs GoCCoupling = nml.ElectricalProjection( id="gocGJ", presynaptic_population=goc_pop.id, postsynaptic_population=goc_pop.id ) net.electrical_projections.append( GoCCoupling ) dend_id = [1,2,5] for jj in range( p["GJ_pairs"].shape[0] ): conn = nml.ElectricalConnectionInstanceW( id=jj, pre_cell='../{}/{}/{}'.format(goc_pop.id, p["GJ_pairs"][jj,0], goc_type.id), pre_segment=dend_id[p["GJ_loc"][jj,0]], pre_fraction_along='0.5', post_cell='../{}/{}/{}'.format(goc_pop.id, p["GJ_pairs"][jj,1], goc_type.id), post_segment=dend_id[p["GJ_loc"][jj,1]], post_fraction_along='0.5', synapse=gj.id, weight=p["GJ_wt"][jj] ) GoCCoupling.electrical_connection_instance_ws.append( conn ) ### -------------- Write files net_filename = 'gocNetwork.nml' pynml.write_neuroml2_file( net_doc, net_filename ) simid = 'sim_gocnet_'+goc_type.id+'_run_{}'.format(runid) ls = LEMSSimulation( simid, duration=duration, dt=dt, simulation_seed=seed ) ls.assign_simulation_target( net.id ) ls.include_neuroml2_file( net_filename) ls.include_neuroml2_file( goc_filename) ls.include_neuroml2_file( MFSyn_filename) ls.include_neuroml2_file( MF20Syn_filename) # Specify outputs eof0 = 'Events_file' ls.create_event_output_file(eof0, "%s.v.spikes"%simid,format='ID_TIME') for jj in range( goc_pop.size): ls.add_selection_to_event_output_file( eof0, jj, '{}/{}/{}'.format( goc_pop.id, jj, goc_type.id), 'spike' ) of0 = 'Volts_file' ls.create_output_file(of0, "%s.v.dat"%simid) for jj in range( goc_pop.size ): ls.add_column_to_output_file(of0, jj, '{}/{}/{}/v'.format( goc_pop.id, jj, goc_type.id)) #Create Lems file to run lems_simfile = ls.save_to_file() if run: res = pynml.run_lems_with_jneuroml_neuron( lems_simfile, max_memory="2G", nogui=True, plot=False) else: res = pynml.run_lems_with_jneuroml_neuron( lems_simfile, max_memory="2G", only_generate_scripts = True, compile_mods = False, nogui=True, plot=False) return res
def generate_WB_network(cell_id, synapse_id, numCells_bc, connection_probability, I_mean, I_sigma, generate_LEMS_simulation, duration, x_size=100, y_size=100, z_size=100, network_id=ref + 'Network', color='0 0 1', connection=True, temperature='37 degC', validate=True, dt=0.01): nml_doc = neuroml.NeuroMLDocument(id=network_id) nml_doc.includes.append(neuroml.IncludeType(href='WangBuzsaki.cell.nml')) nml_doc.includes.append(neuroml.IncludeType(href='WangBuzsakiSynapse.xml')) # Create network net = neuroml.Network(id=network_id, type='networkWithTemperature', temperature=temperature) net.notes = 'Network generated using libNeuroML v%s' % __version__ nml_doc.networks.append(net) # Create population pop = neuroml.Population(id=ref + 'pop', component=cell_id, type='populationList', size=numCells_bc) if color is not None: pop.properties.append(neuroml.Property('color', color)) net.populations.append(pop) for i in range(0, numCells_bc): inst = neuroml.Instance(id=i) pop.instances.append(inst) inst.location = neuroml.Location(x=str(x_size * rnd.random()), y=str(y_size * rnd.random()), z=str(z_size * rnd.random())) # Add connections proj = neuroml.ContinuousProjection(id=ref + 'proj', presynaptic_population=pop.id, postsynaptic_population=pop.id) conn_count = 0 for i in range(0, numCells_bc): for j in range(0, numCells_bc): if i != j and rnd.random() < connection_probability: connection = neuroml.ContinuousConnectionInstance( id=conn_count, pre_cell='../%s/%i/%s' % (pop.id, i, cell_id), pre_component='silent', post_cell='../%s/%i/%s' % (pop.id, j, cell_id), post_component=synapse_id) proj.continuous_connection_instances.append(connection) conn_count += 1 net.continuous_projections.append(proj) # make cell pop inhomogenouos (different V_init-s with voltage-clamp) vc_dur = 2 # ms for i in range(0, numCells_bc): tmp = -75 + (rnd.random() * 15) vc = neuroml.VoltageClamp(id='VClamp%i' % i, delay='0ms', duration='%ims' % vc_dur, simple_series_resistance='1e6ohm', target_voltage='%imV' % tmp) nml_doc.voltage_clamps.append(vc) input_list = neuroml.InputList(id='input_%i' % i, component='VClamp%i' % i, populations=pop.id) input = neuroml.Input(id=i, target='../%s/%i/%s' % (pop.id, i, cell_id), destination='synapses') input_list.input.append(input) net.input_lists.append(input_list) # Add outer input (IClamp) tmp = rnd.normal(I_mean, I_sigma**2, numCells_bc) # random numbers from Gaussian distribution for i in range(0, numCells_bc): pg = neuroml.PulseGenerator(id='IClamp%i' % i, delay='%ims' % vc_dur, duration='%ims' % (duration - vc_dur), amplitude='%fpA' % (tmp[i])) nml_doc.pulse_generators.append(pg) input_list = neuroml.InputList(id='input%i' % i, component='IClamp%i' % i, populations=pop.id) input = neuroml.Input(id=i, target='../%s/%i/%s' % (pop.id, i, cell_id), destination='synapses') input_list.input.append(input) net.input_lists.append(input_list) # Write to file nml_file = '%s100Cells.net.nml' % ref print 'Writing network file to:', nml_file, '...' neuroml.writers.NeuroMLWriter.write(nml_doc, nml_file) if validate: # Validate the NeuroML from neuroml.utils import validate_neuroml2 validate_neuroml2(nml_file) if generate_LEMS_simulation: # Vreate a LEMSSimulation to manage creation of LEMS file ls = LEMSSimulation(sim_id='%sNetSim' % ref, duration=duration, dt=dt) # Point to network as target of simulation ls.assign_simulation_target(net.id) # Incude generated/existing NeuroML2 files ls.include_neuroml2_file('WangBuzsaki.cell.nml', include_included=False) ls.include_neuroml2_file('WangBuzsakiSynapse.xml', include_included=False) ls.include_neuroml2_file(nml_file, include_included=False) # Specify Display and output files disp_bc = 'display_bc' ls.create_display(disp_bc, 'Basket Cell Voltage trace', '-80', '40') of_bc = 'volts_file_bc' ls.create_output_file(of_bc, 'wangbuzsaki_network.dat') of_spikes_bc = 'spikes_bc' ls.create_event_output_file(of_spikes_bc, 'wangbuzsaki_network_spikes.dat') max_traces = 9 # the 10th color in NEURON is white ... for i in range(numCells_bc): quantity = '%s/%i/%s/v' % (pop.id, i, cell_id) if i < max_traces: ls.add_line_to_display(disp_bc, 'BC %i: Vm' % i, quantity, '1mV', pynml.get_next_hex_color()) ls.add_column_to_output_file(of_bc, 'v_%i' % i, quantity) ls.add_selection_to_event_output_file(of_spikes_bc, i, select='%s/%i/%s' % (pop.id, i, cell_id), event_port='spike') # Save to LEMS file print 'Writing LEMS file...' lems_file_name = ls.save_to_file() else: ls = None lems_file_name = '' return ls, lems_file_name
def generate_Vm_vs_time_plot(nml2_file, cell_id, inj_amp_nA=80, delay_ms=20, inj_dur_ms=60, sim_dur_ms=100, dt=0.05, plot_voltage_traces=False, show_plot_already=True, simulator="jNeuroML", include_included=True): ref = "Test" print_comment_v( "Generating Vm(mV) vs Time(ms) plot for cell %s in %s using %s (Inj %snA / %sms dur after %sms delay)" % (cell_id, nml2_file, simulator, inj_amp_nA, inj_dur_ms, delay_ms)) sim_id = 'Vm_%s' % ref duration = sim_dur_ms ls = LEMSSimulation(sim_id, sim_dur_ms, dt) ls.include_neuroml2_file(nml2_file, include_included=include_included) ls.assign_simulation_target('network') nml_doc = nml.NeuroMLDocument(id=cell_id) nml_doc.includes.append(nml.IncludeType(href=nml2_file)) net = nml.Network(id="network") nml_doc.networks.append(net) input_id = ("input_%s" % str(inj_amp_nA).replace('.', '_')) pg = nml.PulseGenerator(id=input_id, delay="%sms" % delay_ms, duration='%sms' % inj_dur_ms, amplitude='%spA' % inj_amp_nA) nml_doc.pulse_generators.append(pg) pop_id = 'hhpop' pop = nml.Population(id=pop_id, component='hhcell', size=1, type="populationList") inst = nml.Instance(id=0) pop.instances.append(inst) inst.location = nml.Location(x=0, y=0, z=0) net.populations.append(pop) # Add these to cells input_list = nml.InputList(id='il_%s' % input_id, component=pg.id, populations=pop_id) input = nml.Input(id='0', target='../hhpop/0/hhcell', destination="synapses") input_list.input.append(input) net.input_lists.append(input_list) sim_file_name = '%s.sim.nml' % sim_id pynml.write_neuroml2_file(nml_doc, sim_file_name) ls.include_neuroml2_file(sim_file_name) disp0 = 'Voltage_display' ls.create_display(disp0, "Voltages", "-90", "50") ls.add_line_to_display(disp0, "V", "hhpop/0/hhcell/v", scale='1mV') of0 = 'Volts_file' ls.create_output_file(of0, "%s.v.dat" % sim_id) ls.add_column_to_output_file(of0, "V", "hhpop/0/hhcell/v") lems_file_name = ls.save_to_file() if simulator == "jNeuroML": results = pynml.run_lems_with_jneuroml(lems_file_name, nogui=True, load_saved_data=True, plot=plot_voltage_traces, show_plot_already=False) elif simulator == "jNeuroML_NEURON": results = pynml.run_lems_with_jneuroml_neuron(lems_file_name, nogui=True, load_saved_data=True, plot=plot_voltage_traces, show_plot_already=False) if show_plot_already: from matplotlib import pyplot as plt plt.show() return of0
new_id = '%s_%s' % (type, dataset) new_cell_doc = neuroml.NeuroMLDocument(id=new_id) cell.id = new_id cell.notes = "Cell model tuned to Allen Institute Cell Types Database, dataset: "+ \ "%s\n\nTuning procedure metadata:\n\n%s\n"%(dataset, pp.pformat(r2)) new_cell_doc.cells.append(cell) new_cell_file = 'tuned_cells/%s.cell.nml' % new_id channel_files = [ 'IM.channel.nml', 'Kd.channel.nml', 'Leak.channel.nml', 'Na.channel.nml' ] for ch in channel_files: new_cell_doc.includes.append(neuroml.IncludeType(ch)) pynml.write_neuroml2_file(new_cell_doc, new_cell_file) else: print("Options to try:\n\n (Izhikevich cell model)") print( " python tuneAllen.py -izhone (run one Izhikevich cell with typical values)" ) print( " python tuneAllen.py -izhmone (run multiple Izhikevich cells with different current inputs)" ) print( " python tuneAllen.py -izhquick (quick optimisation example using Izhikevich cell)" )
def generate_current_vs_frequency_curve(nml2_file, cell_id, start_amp_nA, end_amp_nA, step_nA, analysis_duration, analysis_delay, dt=0.05, temperature="32degC", spike_threshold_mV=0., plot_voltage_traces=False, plot_if=True, plot_iv=False, xlim_if=None, ylim_if=None, xlim_iv=None, ylim_iv=None, show_plot_already=True, save_if_figure_to=None, save_iv_figure_to=None, simulator="jNeuroML", include_included=True): from pyelectro.analysis import max_min from pyelectro.analysis import mean_spike_frequency import numpy as np print_comment_v( "Generating FI curve for cell %s in %s using %s (%snA->%snA; %snA steps)" % (cell_id, nml2_file, simulator, start_amp_nA, end_amp_nA, step_nA)) sim_id = 'iv_%s' % cell_id duration = analysis_duration + analysis_delay ls = LEMSSimulation(sim_id, duration, dt) ls.include_neuroml2_file(nml2_file, include_included=include_included) stims = [] amp = start_amp_nA while amp <= end_amp_nA: stims.append(amp) amp += step_nA number_cells = len(stims) pop = nml.Population(id="population_of_%s" % cell_id, component=cell_id, size=number_cells) # create network and add populations net_id = "network_of_%s" % cell_id net = nml.Network(id=net_id, type="networkWithTemperature", temperature=temperature) ls.assign_simulation_target(net_id) net_doc = nml.NeuroMLDocument(id=net.id) net_doc.networks.append(net) net_doc.includes.append(nml.IncludeType(nml2_file)) net.populations.append(pop) for i in range(number_cells): stim_amp = "%snA" % stims[i] input_id = ("input_%s" % stim_amp).replace('.', '_').replace('-', 'min') pg = nml.PulseGenerator(id=input_id, delay="0ms", duration="%sms" % duration, amplitude=stim_amp) net_doc.pulse_generators.append(pg) # Add these to cells input_list = nml.InputList(id=input_id, component=pg.id, populations=pop.id) input = nml.Input(id='0', target="../%s[%i]" % (pop.id, i), destination="synapses") input_list.input.append(input) net.input_lists.append(input_list) net_file_name = '%s.net.nml' % sim_id pynml.write_neuroml2_file(net_doc, net_file_name) ls.include_neuroml2_file(net_file_name) disp0 = 'Voltage_display' ls.create_display(disp0, "Voltages", "-90", "50") of0 = 'Volts_file' ls.create_output_file(of0, "%s.v.dat" % sim_id) for i in range(number_cells): ref = "v_cell%i" % i quantity = "%s[%i]/v" % (pop.id, i) ls.add_line_to_display(disp0, ref, quantity, "1mV", pynml.get_next_hex_color()) ls.add_column_to_output_file(of0, ref, quantity) lems_file_name = ls.save_to_file() if simulator == "jNeuroML": results = pynml.run_lems_with_jneuroml(lems_file_name, nogui=True, load_saved_data=True, plot=plot_voltage_traces, show_plot_already=False) elif simulator == "jNeuroML_NEURON": results = pynml.run_lems_with_jneuroml_neuron(lems_file_name, nogui=True, load_saved_data=True, plot=plot_voltage_traces, show_plot_already=False) #print(results.keys()) if_results = {} iv_results = {} for i in range(number_cells): t = np.array(results['t']) * 1000 v = np.array(results["%s[%i]/v" % (pop.id, i)]) * 1000 mm = max_min(v, t, delta=0, peak_threshold=spike_threshold_mV) spike_times = mm['maxima_times'] freq = 0 if len(spike_times) > 2: count = 0 for s in spike_times: if s >= analysis_delay and s < (analysis_duration + analysis_delay): count += 1 freq = 1000 * count / float(analysis_duration) mean_freq = mean_spike_frequency(spike_times) # print("--- %s nA, spike times: %s, mean_spike_frequency: %f, freq (%fms -> %fms): %f"%(stims[i],spike_times, mean_freq, analysis_delay, analysis_duration+analysis_delay, freq)) if_results[stims[i]] = freq if freq == 0: iv_results[stims[i]] = v[-1] if plot_if: stims = sorted(if_results.keys()) stims_pA = [ii * 1000 for ii in stims] freqs = [if_results[s] for s in stims] pynml.generate_plot([stims_pA], [freqs], "Frequency versus injected current for: %s" % nml2_file, colors=['k'], linestyles=['-'], markers=['o'], xaxis='Input current (pA)', yaxis='Firing frequency (Hz)', xlim=xlim_if, ylim=ylim_if, grid=True, show_plot_already=False, save_figure_to=save_if_figure_to) if plot_iv: stims = sorted(iv_results.keys()) stims_pA = [ii * 1000 for ii in sorted(iv_results.keys())] vs = [iv_results[s] for s in stims] pynml.generate_plot( [stims_pA], [vs], "Final membrane potential versus injected current for: %s" % nml2_file, colors=['k'], linestyles=['-'], markers=['o'], xaxis='Input current (pA)', yaxis='Membrane potential (mV)', xlim=xlim_iv, ylim=ylim_iv, grid=True, show_plot_already=False, save_figure_to=save_iv_figure_to) if show_plot_already: from matplotlib import pyplot as plt plt.show() return if_results
def include_neuroml2_file(nml_doc, nml2_file_path): """ Add a NeuroML2 file containing definitions of elements which can be used in the network """ nml_doc.includes.append(neuroml.IncludeType(nml2_file_path))
def create_GoC(runid): ### ---------- Load Params noPar = True pfile = Path('cellparams_file.pkl') keepFile = open('useParams_FI_14_25.pkl', 'rb') runid = pkl.load(keepFile)[runid] keepFile.close() print('Running morphology for parameter set = ', runid) if pfile.exists(): print('Reading parameters from file:') file = open('cellparams_file.pkl', 'rb') params_list = pkl.load(file) if len(params_list) > runid: p = params_list[runid] file.close() if noPar: p = icp.get_channel_params(runid) # Creating document for cell gocID = 'Golgi_040408_C1_' + format(runid, '05d') goc = nml.Cell(id=gocID) #--------simid cell_doc = nml.NeuroMLDocument(id=gocID) cell_doc.cells.append(goc) ### Load morphology morpho_fname = 'Golgi_040408_C1.cell.nml' morpho_file = pynml.read_neuroml2_file(morpho_fname) morpho = morpho_file.cells[0].morphology cell_doc.includes.append(nml.IncludeType(href=morpho_fname)) goc.morphology = morpho ### ---------- Channels na_fname = 'Golgi_Na.channel.nml' cell_doc.includes.append(nml.IncludeType(href=na_fname)) nar_fname = 'Golgi_NaR.channel.nml' cell_doc.includes.append(nml.IncludeType(href=nar_fname)) nap_fname = 'Golgi_NaP.channel.nml' cell_doc.includes.append(nml.IncludeType(href=nap_fname)) ka_fname = 'Golgi_KA.channel.nml' cell_doc.includes.append(nml.IncludeType(href=ka_fname)) sk2_fname = 'Golgi_SK2.channel.nml' cell_doc.includes.append(nml.IncludeType(href=sk2_fname)) km_fname = 'Golgi_KM.channel.nml' cell_doc.includes.append(nml.IncludeType(href=km_fname)) kv_fname = 'Golgi_KV.channel.nml' cell_doc.includes.append(nml.IncludeType(href=kv_fname)) bk_fname = 'Golgi_BK.channel.nml' cell_doc.includes.append(nml.IncludeType(href=bk_fname)) cahva_fname = 'Golgi_CaHVA.channel.nml' cell_doc.includes.append(nml.IncludeType(href=cahva_fname)) calva_fname = 'Golgi_CaLVA.channel.nml' cell_doc.includes.append(nml.IncludeType(href=calva_fname)) hcn1f_fname = 'Golgi_HCN1f.channel.nml' cell_doc.includes.append(nml.IncludeType(href=hcn1f_fname)) hcn1s_fname = 'Golgi_HCN1s.channel.nml' cell_doc.includes.append(nml.IncludeType(href=hcn1s_fname)) hcn2f_fname = 'Golgi_HCN2f.channel.nml' cell_doc.includes.append(nml.IncludeType(href=hcn2f_fname)) hcn2s_fname = 'Golgi_HCN2s.channel.nml' cell_doc.includes.append(nml.IncludeType(href=hcn2s_fname)) leak_fname = 'Golgi_lkg.channel.nml' #leak_ref = nml.IncludeType( href=leak_fname) cell_doc.includes.append(nml.IncludeType(href=leak_fname)) calc_fname = 'Golgi_CALC.nml' cell_doc.includes.append(nml.IncludeType(href=calc_fname)) calc = pynml.read_neuroml2_file( calc_fname).decaying_pool_concentration_models[0] calc2_fname = 'Golgi_CALC2.nml' cell_doc.includes.append(nml.IncludeType(href=calc2_fname)) goc_2pools_fname = 'GoC_2Pools.cell.nml' ### ------Biophysical Properties biophys = nml.BiophysicalProperties(id='biophys_' + gocID) goc.biophysical_properties = biophys # Inproperties ''' res = nml.Resistivity( p["ra"] ) # --------- "0.1 kohm_cm" ca_species = nml.Species( id="ca", ion="ca", concentration_model=calc.id, initial_concentration ="5e-5 mM", initial_ext_concentration="2 mM" ) ca2_species = nml.Species( id="ca2", ion="ca2", concentration_model="Golgi_CALC2", initial_concentration ="5e-5 mM", initial_ext_concentration="2 mM" ) intracellular = nml.IntracellularProperties( ) intracellular.resistivities.append( res ) intracellular.species.append( ca_species ) ''' intracellular = pynml.read_neuroml2_file(goc_2pools_fname).cells[ 0].biophysical_properties.intracellular_properties biophys.intracellular_properties = intracellular # Membrane properties ------- cond memb = nml.MembraneProperties() biophys.membrane_properties = memb #pynml.read_neuroml2_file(leak_fname).ion_channel[0].id -> can't read ion channel passive chan_leak = nml.ChannelDensity(ion_channel="LeakConductance", cond_density=p["leak_cond"], erev="-55 mV", ion="non_specific", id="Leak") memb.channel_densities.append(chan_leak) chan_na = nml.ChannelDensity( ion_channel=pynml.read_neuroml2_file(na_fname).ion_channel[0].id, cond_density=p["na_cond"], erev="87.39 mV", ion="na", id="Golgi_Na_soma_group", segment_groups="soma_group") memb.channel_densities.append(chan_na) chan_nap = nml.ChannelDensity( ion_channel=pynml.read_neuroml2_file(nap_fname).ion_channel[0].id, cond_density=p["nap_cond"], erev="87.39 mV", ion="na", id="Golgi_NaP_soma_group", segment_groups="soma_group") memb.channel_densities.append(chan_nap) chan_nar = nml.ChannelDensity( ion_channel=pynml.read_neuroml2_file(nar_fname).ion_channel[0].id, cond_density=p["nar_cond"], erev="87.39 mV", ion="na", id="Golgi_NaR_soma_group", segment_groups="soma_group") memb.channel_densities.append(chan_nar) chan_ka = nml.ChannelDensity( ion_channel=pynml.read_neuroml2_file(ka_fname).ion_channel[0].id, cond_density=p["ka_cond"], erev="-84.69 mV", ion="k", id="Golgi_KA_soma_group", segment_groups="soma_group") memb.channel_densities.append(chan_ka) chan_sk = nml.ChannelDensity( ion_channel=pynml.read_neuroml2_file(sk2_fname).ion_channel_kses[0].id, cond_density=p["sk2_cond"], erev="-84.69 mV", ion="k", id="Golgi_KAHP_soma_group", segment_groups="soma_group") memb.channel_densities.append(chan_sk) chan_kv = nml.ChannelDensity( ion_channel=pynml.read_neuroml2_file(kv_fname).ion_channel[0].id, cond_density=p["kv_cond"], erev="-84.69 mV", ion="k", id="Golgi_KV_soma_group", segment_groups="soma_group") memb.channel_densities.append(chan_kv) chan_km = nml.ChannelDensity( ion_channel=pynml.read_neuroml2_file(km_fname).ion_channel[0].id, cond_density=p["km_cond"], erev="-84.69 mV", ion="k", id="Golgi_KM_soma_group", segment_groups="soma_group") memb.channel_densities.append(chan_km) chan_bk = nml.ChannelDensity( ion_channel=pynml.read_neuroml2_file(bk_fname).ion_channel[0].id, cond_density=p["bk_cond"], erev="-84.69 mV", ion="k", id="Golgi_BK_soma_group", segment_groups="soma_group") memb.channel_densities.append(chan_bk) chan_h1f = nml.ChannelDensity( ion_channel=pynml.read_neuroml2_file(hcn1f_fname).ion_channel[0].id, cond_density=p["hcn1f_cond"], erev="-20 mV", ion="h", id="Golgi_hcn1f_soma_group", segment_groups="soma_group") memb.channel_densities.append(chan_h1f) chan_h1s = nml.ChannelDensity( ion_channel=pynml.read_neuroml2_file(hcn1s_fname).ion_channel[0].id, cond_density=p["hcn1s_cond"], erev="-20 mV", ion="h", id="Golgi_hcn1s_soma_group", segment_groups="soma_group") memb.channel_densities.append(chan_h1s) chan_h2f = nml.ChannelDensity( ion_channel=pynml.read_neuroml2_file(hcn2f_fname).ion_channel[0].id, cond_density=p["hcn2f_cond"], erev="-20 mV", ion="h", id="Golgi_hcn2f_soma_group", segment_groups="soma_group") memb.channel_densities.append(chan_h2f) chan_h2s = nml.ChannelDensity( ion_channel=pynml.read_neuroml2_file(hcn2s_fname).ion_channel[0].id, cond_density=p["hcn2s_cond"], erev="-20 mV", ion="h", id="Golgi_hcn2s_soma_group", segment_groups="soma_group") memb.channel_densities.append(chan_h2s) chan_hva = nml.ChannelDensityNernst( ion_channel=pynml.read_neuroml2_file(cahva_fname).ion_channel[0].id, cond_density=p["cahva_cond"], ion="ca", id="Golgi_Ca_HVA_soma_group", segment_groups="soma_group") memb.channel_density_nernsts.append(chan_hva) chan_lva = nml.ChannelDensityNernst( ion_channel=pynml.read_neuroml2_file(calva_fname).ion_channel[0].id, cond_density=p["calva_cond"], ion="ca2", id="Golgi_Ca_LVA_soma_group", segment_groups="soma_group") memb.channel_density_nernsts.append(chan_lva) memb.spike_threshes.append(nml.SpikeThresh("0 mV")) memb.specific_capacitances.append( nml.SpecificCapacitance("1.0 uF_per_cm2")) memb.init_memb_potentials.append(nml.InitMembPotential("-60 mV")) goc_filename = '{}.cell.nml'.format(gocID) pynml.write_neuroml2_file(cell_doc, goc_filename) return True
def export(num_cells_to_export=5): cells = [] for mgid in range(num_cells_to_export): print mgid cells.append(mkmitral(mgid)) nml_net_file = "../NeuroML2/MitralCells/Exported/PartialBulb_%iMTCells.net.nml" % num_cells_to_export export_to_neuroml2(None, nml_net_file, includeBiophysicalProperties=False, separateCellFiles=True) for i in range(num_cells_to_export): print("Processing cell %i out of %i" % (i, num_cells_to_export)) nml_cell_file = "../NeuroML2/MitralCells/Exported/Mitral_0_%i.cell.nml" % i nml_doc = pynml.read_neuroml2_file(nml_cell_file) cell = nml_doc.cells[0] soma_seg = next(seg for seg in cell.morphology.segments if seg.name == "Seg0_soma") initial_seg = next(seg for seg in cell.morphology.segments if seg.name == "Seg0_initialseg") hillock_seg = next(seg for seg in cell.morphology.segments if seg.name == "Seg0_hillock") # Ensure hillock parent is soma hillock_seg.parent.segments = soma_seg.id # Fix initial and hillock segs by moving them to the soma hillock_seg.proximal = pointMovedByOffset(hillock_seg.proximal, soma_seg.distal) hillock_seg.distal = pointMovedByOffset(hillock_seg.distal, soma_seg.distal) initial_seg.proximal = pointMovedByOffset(initial_seg.proximal, soma_seg.distal) initial_seg.distal = pointMovedByOffset(initial_seg.distal, soma_seg.distal) # Set root to id=0 and increment others exportHelper.resetRoot(cell) # TODO: cell.position(x,y,z) used for cell positioning in networks does not work as expected # See: https://github.com/NeuroML/jNeuroML/issues/55 # Skipping the translation for now # # Move everything back to the origin # originOffset = type("", (), dict(x = -soma_seg.proximal.x, y = -soma_seg.proximal.y, z = -soma_seg.proximal.z ))() # # for seg in cell.morphology.segments: # seg.proximal = pointMovedByOffset(seg.proximal, originOffset) # seg.distal = pointMovedByOffset(seg.distal, originOffset) # Replace ModelViewParmSubset_N groups with all, axon, soma, dendrite groups buildStandardSegmentGroups(cell) # Add channel placeholders nml_doc.includes.append( neuroml.IncludeType(href="channelIncludesPLACEHOLDER")) cell.biophysical_properties = neuroml.BiophysicalProperties( id="biophysPLACEHOLDER") # Save the new NML pynml.write_neuroml2_file(nml_doc, nml_cell_file) # Replace placeholders with contents from MitralCell...xml files replaceChannelPlaceholders(nml_cell_file) print("COMPLETED: " + nml_cell_file) print("DONE")
def generate_current_vs_frequency_curve(nml2_file, cell_id, start_amp_nA=-0.1, end_amp_nA=0.1, step_nA=0.01, custom_amps_nA=[], analysis_duration=1000, analysis_delay=0, pre_zero_pulse=0, post_zero_pulse=0, dt=0.05, temperature="32degC", spike_threshold_mV=0., plot_voltage_traces=False, plot_if=True, plot_iv=False, xlim_if=None, ylim_if=None, xlim_iv=None, ylim_iv=None, label_xaxis=True, label_yaxis=True, show_volts_label=True, grid=True, font_size=12, if_iv_color='k', linewidth=1, bottom_left_spines_only=False, show_plot_already=True, save_voltage_traces_to=None, save_if_figure_to=None, save_iv_figure_to=None, save_if_data_to=None, save_iv_data_to=None, simulator="jNeuroML", num_processors=1, include_included=True, title_above_plot=False, return_axes=False, verbose=False): print_comment( "Running generate_current_vs_frequency_curve() on %s (%s)" % (nml2_file, os.path.abspath(nml2_file)), verbose) from pyelectro.analysis import max_min from pyelectro.analysis import mean_spike_frequency import numpy as np traces_ax = None if_ax = None iv_ax = None sim_id = 'iv_%s' % cell_id total_duration = pre_zero_pulse + analysis_duration + analysis_delay + post_zero_pulse pulse_duration = analysis_duration + analysis_delay end_stim = pre_zero_pulse + analysis_duration + analysis_delay ls = LEMSSimulation(sim_id, total_duration, dt) ls.include_neuroml2_file(nml2_file, include_included=include_included) stims = [] if len(custom_amps_nA) > 0: stims = [float(a) for a in custom_amps_nA] stim_info = ['%snA' % float(a) for a in custom_amps_nA] else: amp = start_amp_nA while amp <= end_amp_nA: stims.append(amp) amp += step_nA stim_info = '(%snA->%snA; %s steps of %snA; %sms)' % ( start_amp_nA, end_amp_nA, len(stims), step_nA, total_duration) print_comment_v("Generating an IF curve for cell %s in %s using %s %s" % (cell_id, nml2_file, simulator, stim_info)) number_cells = len(stims) pop = nml.Population(id="population_of_%s" % cell_id, component=cell_id, size=number_cells) # create network and add populations net_id = "network_of_%s" % cell_id net = nml.Network(id=net_id, type="networkWithTemperature", temperature=temperature) ls.assign_simulation_target(net_id) net_doc = nml.NeuroMLDocument(id=net.id) net_doc.networks.append(net) net_doc.includes.append(nml.IncludeType(nml2_file)) net.populations.append(pop) for i in range(number_cells): stim_amp = "%snA" % stims[i] input_id = ("input_%s" % stim_amp).replace('.', '_').replace('-', 'min') pg = nml.PulseGenerator(id=input_id, delay="%sms" % pre_zero_pulse, duration="%sms" % pulse_duration, amplitude=stim_amp) net_doc.pulse_generators.append(pg) # Add these to cells input_list = nml.InputList(id=input_id, component=pg.id, populations=pop.id) input = nml.Input(id='0', target="../%s[%i]" % (pop.id, i), destination="synapses") input_list.input.append(input) net.input_lists.append(input_list) net_file_name = '%s.net.nml' % sim_id pynml.write_neuroml2_file(net_doc, net_file_name) ls.include_neuroml2_file(net_file_name) disp0 = 'Voltage_display' ls.create_display(disp0, "Voltages", "-90", "50") of0 = 'Volts_file' ls.create_output_file(of0, "%s.v.dat" % sim_id) for i in range(number_cells): ref = "v_cell%i" % i quantity = "%s[%i]/v" % (pop.id, i) ls.add_line_to_display(disp0, ref, quantity, "1mV", pynml.get_next_hex_color()) ls.add_column_to_output_file(of0, ref, quantity) lems_file_name = ls.save_to_file() print_comment( "Written LEMS file %s (%s)" % (lems_file_name, os.path.abspath(lems_file_name)), verbose) if simulator == "jNeuroML": results = pynml.run_lems_with_jneuroml(lems_file_name, nogui=True, load_saved_data=True, plot=False, show_plot_already=False, verbose=verbose) elif simulator == "jNeuroML_NEURON": results = pynml.run_lems_with_jneuroml_neuron(lems_file_name, nogui=True, load_saved_data=True, plot=False, show_plot_already=False, verbose=verbose) elif simulator == "jNeuroML_NetPyNE": results = pynml.run_lems_with_jneuroml_netpyne( lems_file_name, nogui=True, load_saved_data=True, plot=False, show_plot_already=False, num_processors=num_processors, verbose=verbose) else: raise Exception( "Sorry, cannot yet run current vs frequency analysis using simulator %s" % simulator) print_comment( "Completed run in simulator %s (results: %s)" % (simulator, results.keys()), verbose) #print(results.keys()) times_results = [] volts_results = [] volts_labels = [] if_results = {} iv_results = {} for i in range(number_cells): t = np.array(results['t']) * 1000 v = np.array(results["%s[%i]/v" % (pop.id, i)]) * 1000 if plot_voltage_traces: times_results.append(t) volts_results.append(v) volts_labels.append("%s nA" % stims[i]) mm = max_min(v, t, delta=0, peak_threshold=spike_threshold_mV) spike_times = mm['maxima_times'] freq = 0 if len(spike_times) > 2: count = 0 for s in spike_times: if s >= pre_zero_pulse + analysis_delay and s < ( pre_zero_pulse + analysis_duration + analysis_delay): count += 1 freq = 1000 * count / float(analysis_duration) mean_freq = mean_spike_frequency(spike_times) #print("--- %s nA, spike times: %s, mean_spike_frequency: %f, freq (%fms -> %fms): %f"%(stims[i],spike_times, mean_freq, analysis_delay, analysis_duration+analysis_delay, freq)) if_results[stims[i]] = freq if freq == 0: if post_zero_pulse == 0: iv_results[stims[i]] = v[-1] else: v_end = None for j in range(len(t)): if v_end == None and t[j] >= end_stim: v_end = v[j] iv_results[stims[i]] = v_end if plot_voltage_traces: traces_ax = pynml.generate_plot( times_results, volts_results, "Membrane potential traces for: %s" % nml2_file, xaxis='Time (ms)' if label_xaxis else ' ', yaxis='Membrane potential (mV)' if label_yaxis else '', xlim=[total_duration * -0.05, total_duration * 1.05], show_xticklabels=label_xaxis, font_size=font_size, bottom_left_spines_only=bottom_left_spines_only, grid=False, labels=volts_labels if show_volts_label else [], show_plot_already=False, save_figure_to=save_voltage_traces_to, title_above_plot=title_above_plot, verbose=verbose) if plot_if: stims = sorted(if_results.keys()) stims_pA = [ii * 1000 for ii in stims] freqs = [if_results[s] for s in stims] if_ax = pynml.generate_plot( [stims_pA], [freqs], "Firing frequency versus injected current for: %s" % nml2_file, colors=[if_iv_color], linestyles=['-'], markers=['o'], linewidths=[linewidth], xaxis='Input current (pA)' if label_xaxis else ' ', yaxis='Firing frequency (Hz)' if label_yaxis else '', xlim=xlim_if, ylim=ylim_if, show_xticklabels=label_xaxis, show_yticklabels=label_yaxis, font_size=font_size, bottom_left_spines_only=bottom_left_spines_only, grid=grid, show_plot_already=False, save_figure_to=save_if_figure_to, title_above_plot=title_above_plot, verbose=verbose) if save_if_data_to: with open(save_if_data_to, 'w') as if_file: for i in range(len(stims_pA)): if_file.write("%s\t%s\n" % (stims_pA[i], freqs[i])) if plot_iv: stims = sorted(iv_results.keys()) stims_pA = [ii * 1000 for ii in sorted(iv_results.keys())] vs = [iv_results[s] for s in stims] xs = [] ys = [] xs.append([]) ys.append([]) for si in range(len(stims)): stim = stims[si] if len(custom_amps_nA) == 0 and si > 1 and ( stims[si] - stims[si - 1]) > step_nA * 1.01: xs.append([]) ys.append([]) xs[-1].append(stim * 1000) ys[-1].append(iv_results[stim]) iv_ax = pynml.generate_plot( xs, ys, "V at %sms versus I below threshold for: %s" % (end_stim, nml2_file), colors=[if_iv_color for s in xs], linestyles=['-' for s in xs], markers=['o' for s in xs], xaxis='Input current (pA)' if label_xaxis else '', yaxis='Membrane potential (mV)' if label_yaxis else '', xlim=xlim_iv, ylim=ylim_iv, show_xticklabels=label_xaxis, show_yticklabels=label_yaxis, font_size=font_size, linewidths=[linewidth for s in xs], bottom_left_spines_only=bottom_left_spines_only, grid=grid, show_plot_already=False, save_figure_to=save_iv_figure_to, title_above_plot=title_above_plot, verbose=verbose) if save_iv_data_to: with open(save_iv_data_to, 'w') as iv_file: for i in range(len(stims_pA)): iv_file.write("%s\t%s\n" % (stims_pA[i], vs[i])) if show_plot_already: from matplotlib import pyplot as plt plt.show() if return_axes: return traces_ax, if_ax, iv_ax return if_results
def parse_templates_json(templates_json="templates.json", ignore_chans = [], save_example_files=False, verbose=False): with open(templates_json, "r") as templates_json_file: json_cells = json.load(templates_json_file) concentrationModels = '' for firing_type_u in json_cells: if verbose: print("\n --------------- %s "%(firing_type_u)) firing_type = str(firing_type_u) cell_dict = json_cells[firing_type] nml_doc = neuroml.NeuroMLDocument(id=firing_type) # Membrane properties # included_channels[firing_type] = [] channel_densities = [] channel_density_nernsts = [] channel_density_non_uniform_nernsts = [] channel_density_non_uniforms = [] species = [] for section_list in cell_dict['forsecs']: for parameter_name in cell_dict['forsecs'][section_list]: value = cell_dict['forsecs'][section_list][parameter_name] if verbose: print(" --- %s, %s: %s "%(section_list,parameter_name,value)) if parameter_name == 'g_pas': channel = 'pas' arguments = {} cond_density = "%s S_per_cm2" % value if verbose: print(' - Adding %s with %s'%(channel, cond_density)) channel_nml2_file = "%s.channel.nml"%channel if channel_nml2_file not in included_channels[firing_type]: nml_doc.includes.append( neuroml.IncludeType( href="../../NeuroML2/%s" % channel_nml2_file)) included_channels[firing_type].append(channel_nml2_file) erev = cell_dict['forsecs'][section_list]['e_pas'] erev = "%s mV" % erev arguments["cond_density"] = cond_density arguments['ion_channel'] = channel arguments["ion"] = "non_specific" arguments["erev"] = erev arguments["id"] = "%s_%s" % (section_list, parameter_name) channel_class = 'ChannelDensity' density = getattr(neuroml, channel_class)(**arguments) channel_densities.append(density) for section_list in cell_dict['parameters']: for parameter_name in cell_dict['parameters'][section_list]: if parameter_name != 'e_pas' and 'CaDynamics_E2' not in parameter_name: parameter_dict = cell_dict['parameters'][section_list][parameter_name] if verbose: print(" --- %s, %s: %s "%(section_list,parameter_name,parameter_dict)) channel = parameter_dict['channel'] if channel not in ignore_chans: arguments = {} cond_density = None variable_parameters = None if parameter_dict['distribution']['disttype'] == "uniform": value = float(parameter_dict['distribution']['value']) if channel in density_scales: value = value * density_scales[channel] cond_density = "%s S_per_cm2" % value else: new_expr = '1e4 * (%s)'%parameter_dict['distribution']['value'].replace('x','p').replace('epp','exp') iv = neuroml.InhomogeneousValue(inhomogeneous_parameters="PathLengthOver_%s"%section_list, value=new_expr) variable_parameters = [ neuroml.VariableParameter( segment_groups=section_list, parameter='condDensity', inhomogeneous_value=iv)] channel_name = channel if channel_substitutes.has_key(channel): channel_name = channel_substitutes[channel] channel_nml2_file = "%s.channel.nml"%channel_name if channel_nml2_file not in included_channels[firing_type]: nml_doc.includes.append( neuroml.IncludeType( href="../../NeuroML2/%s" % channel_nml2_file)) included_channels[firing_type].append(channel_nml2_file) arguments['ion'] = channel_ions[channel] erev = ion_erevs[arguments["ion"]] channel_class = 'ChannelDensity' if erev == "nernst": erev = None channel_class = 'ChannelDensityNernst' elif erev == "pas": erev = cell_dict['parameters'] \ [section_list]['e_pas']['distribution']\ ['value'] erev = "%s mV" % erev arguments["ion"] = "non_specific" if variable_parameters is not None: channel_class += 'NonUniform' else: arguments["segment_groups"] = section_list if erev is not None: arguments["erev"] = erev arguments["id"] = "%s_%s" % (section_list, parameter_name) if cond_density is not None: arguments["cond_density"] = cond_density arguments['ion_channel'] = channel_name if variable_parameters is not None: arguments['variable_parameters'] = variable_parameters density = getattr(neuroml, channel_class)(**arguments) if channel_class == "ChannelDensityNernst": channel_density_nernsts.append(density) elif channel_class == "ChannelDensityNernstNonUniform": channel_density_non_uniform_nernsts.append(density) elif channel_class == "ChannelDensityNonUniform": channel_density_non_uniforms.append(density) else: channel_densities.append(density) elif 'gamma_CaDynamics_E2' in parameter_name: parameter_dict = cell_dict['parameters'][section_list][parameter_name] model = 'CaDynamics_E2_NML2__%s_%s'%(firing_type,section_list) value = parameter_dict['distribution']['value'] concentrationModels+='<concentrationModel id="%s" ion="ca" '%model +\ 'type="concentrationModelHayEtAl" minCai="1e-4 mM" ' +\ 'gamma="%s" '%value elif 'decay_CaDynamics_E2' in parameter_name: # calcium_model = \ # neuroml.DecayingPoolConcentrationModel(ion='ca') model = 'CaDynamics_E2_NML2__%s_%s'%(firing_type,section_list) species.append(neuroml.Species( id='ca', ion='ca', initial_concentration='5.0E-11 mol_per_cm3', initial_ext_concentration='2.0E-6 mol_per_cm3', concentration_model=model, segment_groups=section_list)) channel_nml2_file = 'CaDynamics_E2_NML2.nml' if channel_nml2_file not in included_channels[firing_type]: included_channels[firing_type].append(channel_nml2_file) parameter_dict = cell_dict['parameters'][section_list][parameter_name] value = parameter_dict['distribution']['value'] concentrationModels+='decay="%s ms" depth="0.1 um"/> <!-- For group %s in %s-->\n\n'%(value,section_list,firing_type) capacitance_overwrites = {} for section_list in cell_dict['forsecs']: for parameter_name in cell_dict['forsecs'][section_list]: if parameter_name == "cm" and section_list != 'all': value = cell_dict['forsecs'][section_list][parameter_name] capacitance_overwrites[ section_list] = "%s uF_per_cm2" % value specific_capacitances = [] for section_list in default_capacitances: if section_list in capacitance_overwrites: capacitance = capacitance_overwrites[section_list] else: capacitance = default_capacitances[section_list] specific_capacitances.append( neuroml.SpecificCapacitance(value=capacitance, segment_groups=section_list)) init_memb_potentials = [neuroml.InitMembPotential( value="-80 mV", segment_groups='all')] membrane_properties = neuroml.MembraneProperties( channel_densities=channel_densities, channel_density_nernsts=channel_density_nernsts, channel_density_non_uniform_nernsts=channel_density_non_uniform_nernsts, channel_density_non_uniforms=channel_density_non_uniforms, specific_capacitances=specific_capacitances, init_memb_potentials=init_memb_potentials) # Intracellular Properties # resistivities = [] resistivities.append(neuroml.Resistivity( value="100 ohm_cm", segment_groups='all')) intracellular_properties = neuroml.IntracellularProperties( resistivities=resistivities, species=species) # Cell construction # biophysical_properties = \ neuroml.BiophysicalProperties(id="biophys", intracellular_properties= intracellular_properties, membrane_properties= membrane_properties) biophysical_properties_vs_types[firing_type] = biophysical_properties if save_example_files: cell = neuroml.Cell(id=firing_type, notes="\n*************************\nThis is not a physiologically constrained cell model!!\n"+\ "It is only for testing formatting of the biophysicalProperties extracted from templates.json\n*************************\n", biophysical_properties=biophysical_properties) nml_doc.cells.append(cell) cell.morphology = neuroml.Morphology(id="morph") cell.morphology.segments.append(neuroml.Segment(id='0', name='soma', proximal=neuroml.Point3DWithDiam(x=0,y=0,z=0,diameter=10), distal=neuroml.Point3DWithDiam(x=0,y=20,z=0,diameter=10))) cell.morphology.segment_groups.append(neuroml.SegmentGroup(id="soma", neuro_lex_id="sao864921383", members=[neuroml.Member("0")])) cell.morphology.segments.append(neuroml.Segment(id='1', name='axon', parent=neuroml.SegmentParent(segments='0',fraction_along="0"), proximal=neuroml.Point3DWithDiam(x=0,y=0,z=0,diameter=2), distal=neuroml.Point3DWithDiam(x=0,y=-50,z=0,diameter=2))) cell.morphology.segment_groups.append(neuroml.SegmentGroup(id="axon", neuro_lex_id="sao864921383", members=[neuroml.Member("1")])) cell.morphology.segments.append(neuroml.Segment(id='2', name='basal_dend', parent=neuroml.SegmentParent(segments='0'), proximal=neuroml.Point3DWithDiam(x=0,y=20,z=0,diameter=3), distal=neuroml.Point3DWithDiam(x=50,y=20,z=0,diameter=3))) cell.morphology.segment_groups.append(neuroml.SegmentGroup(id="basal_dend", neuro_lex_id="sao864921383", members=[neuroml.Member("2")])) cell.morphology.segments.append(neuroml.Segment(id='3', name='apical_dend1', parent=neuroml.SegmentParent(segments='0'), proximal=neuroml.Point3DWithDiam(x=0,y=20,z=0,diameter=3), distal=neuroml.Point3DWithDiam(x=0,y=120,z=0,diameter=3))) cell.morphology.segments.append(neuroml.Segment(id='4', name='apical_dend2', parent=neuroml.SegmentParent(segments='0'), proximal=neuroml.Point3DWithDiam(x=0,y=120,z=0,diameter=3), distal=neuroml.Point3DWithDiam(x=0,y=220,z=0,diameter=3))) cell.morphology.segment_groups.append(neuroml.SegmentGroup(id="apical_dend", neuro_lex_id="sao864921383", members=[neuroml.Member("3"),neuroml.Member("4")])) cell.morphology.segment_groups.append(neuroml.SegmentGroup(id="somatic",includes=[neuroml.Include("soma")])) cell.morphology.segment_groups.append(neuroml.SegmentGroup(id="axonal", includes=[neuroml.Include("axon")])) sg = neuroml.SegmentGroup(id="basal", includes=[neuroml.Include("basal_dend")]) sg.inhomogeneous_parameters.append(neuroml.InhomogeneousParameter(id="PathLengthOver_"+"basal", variable="x", metric="Path Length from root", proximal=neuroml.ProximalDetails(translation_start="0"))) cell.morphology.segment_groups.append(sg) sg = neuroml.SegmentGroup(id="apical", includes=[neuroml.Include("apical_dend")]) sg.inhomogeneous_parameters.append(neuroml.InhomogeneousParameter(id="PathLengthOver_"+"apical", variable="x", metric="Path Length from root", proximal=neuroml.ProximalDetails(translation_start="0"))) cell.morphology.segment_groups.append(sg) nml_filename = 'test/%s.cell.nml' % firing_type neuroml.writers.NeuroMLWriter.write(nml_doc, nml_filename) logging.debug("Written cell file to: %s", nml_filename) neuroml.utils.validate_neuroml2(nml_filename) conc_mod_file = open('test/concentrationModel.txt','w') conc_mod_file.write(concentrationModels) conc_mod_file.close()
import neuroml import neuroml.loaders as loaders import neuroml.writers as writers from pyneuroml.lems import generate_lems_file_for_neuroml net_ref = "BC_StimNet" net_doc = neuroml.NeuroMLDocument(id=net_ref) net = neuroml.Network(id=net_ref) net_doc.networks.append(net) cell_id = 'BC2_na_k' net_doc.includes.append(neuroml.IncludeType(cell_id + '.cell.nml')) pop = neuroml.Population(id="BC", component=cell_id, type="populationList") inst = neuroml.Instance(id="0") pop.instances.append(inst) inst.location = neuroml.Location(x=0, y=0, z=0) net.populations.append(pop) stim = neuroml.PulseGenerator(id='stim0', delay='50ms', duration='200ms', amplitude='0.5nA') net_doc.pulse_generators.append(stim)
def process_celldir(inputs): """Process cell directory""" count, cell_dir, nml2_cell_dir, total_count = inputs local_nml2_cell_dir = os.path.join("..", nml2_cell_dir) print( '\n\n************************************************************\n\n' 'Parsing %s (cell %i/%i)\n' % (cell_dir, count, total_count)) if os.path.isdir(cell_dir): old_cwd = os.getcwd() os.chdir(cell_dir) else: old_cwd = os.getcwd() os.chdir('../' + cell_dir) if make_zips: nml2_cell_dir = '%s/%s' % (zips_dir, cell_dir) if not os.path.isdir(nml2_cell_dir): os.mkdir(nml2_cell_dir) print("Generating into %s" % nml2_cell_dir) bbp_ref = None template_file = open('template.hoc', 'r') for line in template_file: if line.startswith('begintemplate '): bbp_ref = line.split(' ')[1].strip() print( ' > Assuming cell in directory %s is in a template named %s' % (cell_dir, bbp_ref)) load_cell_file = 'loadcell.hoc' variables = {} variables['cell'] = bbp_ref variables['groups_info_file'] = groups_info_file template = """ /////////////////////////////////////////////////////////////////////////////// // // NOTE: This file is not part of the original BBP cell model distribution // It has been generated by ../ParseAll.py to facilitate loading of the cell // into NEURON for exporting the model morphology to NeuroML2 // ////////////////////////////////////////////////////////////////////////////// load_file("stdrun.hoc") objref cvode cvode = new CVode() cvode.active(1) //======================== settings =================================== v_init = -80 hyp_amp = -0.062866 step_amp = 0.3112968 tstop = 3000 //=================== creating cell object =========================== load_file("import3d.hoc") objref cell // Using 1 to force loading of the file, in case file with same name was loaded // before... load_file(1, "constants.hoc") load_file(1, "morphology.hoc") load_file(1, "biophysics.hoc") print "Loaded morphology and biophysics..." load_file(1, "synapses/synapses.hoc") load_file(1, "template.hoc") print "Loaded template..." load_file(1, "createsimulation.hoc") create_cell(0) print "Created new cell using loadcell.hoc: {{ cell }}" define_shape() wopen("{{ groups_info_file }}") fprint("//Saving information on groups in this cell...\\n") fprint("- somatic\\n") forsec {{ cell }}[0].somatic { fprint("%s\\n",secname()) } fprint("- basal\\n") forsec {{ cell }}[0].basal { fprint("%s\\n",secname()) } fprint("- axonal\\n") forsec {{ cell }}[0].axonal { fprint("%s\\n",secname()) } fprint("- apical\\n") forsec {{ cell }}[0].apical { fprint("%s\\n",secname()) } wopen() """ t = Template(template) contents = t.render(variables) load_cell = open(load_cell_file, 'w') load_cell.write(contents) load_cell.close() print(' > Written %s' % load_cell_file) if os.path.isfile(load_cell_file): cell_info = parse_cell_info_file(cell_dir) nml_file_name = "%s.net.nml" % bbp_ref nml_net_loc = "%s/%s" % (local_nml2_cell_dir, nml_file_name) nml_cell_file = "%s_0_0.cell.nml" % bbp_ref nml_cell_loc = "%s/%s" % (local_nml2_cell_dir, nml_cell_file) print(' > Loading %s and exporting to %s' % (load_cell_file, nml_net_loc)) export_to_neuroml2(load_cell_file, nml_net_loc, separateCellFiles=True, includeBiophysicalProperties=False) print(' > Exported to: %s and %s using %s' % (nml_net_loc, nml_cell_loc, load_cell_file)) nml_doc = pynml.read_neuroml2_file(nml_cell_loc) cell = nml_doc.cells[0] print(' > Adding groups from: %s' % groups_info_file) groups = {} current_group = None for line in open(groups_info_file): if not line.startswith('//'): if line.startswith('- '): current_group = line[2:-1] print(' > Adding group: [%s]' % current_group) groups[current_group] = [] else: section = line.split('.')[1].strip() segment_group = section.replace('[', '_').replace(']', '') groups[current_group].append(segment_group) for g in groups.keys(): new_seg_group = neuroml.SegmentGroup(id=g) cell.morphology.segment_groups.append(new_seg_group) for sg in groups[g]: new_seg_group.includes.append(neuroml.Include(sg)) if g in ['basal', 'apical']: new_seg_group.inhomogeneous_parameters.append( neuroml.InhomogeneousParameter( id="PathLengthOver_" + g, variable="p", metric="Path Length from root", proximal=neuroml.ProximalDetails( translation_start="0"))) ignore_chans = [ 'Ih', 'Ca_HVA', 'Ca_LVAst', 'Ca', "SKv3_1", "SK_E2", "CaDynamics_E2", "Nap_Et2", "Im", "K_Tst", "NaTa_t", "K_Pst", "NaTs2_t" ] # ignore_chans=['StochKv','StochKv_deterministic'] ignore_chans = [] bp, incl_chans = get_biophysical_properties( cell_info['e-type'], ignore_chans=ignore_chans, templates_json="../templates.json") cell.biophysical_properties = bp print("Set biophysical properties") notes = '' notes += \ "\n\nExport of a cell model obtained from the BBP Neocortical" \ "Microcircuit Collaboration Portal into NeuroML2" \ "\n\n******************************************************\n*" \ " This export to NeuroML2 has not yet been fully validated!!" \ "\n* Use with caution!!\n***********************************" \ "*******************\n\n" if len(ignore_chans) > 0: notes += "Ignored channels = %s\n\n" % ignore_chans notes += "For more information on this cell model see: " \ "https://bbp.epfl.ch/nmc-portal/microcircuit#/metype/%s/" \ "details\n\n" % cell_info['me-type'] cell.notes = notes for channel in incl_chans: nml_doc.includes.append(neuroml.IncludeType(href="%s" % channel)) if make_zips: print("Copying %s to zip folder" % channel) shutil.copyfile('../../NeuroML2/%s' % channel, '%s/%s' % (local_nml2_cell_dir, channel)) pynml.write_neuroml2_file(nml_doc, nml_cell_loc) stim_ref = 'stepcurrent3' stim_ref_hyp = '%s_hyp' % stim_ref stim_sim_duration = 3000 stim_hyp_amp, stim_amp = get_stimulus_amplitudes(bbp_ref) stim_del = '700ms' stim_dur = '2000ms' new_net_loc = "%s/%s.%s.net.nml" % (local_nml2_cell_dir, bbp_ref, stim_ref) new_net_doc = pynml.read_neuroml2_file(nml_net_loc) new_net_doc.notes = notes stim_hyp = neuroml.PulseGenerator(id=stim_ref_hyp, delay="0ms", duration="%sms" % stim_sim_duration, amplitude=stim_hyp_amp) new_net_doc.pulse_generators.append(stim_hyp) stim = neuroml.PulseGenerator(id=stim_ref, delay=stim_del, duration=stim_dur, amplitude=stim_amp) new_net_doc.pulse_generators.append(stim) new_net = new_net_doc.networks[0] pop_id = new_net.populations[0].id pop_comp = new_net.populations[0].component input_list = neuroml.InputList(id="%s_input" % stim_ref_hyp, component=stim_ref_hyp, populations=pop_id) syn_input = neuroml.Input(id=0, target="../%s/0/%s" % (pop_id, pop_comp), destination="synapses") input_list.input.append(syn_input) new_net.input_lists.append(input_list) input_list = neuroml.InputList(id="%s_input" % stim_ref, component=stim_ref, populations=pop_id) syn_input = neuroml.Input(id=0, target="../%s/0/%s" % (pop_id, pop_comp), destination="synapses") input_list.input.append(syn_input) new_net.input_lists.append(input_list) pynml.write_neuroml2_file(new_net_doc, new_net_loc) generate_lems_file_for_neuroml(cell_dir, new_net_loc, "network", stim_sim_duration, 0.025, "LEMS_%s.xml" % cell_dir, local_nml2_cell_dir, copy_neuroml=False, seed=1234) pynml.nml2_to_svg(nml_net_loc) clear_neuron() pop = neuroml.Population(id="Pop_%s" % bbp_ref, component=bbp_ref + '_0_0', type="populationList") inst = neuroml.Instance(id="0") pop.instances.append(inst) width = 6 X = count % width Z = (count - X) / width inst.location = neuroml.Location(x=300 * X, y=0, z=300 * Z) count += 1 if make_zips: zip_file = "%s/%s.zip" % (zips_dir, cell_dir) print("Creating zip file: %s" % zip_file) with zipfile.ZipFile(zip_file, 'w') as myzip: for next_file in os.listdir(local_nml2_cell_dir): next_file = '%s/%s' % (local_nml2_cell_dir, next_file) arcname = next_file[len(zips_dir):] print("Adding : %s as %s" % (next_file, arcname)) myzip.write(next_file, arcname) os.chdir(old_cwd) return nml_cell_file, pop