def _eval_at_all(self, expr, parameters, traces):
tr_present = []
for t in traces:
if t != "t" and t in expr:
tr_present.append(t)
ret_val = []
num_vals = len(traces[tr_present[0]])
print_(
"Evaluating %s with traces: %s (%i values) and params: %s"
% (expr, tr_present, num_vals, parameters.keys()),
self.verbose,
)
for i in range(num_vals):
noo = expr
for t in tr_present:
noo = noo.replace(t, str(traces[tr_present[0]][i]))
# print_v('%i: %s -> %s'%(i, expr, noo))
r = evaluate(noo, parameters)
ret_val.append(float(r))
print_(
"Generated: %s->%s (#%s)" % (ret_val[0], ret_val[-1], len(ret_val)),
self.verbose,
)
return ret_val
def showMatrix(self):
"""Generate matrix buttom has been pressed"""
print_v("Matrix button was clicked.")
if len(self.network.projections) == 0:
self.dialog_popup(
"No projections present in network, and so no matrix to show"
)
return
self.update_net_sim()
self.tabs.setCurrentWidget(self.matrixTab)
from neuromllite.MatrixHandler import MatrixHandler
level = 2
handler = MatrixHandler(level, nl_network=self.network)
from neuromllite.NetworkGenerator import generate_network
generate_network(self.network, handler, always_include_props=True, base_dir=".")
print_("Done with MatrixHandler...", self.verbose)
def updated_param(self, p):
"""A parameter has been updated"""
print_('===== Param %s changed' % p, self.verbose)
if self.autoRunCheckBox.isChecked():
self.runSimulation()
else:
print_('Nothing changing...', self.verbose)
self.update_net_sim()
if self.tabs.currentWidget() == self.nmlliteTab:
self.update_network_json()
self.update_simulation_json()
def showGraph(self):
"""Generate graph buttom has been pressed"""
print_v("Graph button was clicked.")
self.update_net_sim()
self.tabs.setCurrentWidget(self.all_tabs[self.GRAPH_TAB])
from neuromllite.GraphVizHandler import GraphVizHandler
engine = str(self.graphTypeComboBox.currentText()).split(" - ")[1]
level = int(self.graphLevelComboBox.currentText())
show_ext_inputs = self.graphShowExtInputs.isChecked()
show_input_pops = self.graphShowInputPops.isChecked()
format = "svg"
format = "png"
handler = GraphVizHandler(
level,
engine=engine,
nl_network=self.network,
output_format=format,
view_on_render=False,
include_ext_inputs=show_ext_inputs,
include_input_pops=show_input_pops,
)
from neuromllite.NetworkGenerator import generate_network
generate_network(self.network, handler, always_include_props=True, base_dir=".")
print_("Done with GraphViz...", self.verbose)
if format == "svg":
genFile = "%s.gv.svg" % self.network.id
self.add_image(genFile, self.GRAPH_TAB)
"""
svgWidget = QSvgWidget(genFile)
svgWidget.resize(svgWidget.sizeHint())
svgWidget.show()
self.graphTabLayout.addWidget(svgWidget, 0, 0)"""
elif format == "png":
genFile = "%s.gv.png" % self.network.id
self.add_image(genFile, self.GRAPH_TAB)
def update_net_sim(self):
"""Set the parameters in the network/simulation from the GUI values"""
for p in self.param_entries:
v = self.param_entries[p].text()
try:
v = int(v)
except:
try:
v = float(v)
except:
pass # leave as string...
print_('Setting param %s to %s' % (p, v), self.verbose)
if p=='seed':
self.network.seed = v
elif p=='temperature':
self.network.temperature = v
else:
self.network.parameters[p] = v
print_('All params: %s' % self.network.parameters, self.verbose)
for s in self.sim_entries:
v = float(self.sim_entries[s].text())
print_('Setting simulation variable %s to %s' % (s, v), self.verbose)
self.simulation.__setattr__(s, v)
def get_value_entry(self, name, value, entry_map):
"""Create a graphical element for displaying/setting values"""
simple = False
# simple = True
if simple:
entry = QLineEdit()
entry_map[name] = entry
entry.setText(str(value))
entry.textChanged.connect(self.updated_param)
else:
try:
entry = ParameterSpinBox()
entry_map[name] = entry
entry.setDecimals(18)
entry.setMaximum(1e16)
entry.setMinimum(-1e16)
entry.setSingleStep(value / 20.0)
entry.setValue(float(value))
entry.valueChanged.connect(self.updated_param)
except Exception as e:
print_v("Error: %s" % e)
entry = QLineEdit()
entry_map[name] = entry
entry.setText(str(value))
entry.textChanged.connect(self.updated_param)
entry.setToolTip("Parameter: %s (initial value: %s)" % (name, value))
print_(
"Created value entry widget for %s (= %s): %s (%s)"
% (name, value, entry, entry.text()),
self.verbose,
)
return entry
def replotSimResults(self):
simulator = str(self.simulatorComboBox.currentText())
self.traceSelectButton.setEnabled(True)
info = "Data from sim of %s%s" \
% (self.simulation.id, ' (%s)' % simulator
if simulator else '')
pop_colors = {}
for pop in self.network.populations:
for prop in pop.properties:
if prop == 'color':
rgb = pop.properties[prop].split()
color = '#'
for a in rgb:
color = color + '%02x' % int(float(a) * 255)
pop_colors[pop.id] = color
## Plot traces
xs = []
ys = []
labels = []
colors = []
colors_used = []
heat_array = []
for key in sorted(self.current_traces.keys()):
if not key in self.current_traces_shown:
self.current_traces_shown[key] = True
if key != 't':
heat_array.append(self.current_traces[key])
pop_id = key.split('/')[0]
if self.current_traces_shown[key]:
chosen_color = None
if key in self.current_traces_colours:
#print 'using stored for %s'%key
chosen_color = self.current_traces_colours[key]
colors.append(chosen_color)
else:
#print 'using new for %s'%key
if pop_id in pop_colors and not pop_colors[pop_id] in colors_used:
chosen_color = pop_colors[pop_id]
colors_used.append(pop_colors[pop_id])
else:
if key in self.backup_colors:
chosen_color = self.backup_colors[key]
else:
chosen_color = get_next_hex_color()
self.backup_colors[key] = chosen_color
colors.append(chosen_color)
self.current_traces_colours[key] = chosen_color
xs.append(self.current_traces['t'])
ys.append(self.current_traces[key])
labels.append(key)
ax_traces = self.tracesFigure.add_subplot(111)
ax_traces.clear()
for i in range(len(xs)):
ax_traces.plot(xs[i], ys[i], label=labels[i], linewidth=0.5, color=colors[i])
ax_traces.set_xlabel('Time (s)')
if self.showTracesLegend.isChecked():
self.tracesFigure.legend()
self.tracesCanvas.draw()
## Plot heatmap
ax_heatmap = self.heatmapFigure.add_subplot(111)
ax_heatmap.clear()
if len(heat_array)>0:
cm = matplotlib.cm.get_cmap('jet')
hm = ax_heatmap.pcolormesh(heat_array, cmap=cm)
#cbar = ax_heatmap.colorbar(im)
if self.heatmapColorbar == None:
self.heatmapColorbar = self.heatmapFigure.colorbar(hm)
self.heatmapColorbar.set_label('Firing rate')
self.heatmapCanvas.draw()
## Plot 2D
if self.simulation.plots2D is not None:
for plot2D in self.simulation.plots2D:
info = self.simulation.plots2D[plot2D]
fig = self.all_figures[plot2D]
ax_2d = fig.add_subplot(111)
ax_2d.clear()
x_axes = info['x_axis']
y_axes = info['y_axis']
if not type(x_axes) == dict:
x_axes = {plot2D:x_axes}
y_axes = {plot2D:y_axes}
for a in x_axes:
x_axis = x_axes[a]
y_axis = y_axes[a]
ax_2d.set_xlabel(x_axis)
ax_2d.set_ylabel(y_axis)
print_('Plotting %s for %s in %s: %s'%(a,plot2D, fig, info), self.verbose)
if x_axis in self.current_traces.keys():
xs = self.current_traces[x_axis]
else:
xs = self._eval_at_all(x_axis, self.network.parameters, self.current_traces)
if y_axis in self.current_traces.keys():
ys = self.current_traces[y_axis]
else:
ys = self._eval_at_all(y_axis, self.network.parameters, self.current_traces)
ax_2d.plot(xs,ys, linewidth=0.5, label=a)
from pyneuroml.analysis.NML2ChannelAnalysis import get_colour_hex
num_points = len(xs)
tot_dots = 2
if a!='a':
tot_dots=2
for i in range(tot_dots):
fract = i/float(tot_dots-1)
index = int(num_points*fract)
if index>=num_points:
index = -1
c = '%s'%get_colour_hex(fract, (0, 255, 0), (255, 0, 0))
#print('Point %s/%s, fract %s, index %i, %s'%(i,tot_dots, fract,index, c))
m = 4 if index==0 or index==-1 else 2
ax_2d.plot(xs[index],ys[index], 'o', color=c, markersize=m)
fig.legend()
self.all_canvases[plot2D].draw()
## Plot 3D
if self.simulation.plots3D is not None:
for plot3D in self.simulation.plots3D:
info = self.simulation.plots3D[plot3D]
fig = self.all_figures[plot3D]
#ax_3d = fig.add_subplot(111)
from mpl_toolkits.mplot3d import Axes3D
ax_3d = fig.gca(projection='3d')
ax_3d.clear()
xs = self.current_traces[info['x_axis']]
ys = self.current_traces[info['y_axis']]
zs = self.current_traces[info['z_axis']]
num_points = len(xs)
tot_dots = 300
for i in range(tot_dots):
fract = i/float(tot_dots-1)
index = int(num_points*fract)
if index>=num_points:
index = -1
c = '%s'%get_colour_hex(fract, (0, 255, 0), (255, 0, 0))
#print('Point %s/%s, fract %s, index %i, %s'%(i,tot_dots, fract,index, c))
m = 4 if index==0 or index==-1 else 1.5
ax_3d.plot([xs[index]],[ys[index]],[zs[index]], 'o', color=c, markersize=m)
ax_3d.plot(xs,ys,zs, linewidth=0.5)
ax_3d.set_xlabel(info['x_axis'])
ax_3d.set_ylabel(info['y_axis'])
ax_3d.set_zlabel(info['z_axis'])
print('Plotting for %s in %s: %s'%(plot3D, fig, info))
self.all_canvases[plot3D].draw()
## Plot spikes
spikesFigure = self.all_figures[self.SPIKES_RASTERPLOT]
ax_spikes = spikesFigure.add_subplot(111)
ax_spikes.clear()
ids_for_pop = {}
ts_for_pop = {}
include_input_pops = self.rasterInPops.isChecked()
pops_to_use = self._get_sorted_population_ids(include_input_pops=include_input_pops)
for k in self.current_events.keys():
spikes = self.current_events[k]
pop_id, cell_id = self._get_pop_id_cell_id(k)
if pop_id in pops_to_use:
if not pop_id in ids_for_pop:
ids_for_pop[pop_id] = []
ts_for_pop[pop_id] = []
for t in spikes:
ids_for_pop[pop_id].append(cell_id)
ts_for_pop[pop_id].append(t)
max_id = 0
for pop_id in sorted(ids_for_pop.keys()):
if pop_id in pop_colors:
c = pop_colors[pop_id]
else:
c = get_next_hex_color()
if pop_id in ts_for_pop:
shifted_ids = [id+max_id for id in ids_for_pop[pop_id]]
ax_spikes.plot(ts_for_pop[pop_id], shifted_ids, label=pop_id, linewidth=0, marker='.', color=c)
pop = self.network.get_child(pop_id, 'populations')
if pop.size is not None:
max_id_here = self._get_pop_size(pop_id)
else:
max_id_here = max(ids_for_pop[pop_id]) if len(ids_for_pop[pop_id])>0 else 0
print_('Finished with spikes for %s, go from %i with max %i'%(pop_id, max_id, max_id_here), self.verbose)
max_id += max_id_here
ax_spikes.set_xlabel('Time (s)')
ax_spikes.set_ylabel('Index')
tmax = self.simulation.duration/1000.
ax_spikes.set_xlim(tmax/-20.0, tmax*1.05)
ax_spikes.set_ylim(max_id/-20., max_id*1.05)
if self.rasterLegend.isChecked():
spikesFigure.legend()
self.all_canvases[self.SPIKES_RASTERPLOT].draw()
## Plot pop spike rates
popRateFigure = self.all_figures[self.SPIKES_POP_RATE_AVE]
ax_pop_rate = popRateFigure.add_subplot(111)
ax_pop_rate.clear()
rates = {}
print_('Generating rates from %s'%self.current_events.keys(), self.verbose)
xs = []
labels = []
pop_sizes = {}
count = 0
rates = {}
include_input_pops = self.spikeStatInPops.isChecked()
pops_to_use = self._get_sorted_population_ids(include_input_pops=include_input_pops)
for pop_id in pops_to_use:
xs.append(count)
labels.append(pop_id)
count +=1
pop_sizes[pop_id] = self._get_pop_size(pop_id)
rates[pop_id] = []
for k in self.current_events.keys():
spikes = self.current_events[k]
pop_id, cell_id = self._get_pop_id_cell_id(k)
if pop_id in pops_to_use:
rate = 1000*len(spikes)/self.simulation.duration
print_('%s: %s[%s] has %s spikes, so %s Hz'%(k, pop_id, cell_id, len(spikes), rate), self.verbose)
rates[pop_id].append(rate)
avg_rates = []
sd_rates = []
import numpy as np
for pop_id in pops_to_use:
avg_rates.append(np.mean(rates[pop_id]) if len(rates[pop_id])>0 else 0)
sd_rates.append(np.std(rates[pop_id]) if len(rates[pop_id])>0 else 0)
print_v('Calculated rates: %s; means: %s; stds: %s'%(rates,avg_rates,sd_rates))
bars = ax_pop_rate.bar(xs, avg_rates, yerr=sd_rates)
ax_pop_rate.set_ylabel('Rate (Hz)')
for bi in range(len(bars)):
bar = bars[bi]
bar.set_facecolor(pop_colors[labels[bi]])
ax_pop_rate.set_xticks(xs)
ax_pop_rate.set_xticklabels(labels)
ax_pop_rate.set_xticklabels(ax_pop_rate.get_xticklabels(), rotation=45, horizontalalignment='right')
self.all_canvases[self.SPIKES_POP_RATE_AVE].draw()
print_v('Finished plotting')