def compare(sim_data_file, show_plot_already=True, dataset=471141261):
dat_file_name = '../data/%s.dat' % dataset
x = []
y = []
colors = []
linestyles = []
data, indeces = pynml.reload_standard_dat_file(dat_file_name)
for ii in indeces:
x.append(data['t'])
y.append(data[ii])
colors.append('lightgrey')
linestyles.append('-')
data, indeces = pynml.reload_standard_dat_file(sim_data_file)
r = lambda: random.randint(0, 255)
for ii in indeces:
x.append(data['t'])
y.append(data[ii])
c = '#%02X%02X%02X' % (r(), r(), r())
colors.append(c)
linestyles.append('-')
pynml.generate_plot(x,
y,
"Comparing tuned cell to: %s" % dat_file_name,
xaxis='Input current (nA)',
yaxis='Membrane potential (mV)',
colors=colors,
linestyles=linestyles,
show_plot_already=show_plot_already)
def compare(sim_data_file, show_plot_already=True, dataset=471141261):
dat_file_name = '../data/%s.dat'%dataset
x = []
y = []
colors = []
linestyles = []
data, indeces = pynml.reload_standard_dat_file(dat_file_name)
for ii in indeces:
x.append(data['t'])
y.append(data[ii])
colors.append('lightgrey')
linestyles.append('-')
data, indeces = pynml.reload_standard_dat_file(sim_data_file)
r = lambda: random.randint(0,255)
for ii in indeces:
x.append(data['t'])
y.append(data[ii])
c = '#%02X%02X%02X' % (r(),r(),r())
colors.append(c)
linestyles.append('-')
pynml.generate_plot(x,
y,
"Comparing tuned cell to: %s"%dat_file_name,
xaxis = 'Input current (nA)',
yaxis = 'Membrane potential (mV)',
colors = colors,
linestyles = linestyles,
show_plot_already=show_plot_already)
def run_one_cell(glif_dir, curr_pA, dt=5e-7, show_plot=True):
# initialize the neuron
neuron_config = json_utilities.read('%s/neuron_config.json'%glif_dir)
neuron = GlifNeuron.from_dict(neuron_config)
# important! set the neuron's dt value for your stimulus in seconds
neuron.dt = dt
# make a short square pulse. stimulus units should be in Amps.
stimulus = [ 0.0 ] * int(0.1/neuron.dt) + [ curr_pA * 1e-12 ] * int(1/neuron.dt) + [ 0.0 ] * int(0.1/neuron.dt)
times = [ i*neuron.dt for i in range(len(stimulus)) ]
# simulate the neuron
output = neuron.run(stimulus)
print "run.."
voltage = output['voltage']
threshold = output['threshold']
spike_times = output['interpolated_spike_times']
info = "Model %s; %spA stimulation; dt=%ss; %i spikes"%(glif_dir,curr_pA,dt,len(spike_times))
print(info)
v_file = open('%s/original.v.dat'%glif_dir,'w')
th_file = open('%s/original.thresh.dat'%glif_dir,'w')
for i in range(len(times)):
t = times[i]
v = voltage[i]
th = threshold[i]
v_file.write('%s\t%s\n'%(t,v))
th_file.write('%s\t%s\n'%(t,th))
v_file.close()
th_file.close()
pynml.generate_plot([times],
[voltage],
"Membrane potential; %s"%info,
colors = ['k'],
xaxis = "Time (s)",
yaxis = "Voltage (V)",
grid = True,
show_plot_already=False,
save_figure_to='%s/MembranePotential_%ipA.png'%(glif_dir,curr_pA))
pynml.generate_plot([times],
[threshold],
"Threshold; %s"%info,
colors = ['r'],
xaxis = "Time (s)",
yaxis = "Voltage (V)",
grid = True,
show_plot_already=show_plot,
save_figure_to='%s/Threshold_%ipA.png'%(glif_dir,curr_pA))
def generate_traces_plot(config,parameter_set,xvals,yvals,info,labels,save,save_fig_path,voltage,muscles):
file_name = 'traces_%s%s_%s_%s.png'%(('muscles' if muscles else 'neuron'),('' if voltage else '_activity'),config,parameter_set)
pynml.generate_plot(xvals,
yvals,
info,
labels=labels,
xaxis="Time (ms)",
yaxis="Membrane potential (mV)" if voltage else "Activity",
show_plot_already=False,
save_figure_to=(None if not save else save_fig_path%(file_name)),
cols_in_legend_box=8)
def plot_sim_data(sweeps_to_tune_against: List, simulation_id: str,
memb_pots: Dict) -> None:
"""Plot data from our fitted simulation
:param simulation_id: string id of simulation
:type simulation_id: str
"""
# Plot
data_array = np.loadtxt("%s.v.dat" % simulation_id)
# construct data for plotting
counter = 0
time_vals_list = []
sim_v_list = []
data_v_list = []
data_t_list = []
stim_vals = []
for acq in sweeps_to_tune_against:
stim_vals.append("{}pA".format(currents[acq]))
# remains the same for all columns
time_vals_list.append(data_array[:, 0] * 1000.0)
sim_v_list.append(data_array[:, counter + 1] * 1000.0)
data_v_list.append(memb_pots[acq][1])
data_t_list.append(memb_pots[acq][0])
counter = counter + 1
# Model membrane potential plot
generate_plot(
xvalues=time_vals_list,
yvalues=sim_v_list,
labels=stim_vals,
title="Membrane potential (model)",
show_plot_already=False,
save_figure_to="%s-model-v.png" % simulation_id,
xaxis="time (ms)",
yaxis="membrane potential (mV)",
)
# data membrane potential plot
generate_plot(
xvalues=data_t_list,
yvalues=data_v_list,
labels=stim_vals,
title="Membrane potential (exp)",
show_plot_already=False,
save_figure_to="%s-exp-v.png" % simulation_id,
xaxis="time (ms)",
yaxis="membrane potential (mV)",
)
def generate_traces_plot(config,parameter_set,xvals,yvals,info,labels,save,save_fig_path,voltage,muscles):
file_name = 'traces_%s%s_%s_%s.png'%(('muscles' if muscles else 'neuron'),('' if voltage else '_activity'),config,parameter_set)
pynml.generate_plot(xvals,
yvals,
info,
labels=labels,
xaxis="Time (ms)",
yaxis="Membrane potential (mV)" if voltage else "Activity",
show_plot_already=False,
save_figure_to=(None if not save else save_fig_path%(file_name)),
cols_in_legend_box=8,
title_above_plot=True)
def plot_data(sim_id):
"""Plot the sim data.
Load the data from the file and plot the graph for the membrane potential
using the pynml generate_plot utility function.
:sim_id: ID of simulaton
"""
data_array = np.loadtxt(sim_id + ".dat")
pynml.generate_plot([data_array[:, 0]], [data_array[:, 1]],
"Membrane potential (soma seg 0)",
show_plot_already=False,
save_figure_to=sim_id + "_seg0_soma0-v.png",
xaxis="time (s)",
yaxis="membrane potential (V)")
pynml.generate_plot([data_array[:, 0]], [data_array[:, 2]],
"Membrane potential (soma seg 1)",
show_plot_already=False,
save_figure_to=sim_id + "_seg1_soma0-v.png",
xaxis="time (s)",
yaxis="membrane potential (V)")
pynml.generate_plot([data_array[:, 0]], [data_array[:, 3]],
"Membrane potential (axon seg 0)",
show_plot_already=False,
save_figure_to=sim_id + "_seg0_axon0-v.png",
xaxis="time (s)",
yaxis="membrane potential (V)")
pynml.generate_plot([data_array[:, 0]], [data_array[:, 4]],
"Membrane potential (axon seg 1)",
show_plot_already=False,
save_figure_to=sim_id + "_seg1_axon0-v.png",
xaxis="time (s)",
yaxis="membrane potential (V)")
def main(args=None):
"""Main"""
vs = [(v - 100) * 0.001 for v in range(200)]
for f in ['IM.channel.nml', 'Kd.channel.nml']:
nml_doc = pynml.read_neuroml2_file(f)
for ct in nml_doc.ComponentType:
ys = []
for v in vs:
req_variables = {'v': '%sV' % v, 'vShift': '10mV'}
vals = pynml.evaluate_component(ct,
req_variables=req_variables)
print(vals)
if 'x' in vals:
ys.append(vals['x'])
if 't' in vals:
ys.append(vals['t'])
if 'r' in vals:
ys.append(vals['r'])
ax = pynml.generate_plot([vs], [ys],
"Some traces from %s in %s" %
(ct.name, f),
show_plot_already=False)
print(vals)
plt.show()
def main(args=None):
"""Main"""
vs = [(v-100)*0.001 for v in range(200)]
for f in ['IM.channel.nml','Kd.channel.nml']:
nml_doc = pynml.read_neuroml2_file(f)
for ct in nml_doc.ComponentType:
ys = []
for v in vs:
req_variables = {'v':'%sV'%v,'vShift':'10mV'}
vals = pynml.evaluate_component(ct,req_variables=req_variables)
print vals
if 'x' in vals:
ys.append(vals['x'])
if 't' in vals:
ys.append(vals['t'])
if 'r' in vals:
ys.append(vals['r'])
ax = pynml.generate_plot([vs],[ys],
"Some traces from %s in %s"%(ct.name,f),
show_plot_already=False )
print vals
plt.show()
def plot_data(sim_id):
"""Plot the sim data.
Load the data from the file and plot the graph for the membrane potential
using the pynml generate_plot utility function.
:sim_id: ID of simulaton
"""
data_array = np.loadtxt(sim_id + ".dat")
pynml.generate_plot([data_array[:, 0]], [data_array[:, 1]], "Membrane potential", show_plot_already=False, save_figure_to=sim_id + "-v.png", xaxis="time (s)", yaxis="membrane potential (V)")
pynml.generate_plot([data_array[:, 0]], [data_array[:, 2]], "channel current", show_plot_already=False, save_figure_to=sim_id + "-i.png", xaxis="time (s)", yaxis="channel current (A)")
pynml.generate_plot([data_array[:, 0], data_array[:, 0]], [data_array[:, 3], data_array[:, 4]], "current density", labels=["Na", "K"], show_plot_already=False, save_figure_to=sim_id + "-iden.png", xaxis="time (s)", yaxis="current density (A_per_m2)")
def analyse_spiketime_vs_dt(nml2_file,
target,
duration,
simulator,
cell_v_path,
dts,
verbose=False,
spike_threshold_mV=0,
show_plot_already=True,
save_figure_to=None,
num_of_last_spikes=None):
from pyelectro.analysis import max_min
import numpy as np
all_results = {}
dts = list(np.sort(dts))
for dt in dts:
if verbose:
print_comment_v(" == Generating simulation for dt = %s ms" % dt)
ref = str("Sim_dt_%s" % dt).replace('.', '_')
lems_file_name = "LEMS_%s.xml" % ref
generate_lems_file_for_neuroml(ref,
nml2_file,
target,
duration,
dt,
lems_file_name,
'.',
gen_plots_for_all_v=True,
gen_saves_for_all_v=True,
copy_neuroml=False)
if simulator == 'jNeuroML':
results = pynml.run_lems_with_jneuroml(lems_file_name,
nogui=True,
load_saved_data=True,
plot=False,
verbose=verbose)
if simulator == 'jNeuroML_NEURON':
results = pynml.run_lems_with_jneuroml_neuron(lems_file_name,
nogui=True,
load_saved_data=True,
plot=False,
verbose=verbose)
print("Results reloaded: %s" % results.keys())
all_results[dt] = results
xs = []
ys = []
labels = []
spxs = []
spys = []
linestyles = []
markers = []
colors = []
spike_times_final = []
array_of_num_of_spikes = []
for dt in dts:
t = all_results[dt]['t']
v = all_results[dt][cell_v_path]
xs.append(t)
ys.append(v)
labels.append(dt)
mm = max_min(v, t, delta=0, peak_threshold=spike_threshold_mV)
spike_times = mm['maxima_times']
spike_times_final.append(spike_times)
array_of_num_of_spikes.append(len(spike_times))
max_num_of_spikes = max(array_of_num_of_spikes)
min_dt_spikes = spike_times_final[0]
bound_dts = [math.log(dts[0]), math.log(dts[-1])]
if num_of_last_spikes == None:
num_of_spikes = len(min_dt_spikes)
else:
if len(min_dt_spikes) >= num_of_last_spikes:
num_of_spikes = num_of_last_spikes
else:
num_of_spikes = len(min_dt_spikes)
spike_indices = [(-1) * ind for ind in range(1, num_of_spikes + 1)]
if len(min_dt_spikes) > abs(spike_indices[-1]):
earliest_spike_time = min_dt_spikes[spike_indices[-1] - 1]
else:
earliest_spike_time = min_dt_spikes[spike_indices[-1]]
for spike_ind in range(0, max_num_of_spikes):
spike_time_values = []
dt_values = []
for dt in range(0, len(dts)):
if spike_times_final[dt] != []:
if len(spike_times_final[dt]) >= spike_ind + 1:
if spike_times_final[dt][spike_ind] >= earliest_spike_time:
spike_time_values.append(
spike_times_final[dt][spike_ind])
dt_values.append(math.log(dts[dt]))
linestyles.append('')
markers.append('o')
colors.append('g')
spxs.append(dt_values)
spys.append(spike_time_values)
for last_spike_index in spike_indices:
vertical_line = [
min_dt_spikes[last_spike_index], min_dt_spikes[last_spike_index]
]
spxs.append(bound_dts)
spys.append(vertical_line)
linestyles.append('--')
markers.append('')
colors.append('k')
pynml.generate_plot(spxs,
spys,
"Spike times vs dt",
colors=colors,
linestyles=linestyles,
markers=markers,
xaxis='ln ( dt (ms) )',
yaxis='Spike times (s)',
show_plot_already=show_plot_already,
save_figure_to=save_figure_to)
if verbose:
pynml.generate_plot(xs,
ys,
"Membrane potentials in %s for %s" %
(simulator, dts),
labels=labels,
show_plot_already=show_plot_already,
save_figure_to=save_figure_to)
tt = read_dat_file(t_nrn_f)
vv = read_dat_file(v_nrn_f)
cc = read_dat_file(ca_nrn_f)
x.append(tt)
y.append(vv)
xc.append(tt)
yc.append(cc)
pynml.generate_plot(
x,
y,
"V from: %s and %s" % (v_nml2_f, v_nrn_f),
xaxis="Time (ms)",
yaxis="Membrane potential (mV)",
labels=["NML2", "NRN"],
ylim=[-100, 40],
show_plot_already=False,
)
pynml.generate_plot(
xc,
yc,
"[Ca2+] from: %s and %s" % (ca_nml2_f, ca_nrn_f),
xaxis="Time (ms)",
yaxis="Ca conc (mM)",
labels=["NML2", "NRN"],
show_plot_already=False,
)
def generate_lems(glif_dir, curr_pA, show_plot=True):
os.chdir(glif_dir)
with open('model_metadata.json', "r") as json_file:
model_metadata = json.load(json_file)
with open('neuron_config.json', "r") as json_file:
neuron_config = json.load(json_file)
with open('ephys_sweeps.json', "r") as json_file:
ephys_sweeps = json.load(json_file)
template_cell = '''<Lems>
<%s %s/>
</Lems>
'''
type = '???'
print(model_metadata['name'])
if '(LIF)' in model_metadata['name']:
type = 'glifCell'
if '(LIF-ASC)' in model_metadata['name']:
type = 'glifAscCell'
if '(LIF-R)' in model_metadata['name']:
type = 'glifRCell'
if '(LIF-R-ASC)' in model_metadata['name']:
type = 'glifRAscCell'
if '(LIF-R-ASC-A)' in model_metadata['name']:
type = 'glifRAscATCell'
cell_id = 'GLIF_%s'%glif_dir
attributes = ""
attributes +=' id="%s"'%cell_id
attributes +='\n C="%s F"'%neuron_config["C"]
attributes +='\n leakReversal="%s V"'%neuron_config["El"]
attributes +='\n reset="%s V"'%neuron_config["El"]
attributes +='\n thresh="%s V"'%( float(neuron_config["th_inf"]) * float(neuron_config["coeffs"]["th_inf"]))
attributes +='\n leakConductance="%s S"'%(1/float(neuron_config["R_input"]))
if 'Asc' in type:
attributes +='\n tau1="%s s"'%neuron_config["asc_tau_array"][0]
attributes +='\n tau2="%s s"'%neuron_config["asc_tau_array"][1]
attributes +='\n amp1="%s A"'% ( float(neuron_config["asc_amp_array"][0]) * float(neuron_config["coeffs"]["asc_amp_array"][0]) )
attributes +='\n amp2="%s A"'% ( float(neuron_config["asc_amp_array"][1]) * float(neuron_config["coeffs"]["asc_amp_array"][1]) )
if 'glifR' in type:
attributes +='\n bs="%s per_s"'%neuron_config["threshold_dynamics_method"]["params"]["b_spike"]
attributes +='\n deltaThresh="%s V"'%neuron_config["threshold_dynamics_method"]["params"]["a_spike"]
attributes +='\n fv="%s"'%neuron_config["voltage_reset_method"]["params"]["a"]
attributes +='\n deltaV="%s V"'%neuron_config["voltage_reset_method"]["params"]["b"]
if 'glifRAscATCell' in type:
attributes +='\n bv="%s per_s"'%neuron_config["threshold_dynamics_method"]["params"]["b_voltage"]
attributes +='\n a="%s per_s"'%neuron_config["threshold_dynamics_method"]["params"]["a_voltage"]
file_contents = template_cell%(type, attributes)
print(file_contents)
cell_file_name = '%s.xml'%(cell_id)
cell_file = open(cell_file_name,'w')
cell_file.write(file_contents)
cell_file.close()
import opencortex.build as oc
nml_doc, network = oc.generate_network("Test_%s"%glif_dir)
pop = oc.add_single_cell_population(network,
'pop_%s'%glif_dir,
cell_id)
pg = oc.add_pulse_generator(nml_doc,
id="pg0",
delay="100ms",
duration="1000ms",
amplitude="%s pA"%curr_pA)
oc.add_inputs_to_population(network,
"Stim0",
pop,
pg.id,
all_cells=True)
nml_file_name = '%s.net.nml'%network.id
oc.save_network(nml_doc, nml_file_name, validate=True)
thresh = 'thresh'
if 'glifR' in type:
thresh = 'threshTotal'
lems_file_name = oc.generate_lems_simulation(nml_doc,
network,
nml_file_name,
include_extra_lems_files = [cell_file_name,'../GLIFs.xml'],
duration = 1200,
dt = 0.01,
gen_saves_for_quantities = {'thresh.dat':['pop_%s/0/GLIF_%s/%s'%(glif_dir,glif_dir,thresh)]},
gen_plots_for_quantities = {'Threshold':['pop_%s/0/GLIF_%s/%s'%(glif_dir,glif_dir,thresh)]})
results = pynml.run_lems_with_jneuroml(lems_file_name,
nogui=True,
load_saved_data=True)
print("Ran simulation; results reloaded for: %s"%results.keys())
info = "Model %s; %spA stimulation"%(glif_dir,curr_pA)
times = [results['t']]
vs = [results['pop_%s/0/GLIF_%s/v'%(glif_dir,glif_dir)]]
labels = ['LEMS - jNeuroML']
original_model_v = 'original.v.dat'
if os.path.isfile(original_model_v):
data, indices = pynml.reload_standard_dat_file(original_model_v)
times.append(data['t'])
vs.append(data[0])
labels.append('Allen SDK')
pynml.generate_plot(times,
vs,
"Membrane potential; %s"%info,
xaxis = "Time (s)",
yaxis = "Voltage (V)",
labels = labels,
grid = True,
show_plot_already=False,
save_figure_to='Comparison_%ipA.png'%(curr_pA))
times = [results['t']]
vs = [results['pop_%s/0/GLIF_%s/%s'%(glif_dir,glif_dir,thresh)]]
labels = ['LEMS - jNeuroML']
original_model_th = 'original.thresh.dat'
if os.path.isfile(original_model_th):
data, indeces = pynml.reload_standard_dat_file(original_model_th)
times.append(data['t'])
vs.append(data[0])
labels.append('Allen SDK')
pynml.generate_plot(times,
vs,
"Threshold; %s"%info,
xaxis = "Time (s)",
yaxis = "Voltage (V)",
labels = labels,
grid = True,
show_plot_already=show_plot,
save_figure_to='Comparison_Threshold_%ipA.png'%(curr_pA))
readme = '''
## Model: %(id)s
### Original model
%(name)s
[Allen Cell Types DB electrophysiology page for specimen](http://celltypes.brain-map.org/mouse/experiment/electrophysiology/%(spec)s)
[Neuron configuration](neuron_config.json); [model metadata](model_metadata.json); [electrophysiology summary](ephys_sweeps.json)
#### Original traces:
**Membrane potential**
Current injection of %(curr)s pA
spA.png)
**Threshold**
spA.png)
### Conversion to NeuroML 2
LEMS version of this model: [GLIF_%(id)s.xml](GLIF_%(id)s.xml)
[Definitions of LEMS Component Types](../GLIFs.xml) for GLIFs.
This model can be run locally by installing [jNeuroML](https://github.com/NeuroML/jNeuroML) and running:
jnml LEMS_Test_%(id)s.xml
#### Comparison:
**Membrane potential**
Current injection of %(curr)s pA
spA.png)
**Threshold**
spA.png)'''
readme_file = open('README.md','w')
curr_str = str(curr_pA)
# @type curr_str str
if curr_str.endswith('.0'):
curr_str = curr_str[:-2]
readme_file.write(readme%{"id":glif_dir,"name":model_metadata['name'],"spec":model_metadata["specimen_id"],"curr":curr_str})
readme_file.close()
os.chdir('..')
return model_metadata, neuron_config, ephys_sweeps
def analyse_cell(dataset_id, type, info, nogui = False, densities=False, analysis_dir='../../data/'):
reference = '%s_%s'%(type,dataset_id)
cell_file = '%s/%s.cell.nml'%(type,reference)
print("====================================\n\n Analysing cell: %s, dataset %s\n"%(cell_file,dataset_id))
nml_doc = pynml.read_neuroml2_file(cell_file)
notes = nml_doc.cells[0].notes if len(nml_doc.cells)>0 else nml_doc.izhikevich2007_cells[0].notes
meta_nml = eval(notes[notes.index('{'):])
summary = "Fitness: %s (max evals: %s, pop: %s)"%(meta_nml['fitness'],meta_nml['max_evaluations'],meta_nml['population_size'])
print summary
images = 'summary/%s_%s.png'
if_iv_data_files = 'summary/%s_%s.dat'
data, v_sub, curents_sub, freqs, curents_spike = get_if_iv_for_dataset('%s%s_analysis.json'%(analysis_dir,dataset_id))
if densities:
dataset = {}
seed = meta_nml['seed']
if isinstance(seed, tuple):
seed = seed[0]
layer = str(data['location'].split(',')[-1].strip().replace(' ',''))
ref = '%s_%s_%s'%(dataset_id,layer,int(seed))
dataset['id'] = dataset_id
dataset['reference'] = ref
metas = ['aibs_cre_line','aibs_dendrite_type','location']
for m in metas:
dataset[m] = str(data[m])
metas2 = ['fitness','population_size','seed']
for m in metas2:
dataset[m] = meta_nml[m]
# Assume images below already generated...
if type=='HH':
cell = nml_doc.cells[0]
sgv_files, all_info = generate_channel_density_plots(cell_file, text_densities=True, passives_erevs=True)
sgv_file =sgv_files[0]
for c in all_info:
if c == cell.id:
cc = 'tuned_cell_info'
else:
cc = c
dataset[cc] = all_info[c]
info['datasets'][ref] = dataset
elif type=='Izh':
dataset['tuned_cell_info'] = {}
izh_cell = nml_doc.izhikevich2007_cells[0]
for p in ['C','a','b','c','d','k','vpeak','vr','vt']:
dataset['tuned_cell_info'][p] = get_value_in_si(getattr(izh_cell, p))
'''
sgv_files, all_info = generate_channel_density_plots(cell_file, text_densities=True, passives_erevs=True)
sgv_file =sgv_files[0]
for c in all_info:
if c == cell.id:
cc = 'tuned_cell_info'
else:
cc = c
dataset[cc] = all_info[c]'''
info['datasets'][ref] = dataset
else:
traces_ax, if_ax, iv_ax = generate_current_vs_frequency_curve(cell_file,
reference,
simulator = 'jNeuroML_NEURON',
start_amp_nA = -0.1,
end_amp_nA = 0.4,
step_nA = 0.01,
analysis_duration = 1000,
analysis_delay = 50,
plot_voltage_traces = False,
plot_if = not nogui,
plot_iv = not nogui,
xlim_if = [-200, 400],
ylim_if = [-10, 120],
xlim_iv = [-200, 400],
ylim_iv = [-120, -40],
save_if_figure_to = images%(reference, 'if'),
save_iv_figure_to = images%(reference, 'iv'),
save_if_data_to = if_iv_data_files%(reference, 'if'),
save_iv_data_to = if_iv_data_files%(reference, 'iv'),
show_plot_already = False,
return_axes = True)
iv_ax.plot(curents_sub, v_sub, color='#ff2222',marker='o', linestyle='',zorder=1)
if_ax.plot(curents_spike, freqs ,color='#ff2222',marker='o', linestyle='',zorder=1)
iv_ax.get_figure().savefig(images%(reference, 'iv'),bbox_inches='tight')
if_ax.get_figure().savefig(images%(reference, 'if'),bbox_inches='tight')
offset = 100 # mV
ifv_x = []
ifv_y = []
markers = []
lines = []
colors = []
cols = {'Izh':'r','HH':'g','AllenHH':'b'}
for ii in ['if','iv']:
for tt in ['Izh','HH','AllenHH']:
rr = '%s_%s'%(tt,dataset_id)
f = if_iv_data_files%(rr, ii)
if os.path.isfile(f):
print("--- Opening: %s"%f)
data, indeces = reload_standard_dat_file(f)
ifv_x.append(data['t'])
if ii=='if':
ifv_y.append([ff-offset for ff in data[0]])
else:
ifv_y.append([vv for vv in data[0]])
markers.append('')
colors.append(cols[tt])
lines.append('-')
ifv_x.append(curents_sub)
vvsub = [vv for vv in v_sub]
ifv_y.append(vvsub)
sub_color = '#888888'
markers.append('D')
colors.append('k')
lines.append('')
ifv_x.append(curents_spike)
ifv_y.append([ff-offset for ff in freqs])
markers.append('o')
colors.append(sub_color)
lines.append('')
import matplotlib
import matplotlib.pyplot as plt
print ifv_x
print ifv_y
ylim = [-105, -20]
font_size = 18
ax1 = pynml.generate_plot(ifv_x,
ifv_y,
summary,
markers=markers,
colors=colors,
linestyles=lines,
show_plot_already=False,
xlim = [-100, 400],
font_size = font_size,
ylim = ylim,
title_above_plot=False)
plt.xlabel('Input current (pA)', fontsize = font_size)
plt.ylabel("Steady membrane potential (mV)", fontsize = font_size)
ax2 = ax1.twinx()
plt.ylim([ylim[0]+offset,ylim[1]+offset])
plt.ylabel('Firing frequency (Hz)', color=sub_color, fontsize = font_size)
ax2.tick_params(axis='y', colors=sub_color)
#plt.axis('off')
plt.savefig(images%(reference, 'if_iv'+"_FIG"),bbox_inches='tight')
temp_dir = 'temp/'
print("Copying %s to %s"%(cell_file, temp_dir))
shutil.copy(cell_file, temp_dir)
net_file = generate_network_for_sweeps(type, dataset_id, '%s.cell.nml'%(reference), reference, temp_dir, data_dir=analysis_dir)
lems_file_name = 'LEMS_Test_%s_%s.xml'%(type,dataset_id)
generate_lems_file_for_neuroml('Test_%s_%s'%(dataset_id,type),
net_file,
'network_%s_%s'%(dataset_id,type),
1500,
0.01,
lems_file_name,
temp_dir,
gen_plots_for_all_v=False,
copy_neuroml = False)
simulator = "jNeuroML_NEURON"
if simulator == "jNeuroML":
results = pynml.run_lems_with_jneuroml(temp_dir+lems_file_name,
nogui=True,
load_saved_data=True,
plot=False,
show_plot_already=False)
elif simulator == "jNeuroML_NEURON":
results = pynml.run_lems_with_jneuroml_neuron(temp_dir+lems_file_name,
nogui=True,
load_saved_data=True,
plot=False,
show_plot_already=False)
x = []
y = []
print results.keys()
tt = [t*1000 for t in results['t']]
for i in range(len(results)-1):
x.append(tt)
y.append([v*1000 for v in results['Pop0/%i/%s_%s/v'%(i,type,dataset_id)]])
pynml.generate_plot(x,
y,
summary,
show_plot_already=False,
ylim = [-120, 60],
save_figure_to = images%(reference, 'traces'),
title_above_plot=True)
ax = pynml.generate_plot(x,
y,
summary,
show_plot_already=False,
ylim = [-120, 60],
title_above_plot=False)
ax.set_xlabel(None)
ax.set_ylabel(None)
plt.axis('off')
fig_file = images%(reference, 'traces'+"_FIG")
plt.savefig(fig_file, bbox_inches='tight', pad_inches=0)
from PIL import Image
img = Image.open(fig_file)
img2 = img.crop((60, 40, 660, 480))
img2.save(fig_file)
def analyse_cell(dataset_id, type, nogui = False):
reference = '%s_%s'%(type,dataset_id)
cell_file = '%s.cell.nml'%(reference)
images = 'summary/%s_%s.png'
generate_current_vs_frequency_curve(cell_file,
reference,
simulator = 'jNeuroML_NEURON',
start_amp_nA = -0.1,
end_amp_nA = 0.4,
step_nA = 0.01,
analysis_duration = 1000,
analysis_delay = 50,
plot_voltage_traces = False,
plot_if = not nogui,
plot_iv = not nogui,
xlim_if = [-200, 400],
ylim_if = [-10, 120],
xlim_iv = [-200, 400],
ylim_iv = [-120, -40],
save_if_figure_to=images%(reference, 'if'),
save_iv_figure_to=images%(reference, 'iv'),
show_plot_already = False)
temp_dir = 'temp/'
shutil.copy(cell_file, temp_dir)
net_file = generate_network_for_sweeps(type, dataset_id, '%s.cell.nml'%(reference), reference, temp_dir)
lems_file_name = 'LEMS_Test_%s_%s.xml'%(type,dataset_id)
generate_lems_file_for_neuroml('Test_%s_%s'%(dataset_id,type),
net_file,
'network_%s_%s'%(dataset_id,type),
1500,
0.01,
lems_file_name,
temp_dir,
gen_plots_for_all_v=False,
copy_neuroml = False)
simulator = "jNeuroML_NEURON"
if simulator == "jNeuroML":
results = pynml.run_lems_with_jneuroml(temp_dir+lems_file_name,
nogui=True,
load_saved_data=True,
plot=False,
show_plot_already=False)
elif simulator == "jNeuroML_NEURON":
results = pynml.run_lems_with_jneuroml_neuron(temp_dir+lems_file_name,
nogui=True,
load_saved_data=True,
plot=False,
show_plot_already=False)
x = []
y = []
print results.keys()
tt = [t*1000 for t in results['t']]
for i in range(len(results)-1):
x.append(tt)
y.append([v*1000 for v in results['Pop0/%i/%s_%s/v'%(i,type,dataset_id)]])
pynml.generate_plot(x,
y,
"Cell: %s"%dataset_id,
xaxis = "Time (ms)",
yaxis = "Membrane potential (mV)",
show_plot_already=False,
ylim = [-120, 60],
save_figure_to = images%(reference, 'traces'))
def generate(cell_id, duration, reference,
Bee=1,
Ensyn = 10,
Erates = [50,100],
st_onset = 0,
st_duration = 1e9,
format='hdf5',
simulator=None,
num_processors=1,
target_group='soma_group',
temperature='35degC'):
#Insyn = int(Ensyn * 0.2)
#bInsyn = int(bEnsyn * 0.2)
cell_file = '../%s.cell.nml'%cell_id
if '/' in cell_id:
cell_id=cell_id.split('/')[-1]
nml_doc, network = oc.generate_network(reference, temperature=temperature)
oc.include_neuroml2_cell_and_channels(nml_doc,cell_file,cell_id)
synAmpaEE = oc.add_exp_one_syn(nml_doc, id="synAmpaEE", gbase="%snS"%Bee,
erev="0mV", tau_decay="1ms")
pop = oc.add_population_in_rectangular_region(network,
'L23_pop',
cell_id,
len(Erates),
0,0,0,
100,100,100)
to_plot = {'Some_voltages':[]}
to_save = {'%s_voltages.dat'%cell_id:[]}
interesting_seg_ids = [0,200,1000,2000,2500,2949] # [soma, .. some dends .. , axon]
interesting_seg_ids = [0] # [soma, .. some dends .. , axon]
for i,r in enumerate(Erates):
syn0 = oc.add_transient_poisson_firing_synapse(nml_doc,
id="%s_stim_%s"%(synAmpaEE.id,r),
average_rate="%s Hz"%r,
synapse_id=synAmpaEE.id,
delay='%s ms'%st_onset,
duration='%s ms'%st_duration)
oc.add_targeted_inputs_to_population(network,
"Esyn_%s"%r,
pop,
syn0.id,
segment_group=target_group,
number_per_cell = Ensyn,
all_cells=False,
only_cells=[i])
for seg_id in interesting_seg_ids:
to_plot.values()[0].append('%s/%s/%s/%s/v'%(pop.id, i, pop.component,seg_id))
to_save.values()[0].append('%s/%s/%s/%s/v'%(pop.id, i, pop.component,seg_id))
nml_file_name = '%s.net.nml'%network.id + ('.h5' if format=='hdf5' else '')
target_dir='./'
oc.save_network(nml_doc,
nml_file_name,
validate=False,
use_subfolder=True,
target_dir=target_dir,
format=format)
lems_file_name, lems_sim = oc.generate_lems_simulation(nml_doc,
network,
nml_file_name,
duration,
dt = 0.025,
target_dir=target_dir,
gen_plots_for_all_v = False,
plot_all_segments = False,
gen_plots_for_quantities = to_plot, # Dict with displays vs lists of quantity paths
gen_saves_for_all_v = False,
save_all_segments = False,
gen_saves_for_quantities = to_save, # Dict with file names vs lists of quantity paths
verbose = True)
if simulator:
print ("Running %s for %sms in %s"%(lems_file_name, duration, simulator))
traces, events = oc.simulate_network(lems_file_name,
simulator,
max_memory='4000M',
nogui=True,
load_saved_data=True,
reload_events=True,
plot=False,
verbose=True,
num_processors=num_processors)
rates = {}
tt = [t*1000 for t in traces['t']]
for tk in traces.keys():
if tk!='t':
rate = get_rate_from_trace(tt,[v*1000 for v in traces[tk]])
print("Cell %s has rate %s Hz"%(tk,rate))
i = int(tk.split('/')[1])
rates[Erates[i]]=rate
print Erates
print rates
ax = pynml.generate_plot([Erates],
[ [rates[r] for r in Erates] ],
"FF plots",
xaxis = 'Input frequency (Hz)',
yaxis = 'Firing frequency (Hz)',
markers=['o'],
show_plot_already=True) # Save figure
file_name = '%s.%s.%ssyns.%s.rates'%(cell_id,target_group,Ensyn,temperature)
f = open(file_name,'w')
for r in Erates:
f.write('%s\t%s\n'%(r,rates[r]))
f.close()
print("Finished! Saved rates data to %s"%file_name)
'IzPop1[{}]'.format(pre),
'spike')
lems_simulation_file = simulation.save_to_file()
pynml.run_lems_with_jneuroml_neuron(lems_simulation_file,
max_memory="2G",
nogui=True,
plot=False)
# Load the data from the file and plot the spike times
# using the pynml generate_plot utility function.
data_array_0 = np.loadtxt("%s.0.spikes.dat" % simulation_id)
data_array_1 = np.loadtxt("%s.1.spikes.dat" % simulation_id)
times_0 = data_array_0[:, 1]
times_1 = data_array_1[:, 1]
ids_0 = data_array_0[:, 0]
ids_1 = [id + size0 for id in data_array_1[:, 0]]
pynml.generate_plot(
[times_0, times_1],
[ids_0, ids_1],
"Spike times",
show_plot_already=False,
save_figure_to="%s-spikes.png" % simulation_id,
xaxis="time (s)",
yaxis="cell ID",
colors=['b', 'r'],
linewidths=['0', '0'],
markers=['.', '.'],
)
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 analyse_spiketime_vs_dt(nml2_file,
target,
duration,
simulator,
cell_v_path,
dts,
verbose=False,
spike_threshold_mV = 0,
show_plot_already=True,
save_figure_to=None,
num_of_last_spikes=None):
from pyelectro.analysis import max_min
import numpy as np
all_results = {}
dts=list(np.sort(dts))
for dt in dts:
if verbose:
print_comment_v(" == Generating simulation for dt = %s ms"%dt)
ref = str("Sim_dt_%s"%dt).replace('.','_')
lems_file_name = "LEMS_%s.xml"%ref
generate_lems_file_for_neuroml(ref,
nml2_file,
target,
duration,
dt,
lems_file_name,
'.',
gen_plots_for_all_v = True,
gen_saves_for_all_v = True,
copy_neuroml = False,
seed=None)
if simulator == 'jNeuroML':
results = pynml.run_lems_with_jneuroml(lems_file_name, nogui=True, load_saved_data=True, plot=False, verbose=verbose)
if simulator == 'jNeuroML_NEURON':
results = pynml.run_lems_with_jneuroml_neuron(lems_file_name, nogui=True, load_saved_data=True, plot=False, verbose=verbose)
print("Results reloaded: %s"%results.keys())
all_results[dt] = results
xs = []
ys = []
labels = []
spxs = []
spys = []
linestyles = []
markers = []
colors=[]
spike_times_final=[]
array_of_num_of_spikes=[]
for dt in dts:
t = all_results[dt]['t']
v = all_results[dt][cell_v_path]
xs.append(t)
ys.append(v)
labels.append(dt)
mm = max_min(v, t, delta=0, peak_threshold=spike_threshold_mV)
spike_times = mm['maxima_times']
spike_times_final.append(spike_times)
array_of_num_of_spikes.append(len(spike_times))
max_num_of_spikes=max(array_of_num_of_spikes)
min_dt_spikes=spike_times_final[0]
bound_dts=[math.log(dts[0]),math.log(dts[-1])]
if num_of_last_spikes == None:
num_of_spikes=len(min_dt_spikes)
else:
if len(min_dt_spikes) >=num_of_last_spikes:
num_of_spikes=num_of_last_spikes
else:
num_of_spikes=len(min_dt_spikes)
spike_indices=[(-1)*ind for ind in range(1,num_of_spikes+1) ]
if len(min_dt_spikes) > abs(spike_indices[-1]):
earliest_spike_time=min_dt_spikes[spike_indices[-1]-1]
else:
earliest_spike_time=min_dt_spikes[spike_indices[-1]]
for spike_ind in range(0,max_num_of_spikes):
spike_time_values=[]
dt_values=[]
for dt in range(0,len(dts)):
if spike_times_final[dt] !=[]:
if len(spike_times_final[dt]) >= spike_ind+1:
if spike_times_final[dt][spike_ind] >= earliest_spike_time:
spike_time_values.append(spike_times_final[dt][spike_ind])
dt_values.append(math.log(dts[dt]))
linestyles.append('')
markers.append('o')
colors.append('g')
spxs.append(dt_values)
spys.append(spike_time_values)
for last_spike_index in spike_indices:
vertical_line=[min_dt_spikes[last_spike_index],min_dt_spikes[last_spike_index] ]
spxs.append(bound_dts)
spys.append(vertical_line)
linestyles.append('--')
markers.append('')
colors.append('k')
pynml.generate_plot(spxs,
spys,
"Spike times vs dt",
colors=colors,
linestyles = linestyles,
markers = markers,
xaxis = 'ln ( dt (ms) )',
yaxis = 'Spike times (s)',
show_plot_already=show_plot_already,
save_figure_to=save_figure_to)
if verbose:
pynml.generate_plot(xs,
ys,
"Membrane potentials in %s for %s"%(simulator,dts),
labels = labels,
show_plot_already=show_plot_already,
save_figure_to=save_figure_to)
p =[]
f = []
m = []
c = []
for r in reports:
rep = reports[r]
ptype = rep['Prototype'] if rep['Prototype']!='Izhikevich' else 'Izh'
print("%s:\t%s %s\t %s(p%s)\t%s"%(r,ptype,rep['dataset'],rep['max_evaluations'],rep['population_size'],rep['fitness']))
p.append([rep['population_size']])
f.append([rep['fitness']])
m.append('.' if rep['Prototype']=='Izhikevich' else ('o' if rep['Prototype']=='AllenHH' else 'x'))
c.append('k' if rep['Prototype']=='Izhikevich' else ('b' if rep['Prototype']=='AllenHH' else 'r'))
print p
print f
print m
print c
from pyneuroml import pynml
pynml.generate_plot(p, # Add 2 sets of x values
f, # Add 2 sets of y values
"Some traces", # Title
markers = m,
colors = c,
logx = True,
logy = True,
show_plot_already=True)
for line in f:
if len(line.strip()) > 0: vals.append(float(line.strip()))
return vals
tt = read_dat_file(t_nrn_f)
vv = read_dat_file(v_nrn_f)
cc = read_dat_file(ca_nrn_f)
x.append(tt)
y.append(vv)
xc.append(tt)
yc.append(cc)
pynml.generate_plot(x,
y,
"V from: %s and %s" % (v_nml2_f, v_nrn_f),
xaxis="Time (ms)",
yaxis="Membrane potential (mV)",
labels=["NML2", "NRN"],
ylim=[-100, 40],
show_plot_already=False)
pynml.generate_plot(xc,
yc,
"[Ca2+] from: %s and %s" % (ca_nml2_f, ca_nrn_f),
xaxis="Time (ms)",
yaxis="Ca conc (mM)",
labels=["NML2", "NRN"],
show_plot_already=False)
plt.show()
#plot_cell_firing('../cells/AllenHH/AllenHH_477127614.cell.nml', num_processors=num_processors, show_plot=show)
#plot_cell_firing('../cells/AllenHH/AllenHH_476686112.cell.nml', num_processors=num_processors, show_plot=show)
#plot_cell_firing('../cells/BBP/cNAC187_L23_NBC_9d37c4b1f8_0_0.cell.nml', num_processors=num_processors, show_plot=show)
plot_cell_firing('../cells/SmithEtAl2013/L23_Retuned_477127614.cell.nml',
num_processors=num_processors,
show_plot=show)
refs = [('AllenHH_477127614', 'L23_Retuned_477127614'),
('AllenHH_476686112', 'cNAC187_L23_NBC_9d37c4b1f8_0_0')]
for ref in refs:
for ii in ['IF', 'IV']:
point_neuron, cols = pynml.reload_standard_dat_file('%s_%s.dat' %
(ref[0], ii))
detailed_neuron, cols = pynml.reload_standard_dat_file('%s_%s.dat' %
(ref[1], ii))
print detailed_neuron
pynml.generate_plot([point_neuron['t'], detailed_neuron['t']],
[point_neuron[0], detailed_neuron[0]],
"2 cells: %s, %s" % ref,
markers=['o', 'o'],
labels=[ref[0], ref[1]],
show_plot_already=False)
plt.show()
def analyse_cell(dataset_id,
type,
info,
nogui=False,
densities=False,
analysis_dir='../../data/'):
reference = '%s_%s' % (type, dataset_id)
cell_file = '%s/%s.cell.nml' % (type, reference)
print(
"====================================\n\n Analysing cell: %s, dataset %s\n"
% (cell_file, dataset_id))
nml_doc = pynml.read_neuroml2_file(cell_file)
notes = nml_doc.cells[0].notes if len(
nml_doc.cells) > 0 else nml_doc.izhikevich2007_cells[0].notes
meta_nml = eval(notes[notes.index('{'):])
summary = "Fitness: %s (max evals: %s, pop: %s)" % (
meta_nml['fitness'], meta_nml['max_evaluations'],
meta_nml['population_size'])
print summary
images = 'summary/%s_%s.png'
if_iv_data_files = 'summary/%s_%s.dat'
data, v_sub, curents_sub, freqs, curents_spike = get_if_iv_for_dataset(
'%s%s_analysis.json' % (analysis_dir, dataset_id))
if densities:
dataset = {}
seed = meta_nml['seed']
if isinstance(seed, tuple):
seed = seed[0]
layer = str(data['location'].split(',')[-1].strip().replace(' ', ''))
ref = '%s_%s_%s' % (dataset_id, layer, int(seed))
dataset['id'] = dataset_id
dataset['reference'] = ref
metas = ['aibs_cre_line', 'aibs_dendrite_type', 'location']
for m in metas:
dataset[m] = str(data[m])
metas2 = ['fitness', 'population_size', 'seed']
for m in metas2:
dataset[m] = meta_nml[m]
# Assume images below already generated...
if type == 'HH':
cell = nml_doc.cells[0]
sgv_files, all_info = generate_channel_density_plots(
cell_file, text_densities=True, passives_erevs=True)
sgv_file = sgv_files[0]
for c in all_info:
if c == cell.id:
cc = 'tuned_cell_info'
else:
cc = c
dataset[cc] = all_info[c]
info['datasets'][ref] = dataset
elif type == 'Izh':
dataset['tuned_cell_info'] = {}
izh_cell = nml_doc.izhikevich2007_cells[0]
for p in ['C', 'a', 'b', 'c', 'd', 'k', 'vpeak', 'vr', 'vt']:
dataset['tuned_cell_info'][p] = get_value_in_si(
getattr(izh_cell, p))
'''
sgv_files, all_info = generate_channel_density_plots(cell_file, text_densities=True, passives_erevs=True)
sgv_file =sgv_files[0]
for c in all_info:
if c == cell.id:
cc = 'tuned_cell_info'
else:
cc = c
dataset[cc] = all_info[c]'''
info['datasets'][ref] = dataset
else:
traces_ax, if_ax, iv_ax = generate_current_vs_frequency_curve(
cell_file,
reference,
simulator='jNeuroML_NEURON',
start_amp_nA=-0.1,
end_amp_nA=0.4,
step_nA=0.01,
analysis_duration=1000,
analysis_delay=50,
plot_voltage_traces=False,
plot_if=not nogui,
plot_iv=not nogui,
xlim_if=[-200, 400],
ylim_if=[-10, 120],
xlim_iv=[-200, 400],
ylim_iv=[-120, -40],
save_if_figure_to=images % (reference, 'if'),
save_iv_figure_to=images % (reference, 'iv'),
save_if_data_to=if_iv_data_files % (reference, 'if'),
save_iv_data_to=if_iv_data_files % (reference, 'iv'),
show_plot_already=False,
return_axes=True)
iv_ax.plot(curents_sub,
v_sub,
color='#ff2222',
marker='o',
linestyle='',
zorder=1)
if_ax.plot(curents_spike,
freqs,
color='#ff2222',
marker='o',
linestyle='',
zorder=1)
iv_ax.get_figure().savefig(images % (reference, 'iv'),
bbox_inches='tight')
if_ax.get_figure().savefig(images % (reference, 'if'),
bbox_inches='tight')
offset = 100 # mV
ifv_x = []
ifv_y = []
markers = []
lines = []
colors = []
cols = {'Izh': 'r', 'HH': 'g', 'AllenHH': 'b'}
for ii in ['if', 'iv']:
for tt in ['Izh', 'HH', 'AllenHH']:
rr = '%s_%s' % (tt, dataset_id)
f = if_iv_data_files % (rr, ii)
if os.path.isfile(f):
print("--- Opening: %s" % f)
data, indeces = reload_standard_dat_file(f)
ifv_x.append(data['t'])
if ii == 'if':
ifv_y.append([ff - offset for ff in data[0]])
else:
ifv_y.append([vv for vv in data[0]])
markers.append('')
colors.append(cols[tt])
lines.append('-')
ifv_x.append(curents_sub)
vvsub = [vv for vv in v_sub]
ifv_y.append(vvsub)
sub_color = '#888888'
markers.append('D')
colors.append('k')
lines.append('')
ifv_x.append(curents_spike)
ifv_y.append([ff - offset for ff in freqs])
markers.append('o')
colors.append(sub_color)
lines.append('')
import matplotlib
import matplotlib.pyplot as plt
print ifv_x
print ifv_y
ylim = [-105, -20]
font_size = 18
ax1 = pynml.generate_plot(ifv_x,
ifv_y,
summary,
markers=markers,
colors=colors,
linestyles=lines,
show_plot_already=False,
xlim=[-100, 400],
font_size=font_size,
ylim=ylim,
title_above_plot=False)
plt.xlabel('Input current (pA)', fontsize=font_size)
plt.ylabel("Steady membrane potential (mV)", fontsize=font_size)
ax2 = ax1.twinx()
plt.ylim([ylim[0] + offset, ylim[1] + offset])
plt.ylabel('Firing frequency (Hz)',
color=sub_color,
fontsize=font_size)
ax2.tick_params(axis='y', colors=sub_color)
#plt.axis('off')
plt.savefig(images % (reference, 'if_iv' + "_FIG"),
bbox_inches='tight')
temp_dir = 'temp/'
print("Copying %s to %s" % (cell_file, temp_dir))
shutil.copy(cell_file, temp_dir)
net_file = generate_network_for_sweeps(type,
dataset_id,
'%s.cell.nml' % (reference),
reference,
temp_dir,
data_dir=analysis_dir)
lems_file_name = 'LEMS_Test_%s_%s.xml' % (type, dataset_id)
generate_lems_file_for_neuroml('Test_%s_%s' % (dataset_id, type),
net_file,
'network_%s_%s' % (dataset_id, type),
1500,
0.01,
lems_file_name,
temp_dir,
gen_plots_for_all_v=False,
copy_neuroml=False)
simulator = "jNeuroML_NEURON"
if simulator == "jNeuroML":
results = pynml.run_lems_with_jneuroml(temp_dir + lems_file_name,
nogui=True,
load_saved_data=True,
plot=False,
show_plot_already=False)
elif simulator == "jNeuroML_NEURON":
results = pynml.run_lems_with_jneuroml_neuron(
temp_dir + lems_file_name,
nogui=True,
load_saved_data=True,
plot=False,
show_plot_already=False)
x = []
y = []
print results.keys()
tt = [t * 1000 for t in results['t']]
for i in range(len(results) - 1):
x.append(tt)
y.append([
v * 1000
for v in results['Pop0/%i/%s_%s/v' % (i, type, dataset_id)]
])
pynml.generate_plot(x,
y,
summary,
show_plot_already=False,
ylim=[-120, 60],
save_figure_to=images % (reference, 'traces'),
title_above_plot=True)
ax = pynml.generate_plot(x,
y,
summary,
show_plot_already=False,
ylim=[-120, 60],
title_above_plot=False)
ax.set_xlabel(None)
ax.set_ylabel(None)
plt.axis('off')
fig_file = images % (reference, 'traces' + "_FIG")
plt.savefig(fig_file, bbox_inches='tight', pad_inches=0)
from PIL import Image
img = Image.open(fig_file)
img2 = img.crop((60, 40, 660, 480))
img2.save(fig_file)
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
c = []
for r in reports:
rep = reports[r]
ptype = rep['Prototype'] if rep['Prototype'] != 'Izhikevich' else 'Izh'
print("%s:\t%s %s\t %s(p%s)\t%s" %
(r, ptype, rep['dataset'], rep['max_evaluations'],
rep['population_size'], rep['fitness']))
p.append([rep['population_size']])
f.append([rep['fitness']])
m.append('.' if rep['Prototype'] == 'Izhikevich' else (
'o' if rep['Prototype'] == 'AllenHH' else 'x'))
c.append('k' if rep['Prototype'] == 'Izhikevich' else (
'b' if rep['Prototype'] == 'AllenHH' else 'r'))
print p
print f
print m
print c
from pyneuroml import pynml
pynml.generate_plot(
p, # Add 2 sets of x values
f, # Add 2 sets of y values
"Some traces", # Title
markers=m,
colors=c,
logx=True,
logy=True,
show_plot_already=True)
x = []
y = []
for i in indices:
x.append(data['t'])
y.append(data[i])
totals = []
for j in range(len(data['t'])):
tot = 0
for i in indices:
tot+=data[i][j]
totals.append(tot)
labels = indices
x.append(data['t'])
y.append(totals)
labels.append('total')
pynml.generate_plot(x,
y,
"States from file: %s"%file,
xaxis = "Time (ms)",
yaxis = "State occupancy",
labels = labels,
show_plot_already=False,
save_figure_to = None,
cols_in_legend_box = 6)
plt.show()
def run(a=None, **kwargs):
a = build_namespace(a, **kwargs)
pynml.print_comment_v(
'Generating spiketime plot for %s; plotting: %s; save to: %s' %
(a.spiketime_files, a.show_plots_already, a.save_spike_plot_to))
xs = []
ys = []
labels = []
markers = []
linestyles = []
offset_id = 0
max_time = 0
max_id = 0
unique_ids = []
times = OrderedDict()
ids_in_file = OrderedDict()
if a.format == 'sonata' or a.format == 's':
for file_name in a.spiketime_files:
ids_times = read_sonata_spikes_hdf5_file(file_name)
x = []
y = []
max_id_here = 0
name = file_name.split('/')[-1]
if name.endswith('_spikes.h5'): name = name[:-10]
elif name.endswith('.h5'): name = name[:-3]
times[name] = []
ids_in_file[name] = []
for id in ids_times:
for t in ids_times[id]:
id_shifted = offset_id + int(float(id))
max_id = max(max_id, id_shifted)
if not id_shifted in ids_in_file[name]:
ids_in_file[name].append(id_shifted)
times[name].append(t)
max_id_here = max(max_id_here, id_shifted)
max_time = max(t, max_time)
if not id_shifted in unique_ids:
unique_ids.append(id_shifted)
x.append(t)
y.append(id_shifted)
print("max_id_here in %s: %i" % (file_name, max_id_here))
labels.append("%s (%i)" % (name, max_id_here - offset_id))
offset_id = max_id_here + 1
xs.append(x)
ys.append(y)
markers.append('.')
linestyles.append('')
xlim = [max_time / -20.0, max_time * 1.05]
ylim = [max_id_here / -20., max_id_here * 1.05]
markersizes = []
for xx in xs:
if len(unique_ids) > 50:
markersizes.append(2)
elif len(unique_ids) > 200:
markersizes.append(1)
else:
markersizes.append(4)
else:
for file_name in a.spiketime_files:
pynml.print_comment_v("Loading spike times from: %s" % file_name)
spikes_file = open(file_name)
x = []
y = []
max_id_here = 0
name = spikes_file.name
if name.endswith('.spikes'): name = name[:-7]
if name.endswith('.spike'): name = name[:-6]
times[name] = []
ids_in_file[name] = []
for line in spikes_file:
if not line.startswith('#'):
if a.format == 'id_t':
[id, t] = line.split()
elif a.format == 't_id':
[t, id] = line.split()
id_shifted = offset_id + int(float(id))
max_id = max(max_id, id_shifted)
t = float(t)
if not id_shifted in ids_in_file[name]:
ids_in_file[name].append(id_shifted)
times[name].append(t)
max_id_here = max(max_id_here, id_shifted)
max_time = max(t, max_time)
if not id_shifted in unique_ids:
unique_ids.append(id_shifted)
x.append(t)
y.append(id_shifted)
#print("max_id_here in %s: %i"%(file_name,max_id_here))
labels.append("%s (%i)" % (name, max_id_here - offset_id))
offset_id = max_id_here + 1
xs.append(x)
ys.append(y)
markers.append('.')
linestyles.append('')
xlim = [max_time / -20.0, max_time * 1.05]
ylim = [max_id_here / -20., max_id_here * 1.05]
markersizes = []
for xx in xs:
if len(unique_ids) > 50:
markersizes.append(2)
elif len(unique_ids) > 200:
markersizes.append(1)
else:
markersizes.append(4)
pynml.generate_plot(xs,
ys,
"Spike times from: %s" % a.spiketime_files,
labels=labels,
linestyles=linestyles,
markers=markers,
xaxis="Time (s)",
yaxis="Cell index",
xlim=xlim,
ylim=ylim,
markersizes=markersizes,
grid=False,
show_plot_already=False,
save_figure_to=a.save_spike_plot_to,
legend_position='right')
if a.rates:
plt.figure()
bins = a.rate_bins
for name in times:
tt = times[name]
ids_here = len(ids_in_file[name])
plt.hist(tt,
bins=bins,
histtype='step',
weights=[bins * max(tt) / (float(ids_here))] * len(tt),
label=name + "_h")
hist, bin_edges = np.histogram(
tt,
bins=bins,
weights=[bins * max(tt) / (float(ids_here))] * len(tt))
'''
width = bin_edges[1]-bin_edges[0]
mids = [i+width/2 for i in bin_edges[:-1]]
plt.plot(mids, hist,label=name)'''
plt.figure()
for name in times:
tt = times[name]
ids_here = len(ids_in_file[name])
hist, bin_edges = np.histogram(
tt,
bins=bins,
weights=[bins * max(tt) / (float(ids_here))] * len(tt))
width = bin_edges[1] - bin_edges[0]
mids = [i + width / 2 for i in bin_edges[:-1]]
boxes = [5, 10, 20, 50]
boxes = [20, 50]
boxes = [int(a.rate_window)]
for b in boxes:
box = np.ones(b)
hist_c = np.convolve(hist / len(box), box)
ys = hist_c
xs = [i / (float(len(ys))) for i in range(len(ys))]
plt.plot(xs, ys, label=name + '_%i_c' % b)
#plt.legend()
if a.show_plots_already:
plt.show()
else:
plt.close()
def analyse_cell(dataset_id, type, nogui=False):
reference = '%s_%s' % (type, dataset_id)
cell_file = '%s.cell.nml' % (reference)
images = 'summary/%s_%s.png'
generate_current_vs_frequency_curve(
cell_file,
reference,
simulator='jNeuroML_NEURON',
start_amp_nA=-0.1,
end_amp_nA=0.4,
step_nA=0.01,
analysis_duration=1000,
analysis_delay=50,
plot_voltage_traces=False,
plot_if=not nogui,
plot_iv=not nogui,
xlim_if=[-200, 400],
ylim_if=[-10, 120],
xlim_iv=[-200, 400],
ylim_iv=[-120, -40],
save_if_figure_to=images % (reference, 'if'),
save_iv_figure_to=images % (reference, 'iv'),
show_plot_already=False)
temp_dir = 'temp/'
shutil.copy(cell_file, temp_dir)
net_file = generate_network_for_sweeps(type, dataset_id,
'%s.cell.nml' % (reference),
reference, temp_dir)
lems_file_name = 'LEMS_Test_%s_%s.xml' % (type, dataset_id)
generate_lems_file_for_neuroml('Test_%s_%s' % (dataset_id, type),
net_file,
'network_%s_%s' % (dataset_id, type),
1500,
0.01,
lems_file_name,
temp_dir,
gen_plots_for_all_v=False,
copy_neuroml=False)
simulator = "jNeuroML_NEURON"
if simulator == "jNeuroML":
results = pynml.run_lems_with_jneuroml(temp_dir + lems_file_name,
nogui=True,
load_saved_data=True,
plot=False,
show_plot_already=False)
elif simulator == "jNeuroML_NEURON":
results = pynml.run_lems_with_jneuroml_neuron(temp_dir +
lems_file_name,
nogui=True,
load_saved_data=True,
plot=False,
show_plot_already=False)
x = []
y = []
print results.keys()
tt = [t * 1000 for t in results['t']]
for i in range(len(results) - 1):
x.append(tt)
y.append([
v * 1000
for v in results['Pop0/%i/%s_%s/v' % (i, type, dataset_id)]
])
pynml.generate_plot(x,
y,
"Cell: %s" % dataset_id,
xaxis="Time (ms)",
yaxis="Membrane potential (mV)",
show_plot_already=False,
ylim=[-120, 60],
save_figure_to=images % (reference, 'traces'))
def runNetwork(Be, Bi, nn_stim, show_gui=True):
Ntrials = 1
bw = 50.
N_max_rec_v = 2001
rec_conn = {'EtoE': 1, 'EtoI': 1, 'ItoE': 1, 'ItoI': 1}
print('####################')
print('### Be: %s, Bi: %s, nn_stim: %s) ' % (Be, Bi, nn_stim))
print('####################')
Bee, Bei = Be, Be
Bie, Bii = Bi, Bi
N = defaultParams.N
NE = defaultParams.NE
NI = defaultParams.NI
print('\n # -----> size of pert. inh: %s; base rate %s; pert rate %s' %
(nn_stim, defaultParams.r_bkg, defaultParams.r_stim))
r_extra = np.zeros(N)
r_extra[NE:NE + nn_stim] = defaultParams.r_stim
rr1 = defaultParams.r_bkg * np.ones(N)
rr2 = rr1 + r_extra
# -- restart the simulator
net_tools._nest_start_()
np.random.seed(1234)
init_seed = np.random.randint(1, 1234, defaultParams.n_cores)
nest.SetStatus([0], [{'rng_seeds': init_seed.tolist()}])
# -- exc & inh neurons
exc_neurons = net_tools._make_neurons_(NE, neuron_model=defaultParams.cell_type, \
myparams={'b':NE*[0.], 'a':NE*[0.]})
inh_neurons = net_tools._make_neurons_(NI, neuron_model=defaultParams.cell_type, \
myparams={'b':NE*[0.],'a':NE*[0.]})
# -- L23 recurrent connectivity
W_EtoE = _mycon_(NE, NE, Bee, .15)
W_EtoI = _mycon_(NE, NI, Bei, .15)
W_ItoE = _mycon_(NI, NE, Bie, 1.)
W_ItoI = _mycon_(NI, NI, Bii, 1.)
all_neurons = exc_neurons + inh_neurons
# -- recurrent connectivity
if rec_conn['EtoE']:
net_tools._connect_pops_(exc_neurons, exc_neurons, W_EtoE)
if rec_conn['EtoI']:
net_tools._connect_pops_(exc_neurons, inh_neurons, W_EtoI)
if rec_conn['ItoE']:
net_tools._connect_pops_(inh_neurons, exc_neurons, W_ItoE)
if rec_conn['ItoI']:
net_tools._connect_pops_(inh_neurons, inh_neurons, W_ItoI)
# -- recording spike data
spikes_all = net_tools._recording_spikes_(neurons=all_neurons)
if N <= N_max_rec_v:
v_all = net_tools._recording_voltages_(neurons=all_neurons)
# -- background input
pos_inp = nest.Create("poisson_generator", N)
for ii in range(N):
nest.Connect([pos_inp[ii]], [all_neurons[ii]], \
syn_spec = {'weight':defaultParams.Be_bkg, 'delay':defaultParams.delay_default})
# -- simulating network for N-trials
for tri in range(Ntrials):
print('')
print('# -> trial # ', tri + 1)
## transient
for ii in range(N):
nest.SetStatus([pos_inp[ii]], {'rate': rr1[ii]})
net_tools._run_simulation_(defaultParams.Ttrans)
## baseline
for ii in range(N):
nest.SetStatus([pos_inp[ii]], {'rate': rr1[ii]})
net_tools._run_simulation_(defaultParams.Tblank)
## perturbing a subset of inh
for ii in range(N):
nest.SetStatus([pos_inp[ii]], {'rate': rr2[ii]})
net_tools._run_simulation_(defaultParams.Tstim)
# -- reading out spiking activity
spd = net_tools._reading_spikes_(spikes_all)
if N <= N_max_rec_v:
v_rec = net_tools._reading_voltages_(v_all)
all_v = {}
all_t = []
for i in range(len(v_rec['senders'])):
v = v_rec['V_m'][i]
t = v_rec['times'][i]
index = v_rec['senders'][i]
if not index in all_v:
all_v[index] = []
all_v[index].append(v)
if not t in all_t:
all_t.append(t)
# -- computes the rates out of spike data in a given time interval
def _rate_interval_(spikedata, T1, T2, bw=bw):
tids = (spikedata['times'] > T1) * (spikedata['times'] < T2)
rr = np.histogram2d(spikedata['times'][tids], spikedata['senders'][tids], \
range=((T1,T2),(1,N)), bins=((T2-T1)/bw,N))[0] / (bw/1e3)
return rr
rout_blank = np.zeros((Ntrials, int(defaultParams.Tblank / bw), N))
rout_stim = np.zeros((Ntrials, int(defaultParams.Tstim / bw), N))
for tri in range(Ntrials):
Tblock = defaultParams.Tstim + defaultParams.Tblank + defaultParams.Ttrans
rblk = _rate_interval_(
spd, Tblock * tri + defaultParams.Ttrans,
Tblock * tri + defaultParams.Ttrans + defaultParams.Tblank)
rstm = _rate_interval_(
spd, Tblock * tri + defaultParams.Ttrans + defaultParams.Tblank,
Tblock * (tri + 1))
rout_blank[tri, :, :] = rblk
rout_stim[tri, :, :] = rstm
print('##########')
print('## Mean firing rates {Exc | Inh (pert.) | Inh (non-pert.)}')
print('## Before pert.: ', \
np.round(rout_blank[:,:,0:NE].mean(),1), \
np.round(rout_blank[:,:,NE:NE+nn_stim].mean(),1), \
np.round(rout_blank[:,:,NE+nn_stim:].mean(),1) )
print('## After pert.: ', \
np.round(rout_stim[:,:,0:NE].mean(),1), \
np.round(rout_stim[:,:,NE:NE+nn_stim].mean(),1), \
np.round(rout_stim[:,:,NE+nn_stim:].mean(),1) )
print('##########')
xs = [[], [], []]
ys = [[], [], []]
all_e = []
all_ip = []
all_inp = []
for i in range(len(spd['senders'])):
cellnum = spd['senders'][i]
time = spd['times'][i]
if cellnum <= NE:
xs[0].append(time)
all_e.append(time)
ys[0].append(cellnum)
elif cellnum <= NE + nn_stim:
xs[1].append(time)
all_ip.append(time)
ys[1].append(cellnum)
else:
xs[2].append(time)
all_inp.append(time)
ys[2].append(cellnum)
if show_gui:
from pyneuroml import pynml
print(
"Plotting %s spikes for %s E cells, %s spikes for %s Ip cells, %s spikes for %s Inp cells"
% (len(xs[0]), NE, len(xs[1]), nn_stim, len(
xs[2]), N - NE - nn_stim))
mksz = 1 if N > 100 else None
pynml.generate_plot(xs,
ys,
"Spike times: Be=%s; Bi=%s; N=%s; p=%s" %
(Be, Bi, N, nn_stim),
xaxis="Time (s)",
yaxis="Cell number",
colors=['red', 'black', 'blue'],
linestyles=['', '', ''],
markers=['.', '.', '.'],
markersizes=[mksz, mksz, mksz],
ylim=[0, N + 1],
grid=False,
show_plot_already=False)
plt.figure()
bins = 15
plt.hist(all_e,
bins=bins,
histtype='step',
weights=[1 / float(NE)] * len(all_e),
color='red')
plt.hist(all_ip,
bins=bins,
histtype='step',
weights=[1 / float(nn_stim)] * len(all_ip),
color='black')
plt.hist(all_inp,
bins=bins,
histtype='step',
weights=[1 / float(N - NE - nn_stim)] * len(all_inp),
color='blue',
ls='--')
plt.title("Histogram of spikes")
if N <= N_max_rec_v:
xs = []
ys = []
colors = []
for i in all_v:
xs.append(all_t)
ys.append(all_v[i])
if i <= NE:
colors.append('red')
elif i <= NE + nn_stim:
colors.append('black')
else:
colors.append('blue')
f = open('cell_%i.dat' % i, 'w')
for ti in range(len(all_t)):
t = all_t[ti] / 1000.
v = all_v[i][ti] / 1000.
f.write('%s\t%s\n' % (t, v))
f.close()
#print("Plotting %s traces for %s E cells, %s traces for %s Ip cells, %s traces for %s Inp cells"%(len(xs[0]), NE ,len(xs[1]), nn_stim, len(xs[2]), N-NE-nn_stim))
pynml.generate_plot(xs,
ys,
"Voltage traces: Be=%s; Bi=%s; N=%s; p=%s" %
(Be, Bi, N, nn_stim),
xaxis="Time (s)",
yaxis="Membrane potential (V)",
colors=colors,
grid=False,
show_plot_already=False)
elif 'Exc' in vs:
colours.append((1-tr_shade_e,1-tr_shade_e,1))
tr_shade_e*=0.8
elif 'Inh2' in vs:
colours.append((1,1-tr_shade_i,1))
tr_shade_e*=0.8
else:
colours.append((1,1-tr_shade_i,1-tr_shade_i))
tr_shade_i*=0.8
print(colours)
pynml.generate_plot(all_t, all_v,
"Sim g=%s, i=%s"%(g,i),
colors=colours,
show_plot_already=False,
xaxis = 'Time (ms)', # x axis legend
yaxis = 'Membrane potential (mV)', # y axis legend
save_figure_to='%s_traces.png'%desc)
count+=1
fig = pl.figure(figsize=(16,8))
info = "%s: scale %s, %s ms"%(run_in_simulator,scalePops, duration)
fig.canvas.set_window_title(info)
pl.suptitle(info)
_plot_(Rexc.T, g_rng, i_rng, 221, 'Rates Exc (Hz)')
_plot_(Rinh.T, g_rng, i_rng, 222, 'Rates Inh (Hz)')
max_id_here = 0
for line in spikes_file:
if not line.startswith('#'):
if format == 'id_t':
[id, t] = line.split()
elif format == 't_id':
[t, id] = line.split()
id_shift = max_id+int(float(id))
max_id_here = max(max_id_here,id_shift)
x.append(t)
y.append(id_shift)
max_id = max_id_here
xs.append(x)
ys.append(y)
labels.append(spikes_file.name)
markers.append('.')
linestyles.append('')
pynml.generate_plot(xs,
ys,
"Spike times from: %s"%spikes_file.name,
labels = labels,
linestyles=linestyles,
markers=markers,
xaxis = "Time (s)",
yaxis = "Cell number",
grid = False,
show_plot_already=True)
y = []
for i in indices:
x.append(data["t"])
y.append(data[i])
totals = []
for j in range(len(data["t"])):
tot = 0
for i in indices:
tot += data[i][j]
totals.append(tot)
labels = indices
x.append(data["t"])
y.append(totals)
labels.append("total")
pynml.generate_plot(
x,
y,
"States",
xaxis="Time (ms)",
yaxis="State occupancy",
labels=labels,
show_plot_already=False,
save_figure_to=None,
)
plt.show()
######## Some example data
ts = [t*0.01 for t in range(20000)]
siny = [math.sin(t/10) for t in ts]
cosey = [ math.exp(t/-80)*math.cos(t/5) for t in ts]
######## Generate a plot for this quickly with generate_plot
ax = pynml.generate_plot([ts,ts], # Add 2 sets of x values
[siny,cosey], # Add 2 sets of y values
"Some traces", # Title
xaxis = 'Time (ms)', # x axis legend
yaxis = 'Arbitrary units...', # y axis legend
linewidths = [2,3], # Thicknesses of each trace
show_plot_already=False, # Show or wait for plt.show()?
font_size = 10, # Font
bottom_left_spines_only = True, # Box or just x & y axes
save_figure_to='quick.png') # Save figure
######## Add another trace
ts_ = [t*0.1 for t in range(2000)]
randy = [ random.random() for t in ts_]
ax.plot(ts_,randy,'.') # Won't be included in saved PNG!
######## Show complete plot
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
colours.append(
(1 - tr_shade_e2, 1, 1 - tr_shade_e2))
tr_shade_e2 *= 0.8
elif 'Exc' in vs:
colours.append(
(1 - tr_shade_e, 1 - tr_shade_e, 1))
tr_shade_e *= 0.8
else:
colours.append(
(1, 1 - tr_shade_i, 1 - tr_shade_i))
tr_shade_i *= 0.8
print colours
pynml.generate_plot(all_t,
all_v,
"Sim g=%s, i=%s" % (g, i),
colors=colours,
show_plot_already=False)
count += 1
fig = pl.figure(figsize=(16, 8))
info = "%s: scale %s, %s ms" % (run_in_simulator, scalePops, duration)
fig.canvas.set_window_title(info)
pl.suptitle(info)
_plot_(Rexc.T, g_rng, i_rng, 221, 'Rates Exc (Hz)')
_plot_(Rinh.T, g_rng, i_rng, 222, 'Rates Inh (Hz)')
pl.subplots_adjust(wspace=.3, hspace=.3)
import sys
from pyneuroml import pynml
cell = sys.argv[1]
print("Comparing behaviour of cell %s to original NEURON code" % cell)
orig_dat = '../%s.soma.dat' % cell
orig_results, indices = pynml.reload_standard_dat_file(orig_dat)
print("Reloaded NEURON data: %s" % orig_results.keys())
results = pynml.run_lems_with_jneuroml_neuron('LEMS_%s.xml' % cell,
nogui=True,
load_saved_data=True)
print("Reloaded data: %s" % results.keys())
xs = []
ys = []
labels = []
xs.append([t * 1000 for t in results['t']])
ys.append([v * 1000 for v in results['Pop_%scell/0/%scell/v' % (cell, cell)]])
labels.append('jNeuroML_NEURON')
xs.append(orig_results['t'])
ys.append(orig_results[0])
labels.append('NEURON')
pynml.generate_plot(xs, ys, 'Plot of %s' % cell, labels=labels)
data, indices = pynml.reload_standard_dat_file('KAHP.states.dat')
x = []
y = []
for i in indices:
x.append(data['t'])
y.append(data[i])
totals = []
for j in range(len(data['t'])):
tot = 0
for i in indices:
tot+=data[i][j]
totals.append(tot)
labels = indices
x.append(data['t'])
y.append(totals)
labels.append('total')
pynml.generate_plot(x,
y,
"States",
xaxis = "Time (ms)",
yaxis = "State occupancy",
labels = labels,
show_plot_already=False,
save_figure_to = None)
plt.show()
data, indices = pynml.reload_standard_dat_file(ivf)
print("Loaded %s from %s" % (data.keys(), ivf))
iv_xs.append(data['t'])
iv_ys.append(data[0])
iv_labels.append(ref)
iff = '%s_IF.dat' % ref
data, indices = pynml.reload_standard_dat_file(iff)
print("Loaded %s from %s" % (data.keys(), iff))
if_xs.append(data['t'])
if_ys.append(data[0])
if_labels.append(ref)
pynml.generate_plot(iv_xs,
iv_ys,
"IV curves",
labels=iv_labels,
markers=['o'] * len(iv_labels),
show_plot_already=False)
pynml.generate_plot(if_xs,
if_ys,
"IF curves",
labels=if_labels,
markers=['o'] * len(if_labels))
else:
#plot_cell_firing('../cells/AllenHH/AllenHH_477127614.cell.nml')
#plot_cell_firing('../cells/AllenHH/AllenHH_476686112.cell.nml')
#plot_cell_firing('../cells/SmithEtAl2013/L23_Retuned_477127614.cell.nml')
plot_cell_firing('../cells/Thalamocortical/L23PyrRS.cell.nml',
quick=False,
num_processors=18,
def __init__(self,
runner,
vary,
fixed={},
verbose=False,
num_parallel_runs=1,
plot_all=False,
save_plot_all_to=None,
heatmap_all=False,
save_heatmap_to=None,
heatmap_lims=None,
show_plot_already=False,
peak_threshold=0):
self.sim = load_simulation_json(runner.nmllite_sim)
self.colormap = 'jet'
ps_id = 'ParamSweep_%s_%s' % (self.sim.id, time.ctime().replace(
' ', '_').replace(':', '.'))
print_v(
"Initialising ParameterSweep %s with %s, %s (%i parallel runs)" %
(ps_id, vary, fixed, num_parallel_runs))
os.mkdir(ps_id)
self.result_dir = os.path.abspath(ps_id)
self.runner = runner
self.fixed = fixed
self.vary = vary
self.verbose = verbose
self.num_parallel_runs = num_parallel_runs
self.plot_all = plot_all
self.save_plot_all_to = save_plot_all_to
self.heatmap_all = heatmap_all
self.save_heatmap_to = save_heatmap_to
self.heatmap_lims = heatmap_lims
self.show_plot_already = show_plot_already
self.index = 0
self.total_todo = 1
self.report = OrderedDict()
self.report['Varied parameters'] = vary
self.report['Fixed parameters'] = fixed
self.report['Simulations'] = OrderedDict()
for v in vary:
self.total_todo *= len(vary[v])
self.analysis_var = {
'peak_delta': 0,
'baseline': 0,
'dvdt_threshold': 0,
'peak_threshold': peak_threshold
}
if self.plot_all:
self.ax = pynml.generate_plot(
[],
[], # Add 2 sets of y values
"Traces generated from %s" % self.sim.id, # Title
labels=[],
xaxis='Time (ms)', # x axis legend
yaxis='Membrane potential (mV)', # y axis legend
title_above_plot=True,
show_plot_already=False) # Save figure
if self.heatmap_all:
if len(self.vary) != 1:
raise Exception(
'Heatmap can only be used when only one parameter is varied...'
)
self.hm_x = None
self.hm_y = []
self.hm_z = []
if seg == 'seg1406':
all_seg_1406.append(res[0])
avg_seg0 = np.zeros(len(all_seg_0[0]))
for l in all_seg_0:
for i in range(len(l)):
avg_seg0[i] += l[i]
avg_seg1406 = np.zeros(len(all_seg_1406[0]))
for l in all_seg_1406:
for i in range(len(l)):
avg_seg1406[i] += l[i]
pynml.generate_plot(xs,
ys,
'V clamp currents %s' % x,
ylim=lims[x],
labels=labels,
show_plot_already=False)
xs = []
ys = []
labels = []
xs.append(time_points)
ys.append(avg_seg0 / len(all_seg_0))
labels.append('%s average' % (seg))
pynml.generate_plot(xs,
ys,
'V clamp current averages at soma %s' % x,
ylim=lims[x],
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
currents_rate_spike[current] = 0
currents_v_sub[current] = sweeps[s]["pyelectro_iclamp_analysis"][steady_state_key]
curents_sub = currents_v_sub.keys()
curents_sub.sort()
v = [currents_v_sub[c] for c in curents_sub]
target_file = 'summary/%s_%s.png'
pynml.generate_plot([curents_sub],
[v],
"Subthreshold responses: %s"%id,
colors = ['k'],
linestyles=['-'],
markers=['o'],
xaxis = "Current (pA)",
yaxis = "Steady state (mV)",
xlim = [-200, 400],
ylim = [-120, -40],
grid = True,
show_plot_already=False,
save_figure_to = target_file%('subthreshold', id))
#plt.plot(curents_sub, , color='k', linestyle='-', marker='o')
curents_spike = currents_rate_spike.keys()
curents_spike.sort()
v = [currents_rate_spike[c] for c in curents_spike]
pynml.generate_plot([curents_spike],
[v],
"Spiking frequencies: %s"%id,
def run(a=None,**kwargs):
a = build_namespace(a,**kwargs)
pynml.print_comment_v('Generating spiketime plot for %s; plotting: %s; save to: %s'%(a.spiketime_files, a.show_plots_already, a.save_spike_plot_to))
xs = []
ys = []
labels = []
markers = []
linestyles = []
offset_id = 0
max_time = 0
max_id = 0
unique_ids = []
times = OrderedDict()
ids_in_file = OrderedDict()
if a.format == 'sonata' or a.format == 's':
for file_name in a.spiketime_files:
ids_times = read_sonata_spikes_hdf5_file(file_name)
x = []
y = []
max_id_here = 0
name = file_name.split('/')[-1]
if name.endswith('_spikes.h5'): name = name[:-10]
elif name.endswith('.h5'): name = name[:-3]
times[name] = []
ids_in_file[name] = []
for id in ids_times:
for t in ids_times[id]:
id_shifted = offset_id+int(float(id))
max_id = max(max_id,id_shifted)
if not id_shifted in ids_in_file[name]:
ids_in_file[name].append(id_shifted)
times[name].append(t)
max_id_here = max(max_id_here,id_shifted)
max_time = max(t,max_time)
if not id_shifted in unique_ids:
unique_ids.append(id_shifted)
x.append(t)
y.append(id_shifted)
print("max_id_here in %s: %i"%(file_name,max_id_here))
labels.append("%s (%i)"%(name,max_id_here-offset_id))
offset_id = max_id_here+1
xs.append(x)
ys.append(y)
markers.append('.')
linestyles.append('')
xlim = [max_time/-20.0, max_time*1.05]
ylim = [max_id_here/-20., max_id_here*1.05]
markersizes = []
for xx in xs:
if len(unique_ids)>50:
markersizes.append(2)
elif len(unique_ids)>200:
markersizes.append(1)
else:
markersizes.append(4)
else:
for file_name in a.spiketime_files:
pynml.print_comment_v("Loading spike times from: %s"%file_name)
spikes_file = open(file_name)
x = []
y = []
max_id_here = 0
name = spikes_file.name
if name.endswith('.spikes'): name = name[:-7]
if name.endswith('.spike'): name = name[:-6]
times[name] = []
ids_in_file[name] = []
for line in spikes_file:
if not line.startswith('#'):
if a.format == 'id_t':
[id, t] = line.split()
elif a.format == 't_id':
[t, id] = line.split()
id_shifted = offset_id+int(float(id))
max_id = max(max_id,id_shifted)
t = float(t)
if not id_shifted in ids_in_file[name]:
ids_in_file[name].append(id_shifted)
times[name].append(t)
max_id_here = max(max_id_here,id_shifted)
max_time = max(t,max_time)
if not id_shifted in unique_ids:
unique_ids.append(id_shifted)
x.append(t)
y.append(id_shifted)
#print("max_id_here in %s: %i"%(file_name,max_id_here))
labels.append("%s (%i)"%(name,max_id_here-offset_id))
offset_id = max_id_here+1
xs.append(x)
ys.append(y)
markers.append('.')
linestyles.append('')
xlim = [max_time/-20.0, max_time*1.05]
ylim = [max_id_here/-20., max_id_here*1.05]
markersizes = []
for xx in xs:
if len(unique_ids)>50:
markersizes.append(2)
elif len(unique_ids)>200:
markersizes.append(1)
else:
markersizes.append(4)
pynml.generate_plot(xs,
ys,
"Spike times from: %s"%a.spiketime_files,
labels = labels,
linestyles=linestyles,
markers=markers,
xaxis = "Time (s)",
yaxis = "Cell index",
xlim = xlim,
ylim = ylim,
markersizes = markersizes,
grid = False,
show_plot_already=False,
save_figure_to=a.save_spike_plot_to,
legend_position='right')
if a.rates:
plt.figure()
bins = a.rate_bins
for name in times:
tt = times[name]
ids_here = len(ids_in_file[name])
plt.hist(tt, bins=bins,histtype='step',weights=[bins*max(tt)/(float(ids_here))]*len(tt),label=name+"_h")
hist, bin_edges = np.histogram(tt, bins=bins,weights=[bins*max(tt)/(float(ids_here))]*len(tt))
'''
width = bin_edges[1]-bin_edges[0]
mids = [i+width/2 for i in bin_edges[:-1]]
plt.plot(mids, hist,label=name)'''
plt.figure()
for name in times:
tt = times[name]
ids_here = len(ids_in_file[name])
hist, bin_edges = np.histogram(tt, bins=bins,weights=[bins*max(tt)/(float(ids_here))]*len(tt))
width = bin_edges[1]-bin_edges[0]
mids = [i+width/2 for i in bin_edges[:-1]]
boxes = [5,10,20,50]
boxes = [20,50]
boxes = [int(a.rate_window)]
for b in boxes:
box = np.ones(b)
hist_c = np.convolve(hist/len(box), box)
ys = hist_c
xs = [i/(float(len(ys))) for i in range(len(ys))]
plt.plot(xs, ys,label=name+'_%i_c'%b)
#plt.legend()
if a.show_plots_already:
plt.show()
else:
plt.close()
3)
comp['iCa_CavN'] = (
'pop/0/cell1/biophysicalProperties/membraneProperties/CavN_all/iDensity',
4)
for var in comp.keys():
lems, nrn = comp[var]
xs = []
ys = []
labels = []
xs.append([t * 1000 for t in results['t']])
factor = 1
if var == 'v': factor = 1000 # 1 V = 1000.0 mV
if var == 'iCa_CavL': factor = .1 # 1 A_per_m2 = 0.1 mA_per_cm2
if var == 'iCa_CavN': factor = .1 # 1 A_per_m2 = 0.1 mA_per_cm2
ys.append([v * factor for v in results[lems]])
labels.append('jNeuroML_NEURON')
xs.append(orig_results['t'])
ys.append(orig_results[nrn])
labels.append('NEURON')
pynml.generate_plot(xs,
ys,
'Plot of %s' % var,
labels=labels,
show_plot_already=False)
plt.show()
def plotLines(self,
first_param,
value,
second_param=None,
save_figure_to=None,
logx=False,
logy=False):
all_pvals = OrderedDict()
all_lines = OrderedDict()
all_traces = []
DEFAULT_TRACE = self.sim.id
if not second_param:
all_traces = [DEFAULT_TRACE]
else:
for ref, info in self.report['Simulations'].items():
val2 = get_value_in_si(info['parameters'][second_param])
trace_id = '%s__%s' % (second_param, val2)
trace_id = val2
if not trace_id in all_traces:
all_traces.append(trace_id)
for t in all_traces:
all_lines[t] = {}
all_pvals[t] = {}
for ref, info in self.report['Simulations'].items():
print_v('Checking %s: %s' % (ref, info['parameters']))
pval = get_value_in_si(info['parameters'][first_param])
if not second_param:
trace_id = DEFAULT_TRACE
else:
val2 = get_value_in_si(info['parameters'][second_param])
trace_id = val2
if ':' in value:
matching_ref = value.split(':')[0]
feature = value.split(':')[1]
else:
matching_ref = '*'
feature = value
for cell_ref in info['analysis']:
print_v('Checking if %s matches %s, feature: %s (from %s)' %
(cell_ref, matching_ref, feature, value))
if matching_ref == cell_ref or matching_ref == '*':
#print('y')
if not cell_ref in all_lines[trace_id]:
all_lines[trace_id][cell_ref] = []
all_pvals[trace_id][cell_ref] = []
vval = info['analysis'][cell_ref][feature]
all_lines[trace_id][cell_ref].append(vval)
all_pvals[trace_id][cell_ref].append(pval)
print_v('Plot x: %s' % all_pvals)
print_v('Plot y: %s' % all_lines)
xs = []
ys = []
labels = []
markers = []
colors = []
maxy = -1 * sys.float_info.max
for t in all_traces:
for ref in all_lines[t]:
print_v('Add data %s, %s' % (t, ref))
xs.append(all_pvals[t][ref])
ys.append(all_lines[t][ref])
maxy = max(maxy, max(all_lines[t][ref]))
labels.append('%s - %s' % (t, ref))
markers.append('o')
pop_id = ref.split('[')[0] if '[' in ref else ref.split('/')[0]
if self.last_network_ran:
pop = self.last_network_ran.get_child(
pop_id, 'populations')
color = [float(c) for c in pop.properties['color'].split()]
else:
color = [random.random(), random.random(), random.random()]
pop = None
print_v("This trace %s has population %s: %s, so color: %s" %
(ref, pop_id, pop, color))
colors.append(color)
xlim = None
ylim = None
yaxis = value.replace('_', ' ')
yaxis = yaxis[0].upper() + yaxis[1:]
if value == 'mean_spike_frequency':
yaxis += ' (Hz)'
ylim = [maxy * -0.1, maxy * 1.1]
print_v('Setting y axes on freq plot to: %s' % ylim)
ax = pynml.generate_plot(xs,
ys,
"Plot of %s vs %s in %s" %
(value, first_param, self.sim),
xaxis=first_param,
yaxis=yaxis,
labels=labels if len(labels) > 1 else None,
markers=markers,
colors=colors,
xlim=xlim,
ylim=ylim,
logx=logx,
logy=logy,
show_plot_already=False,
legend_position='right',
save_figure_to=save_figure_to) # Save figure
######## Some example data
ts = [t * 0.01 for t in range(20000)]
siny = [math.sin(t / 10) for t in ts]
cosey = [math.exp(t / -80) * math.cos(t / 5) for t in ts]
######## Generate a plot for this quickly with generate_plot
ax = pynml.generate_plot(
[ts, ts], # Add 2 sets of x values
[siny, cosey], # Add 2 sets of y values
"Some traces", # Title
xaxis='Time (ms)', # x axis legend
yaxis='Arbitrary units...', # y axis legend
linewidths=[2, 3], # Thicknesses of each trace
show_plot_already=False, # Show or wait for plt.show()?
font_size=10, # Font
bottom_left_spines_only=True, # Box or just x & y axes
save_figure_to='quick.png') # Save figure
######## Add another trace
ts_ = [t * 0.1 for t in range(2000)]
randy = [random.random() for t in ts_]
ax.plot(ts_, randy, '.') # Won't be included in saved PNG!
######## Show complete plot
plt.show()
def analyse_extracted_data():
analysed = []
analysed = [f for f in os.listdir('.') if (f.endswith('_analysis.json'))]
#analysed = [ f for f in os.listdir('.') if (f.endswith('_analysis.json')) ]
analysed.sort()
info = {}
info[
'info'] = 'Cell models tuned to data extracted from Cell Types Database. Note: these are preliminary models designed to test the framework for generating NeuroML models from this data, not the final, optimised models.'
info['datasets'] = []
to_include = None
#to_include = ['468120757']
#to_include = ['477127614','476686112']
#to_include = ['477127614']
#to_include = ['464198958']
for f in analysed:
if to_include == None or f.split('_')[0] in to_include:
print("*************************\n Looking at: %s" % f)
dataset = {}
info['datasets'].append(dataset)
'''
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))
dataset['id'] = id
currents_v_sub = {}
currents_rate_spike = {}
for s in sweeps.keys():
current = float(sweeps[s]["sweep_metadata"]["aibs_stimulus_amplitude_pa"])
print("Sweep %s (%s pA)"%(s, current))
freq_key = '%s:mean_spike_frequency'%(s)
steady_state_key = '%s:average_1000_1200'%(s)
if sweeps[s]["pyelectro_iclamp_analysis"].has_key(freq_key):
currents_rate_spike[current] = sweeps[s]["pyelectro_iclamp_analysis"][freq_key]
else:
currents_rate_spike[current] = 0
currents_v_sub[current] = sweeps[s]["pyelectro_iclamp_analysis"][steady_state_key]
curents_sub = currents_v_sub.keys()
curents_sub.sort()
v = [currents_v_sub[c] for c in curents_sub]
'''
data, v_sub, curents_sub, v, curents_spike = get_if_iv_for_dataset(
f)
id = data['data_set_id']
dataset['id'] = data['data_set_id']
metas = ['aibs_cre_line', 'aibs_dendrite_type', 'location']
for m in metas:
dataset[m] = data[m]
target_file = 'summary/%s_%s.png'
pynml.generate_plot([curents_sub], [v_sub],
"Subthreshold responses: %s" % id,
colors=['k'],
linestyles=['-'],
markers=['o'],
xaxis="Current (pA)",
yaxis="Steady state (mV)",
xlim=[-200, 400],
ylim=[-120, -40],
grid=True,
show_plot_already=False,
save_figure_to=target_file %
('subthreshold', id))
#plt.plot(curents_sub, , color='k', linestyle='-', marker='o')
pynml.generate_plot([curents_spike], [v],
"Spiking frequencies: %s" % id,
colors=['k'],
linestyles=['-'],
markers=['o'],
xaxis="Current (pA)",
yaxis="Firing frequency (Hz)",
xlim=[-200, 400],
ylim=[-10, 120],
grid=True,
show_plot_already=False,
save_figure_to=target_file % ('spikes', id))
data0, indices = pynml.reload_standard_dat_file('%s.dat' % id)
x = []
y = []
tt = [t * 1000 for t in data0['t']]
for i in indices:
x.append(tt)
y.append([v * 1000 for v in data0[i]])
cols = ['b', 'g', 'r', 'c', 'm', 'y', 'k']
ax = pynml.generate_plot(x,
y,
"Example traces from: %s" % id,
xaxis="Time (ms)",
yaxis="Membrane potential (mV)",
ylim=[-120, 60],
colors=cols,
show_plot_already=False,
save_figure_to=target_file %
('traces', id))
ax.spines['right'].set_visible(False)
ax.spines['top'].set_visible(False)
ax.yaxis.set_ticks_position('left')
ax.xaxis.set_ticks_position('bottom')
sweeps = data['sweeps']
from data_helper import CURRENT_DATASETS, DATASET_TARGET_SWEEPS
i = 0
for s in DATASET_TARGET_SWEEPS[data['data_set_id']]:
current = float(sweeps[str(s)]["sweep_metadata"]
["aibs_stimulus_amplitude_pa"])
print("--- Sweep %s (%s pA)" % (s, current))
plt.text(1320,
+8 * i,
"%s pA" % (float('%.2f' % current)),
color=cols[i])
i += 1
plt.savefig(target_file % ('traces', id),
bbox_inches='tight',
pad_inches=0)
ax = pynml.generate_plot(x,
y,
"Example traces from: %s" % id,
ylim=[-120, 60],
colors=cols,
grid=False,
show_plot_already=False)
scale = 1 if not '477127614' in f else 1000
ax.plot([1300 * scale, 1300 * scale, 1500 * scale], [40, 20, 20],
color='k',
linewidth=5,
marker='',
solid_capstyle="butt",
solid_joinstyle='miter')
plt.axis('off')
fig_file = target_file % ('traces_FIG', id)
plt.savefig(fig_file, bbox_inches='tight', pad_inches=0)
from PIL import Image
img = Image.open(fig_file)
img2 = img.crop((60, 40, 660, 480))
img2.save(fig_file)
print(info)
make_html_file(info)
make_html_file(info, template=HTML_TEMPLATE_FILE_FIG, target='Figure.html')
make_md_file()
if not nogui:
plt.show()
def analyse_spiketime_vs_dx(lems_path_dict,
simulator,
cell_v_path,
verbose=False,
spike_threshold_mV = 0,
show_plot_already=True,
save_figure_to=None,
num_of_last_spikes=None):
from pyelectro.analysis import max_min
all_results = {}
comp_values=[]
for num_of_comps in lems_path_dict.keys():
comp_values.append(int(num_of_comps))
if verbose:
print_comment_v(" == Generating simulation for electrotonic length = %s"%(dx))
if simulator == 'jNeuroML':
results = pynml.run_lems_with_jneuroml(lems_path_dict[num_of_comps], nogui=True, load_saved_data=True, plot=False, verbose=verbose)
if simulator == 'jNeuroML_NEURON':
results = pynml.run_lems_with_jneuroml_neuron(lems_path_dict[num_of_comps], nogui=True, load_saved_data=True, plot=False, verbose=verbose)
print("Results reloaded: %s"%results.keys())
all_results[int(num_of_comps)] = results
xs = []
ys = []
labels = []
spxs = []
spys = []
linestyles = []
markers = []
colors=[]
spike_times_final=[]
array_of_num_of_spikes=[]
comp_values=list(np.sort(comp_values))
for num_of_comps in comp_values:
t = all_results[num_of_comps]['t']
v = all_results[num_of_comps][cell_v_path]
xs.append(t)
ys.append(v)
labels.append(num_of_comps)
mm = max_min(v, t, delta=0, peak_threshold=spike_threshold_mV)
spike_times = mm['maxima_times']
spike_times_final.append(spike_times)
array_of_num_of_spikes.append(len(spike_times))
max_num_of_spikes=max(array_of_num_of_spikes)
max_comps_spikes=spike_times_final[-1]
bound_comps=[comp_values[0],comp_values[-1]]
if num_of_last_spikes == None:
num_of_spikes=len(max_comps_spikes)
else:
if len(max_comps_spikes) >=num_of_last_spikes:
num_of_spikes=num_of_last_spikes
else:
num_of_spikes=len(max_comps_spikes)
spike_indices=[(-1)*ind for ind in range(1,num_of_spikes+1) ]
if len(max_comps_spikes) > abs(spike_indices[-1]):
earliest_spike_time=max_comps_spikes[spike_indices[-1]-1]
else:
earliest_spike_time=max_comps_spikes[spike_indices[-1]]
for spike_ind in range(0,max_num_of_spikes):
spike_time_values=[]
compartments=[]
for comp_value in range(0,len(comp_values)):
if spike_times_final[comp_value] !=[]:
if len(spike_times_final[comp_value]) >= spike_ind+1 :
if spike_times_final[comp_value][spike_ind] >= earliest_spike_time:
spike_time_values.append(spike_times_final[comp_value][spike_ind])
compartments.append(comp_values[comp_value])
linestyles.append('')
markers.append('o')
colors.append('b')
spxs.append(compartments)
spys.append(spike_time_values)
for last_spike_index in spike_indices:
vertical_line=[max_comps_spikes[last_spike_index],max_comps_spikes[last_spike_index] ]
spxs.append(bound_comps)
spys.append(vertical_line)
linestyles.append('--')
markers.append('')
colors.append('k')
pynml.generate_plot(spxs,
spys,
"Spike times vs spatial discretization",
colors=colors,
linestyles = linestyles,
markers = markers,
xaxis = 'Number of internal divisions',
yaxis = 'Spike times (s)',
show_plot_already=show_plot_already,
save_figure_to=save_figure_to)
if verbose:
pynml.generate_plot(xs,
ys,
"Membrane potentials in %s for %s"%(simulator,dts),
labels = labels,
show_plot_already=show_plot_already,
save_figure_to=save_figure_to)
