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')