def show_matplotlib_pre_loaded_figure_in_jupyter(fig: Figure):
# Suppresses: `Matplotlib is currently using module://ipykernel.pylab.backend_inline, which is a non-GUI backend, so cannot show the figure.`
# https://stackoverflow.com/questions/49503869/attributeerror-while-trying-to-load-the-pickled-matplotlib-figure?noredirect=1&lq=1
dummy = plt.figure()
new_manager = dummy.canvas.manager
new_manager.canvas.figure = fig
fig.set_canvas(new_manager.canvas)
def mathTex_to_QPixmap(mathTex, fs):
''' E/ mathTEx : The formula to be displayed on screen in LaTeX
E/ fs : The desired font size
S/ qpixmap : The image to be displayed in Qpixmap format '''
# Set up a mpl figure instance #
fig = Figure()
fig.patch.set_facecolor('none')
fig.set_canvas(FigureCanvas(fig))
renderer = fig.canvas.get_renderer()
# Plot the mathTex expression #
ax = fig.add_axes([0, 0, 1, 1])
ax.axis('off')
ax.patch.set_facecolor('none')
t = ax.text(0, 0, mathTex, ha='left', va='bottom', fontsize=fs)
# Fit figure size to text artist #
fwidth, fheight = fig.get_size_inches()
fig_bbox = fig.get_window_extent(renderer)
text_bbox = t.get_window_extent(renderer)
tight_fwidth = text_bbox.width * fwidth / fig_bbox.width
tight_fheight = text_bbox.height * fheight / fig_bbox.height
fig.set_size_inches(tight_fwidth, tight_fheight)
# Convert mpl figure to QPixmap #
buf, size = fig.canvas.print_to_buffer()
qimage = QtGui.QImage.rgbSwapped(QtGui.QImage(buf, size[0], size[1],
QtGui.QImage.Format_ARGB32))
qpixmap = QtGui.QPixmap(qimage)
return qpixmap
def subplots(nrows=1, ncols=1, figsize=(12, 8), dpi=120, num=0, subplot_kw={}):
"""
Equivalent function of pyplot.subplots(). The difference is that this one
is not interactive and is used with backend plotting only.
Parameters
----------
nrows=1, ncols=1, figsize=(12,8), dpi=120
num : dummy variable for compatibility
Returns
-------
fig, axes
"""
fig = Figure(figsize=figsize, dpi=dpi)
canvas = FigCanvas(fig)
fig.set_canvas(canvas)
axes = np.ndarray((nrows, ncols), dtype=np.object)
plt_nr = 1
for row in range(nrows):
for col in range(ncols):
axes[row, col] = fig.add_subplot(nrows, ncols, plt_nr,
**subplot_kw)
plt_nr += 1
return fig, axes
def residuals_at_max_likelihood(mcmc_set):
# Get the maximum likelihood parameters
try:
(max_likelihood, max_likelihood_position) = mcmc_set.maximum_likelihood()
except NoPositionsException as npe:
return Result(None, None)
# Get the residuals
residuals = mcmc_set.chains[0].get_residuals(max_likelihood_position)
# Make the residuals plot
fig = Figure()
ax = fig.gca()
plot_filename = '%s_max_likelihood_residuals.png' % mcmc_set.name
thumbnail_filename = '%s_max_likelihood_residuals_th.png' % mcmc_set.name
ax.plot(residuals[0], residuals[1])
ax.set_title('Residuals at Maximum Likelihood')
#ax.xlabel('Time')
#ax.ylabel('Residual')
canvas = FigureCanvasAgg(fig)
fig.set_canvas(canvas)
fig.savefig(plot_filename)
fig.savefig(thumbnail_filename, dpi=10)
return ThumbnailResult(thumbnail_filename, plot_filename)
def acf_of_ml_residuals(mcmc_set):
# Get the maximum likelihood parameters
try:
(max_likelihood, max_likelihood_position) = mcmc_set.maximum_likelihood()
except NoPositionsException as npe:
return Result(None, None)
# Get the residuals
residuals = mcmc_set.chains[0].get_residuals(max_likelihood_position)
# Plot the autocorrelation function
acf = np.correlate(residuals[1], residuals[1], mode='full')
plot_filename = '%s_acf_of_ml_residuals.png' % mcmc_set.name
thumbnail_filename = '%s_acf_of_ml_residuals_th.png' % mcmc_set.name
fig = Figure()
ax = fig.gca()
ax.plot(acf)
ax.set_title('Autocorrelation of Maximum Likelihood Residuals')
canvas = FigureCanvasAgg(fig)
fig.set_canvas(canvas)
fig.savefig(plot_filename)
fig.savefig(thumbnail_filename, dpi=10)
return ThumbnailResult(thumbnail_filename, plot_filename)
class ResponsePlotDialog(wx.Dialog):
def __init__(self, data, title="LRA Response", parent=None):
wx.Dialog.__init__(self, parent=parent, title=title)
pnl = wx.Panel(self)
pnl.SetBackgroundColour('white')
[time, disp, t_f] = data
# Plot
self.figure = Figure()
self.axes = self.figure.add_subplot(111)
self.canvas = FigureCanvas(pnl, -1, self.figure)
self.axes.grid(alpha=0.5)
self.figure.set_canvas(self.canvas)
self.axes.clear()
self.axes.set_ylabel("Displacement ($\mu$m)")
self.axes.set_xlabel("Time (ms)")
self.axes.set_title("LRA Response")
self.axes.grid(alpha=0.5)
self.axes.plot(time * 1e3, disp * 1e6)
self.axes.axvspan(0, t_f * 1000, color='green', alpha=0.25)
self.canvas.draw()
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(self.canvas, 0, wx.ALL, 10)
sizer.Add(self.CreateStdDialogButtonSizer(wx.OK), 0, wx.ALIGN_RIGHT)
# pnl.SetSizer(sizer)
sizer.SetSizeHints(self)
pnl.SetSizerAndFit(sizer)
self.Center()
def sample_fits(mcmc_set):
tspan = mcmc_set.chains[0].options.tspan
fig = Figure()
ax = fig.gca()
plot_filename = '%s_sample_fits.png' % mcmc_set.name
thumbnail_filename = '%s_sample_fits_th.png' % mcmc_set.name
# Make sure we can call the method 'get_observable_timecourses'
if not hasattr(mcmc_set.chains[0], 'get_observable_timecourses') or \
not hasattr(mcmc_set.chains[0], 'plot_data'):
return Result('None', None)
# Plot the original data
mcmc_set.chains[0].plot_data(ax)
# Plot a sampling of trajectories from the original parameter set
try:
for i in range(num_samples):
position = mcmc_set.get_sample_position()
timecourses = mcmc_set.chains[0].get_observable_timecourses(
position=position)
for obs_name, timecourse in timecourses.iteritems():
ax.plot(tspan, timecourse, color='g', alpha=0.1, label=obs_name)
except NoPositionsException as npe:
pass
canvas = FigureCanvasAgg(fig)
fig.set_canvas(canvas)
fig.savefig(plot_filename)
fig.savefig(thumbnail_filename, dpi=10)
return ThumbnailResult(thumbnail_filename, plot_filename)
def tBidBax_kd(mcmc_set):
""" .. todo:: document the basis for this"""
num_kds = 10000
# Get indices for the tBid/Bax binding constants
estimate_params = mcmc = mcmc_set.chains[0].options.estimate_params
tBid_iBax_kf_index = None
tBid_iBax_kr_index = None
for i, p in enumerate(estimate_params):
if p.name == 'tBid_iBax_kf':
tBid_iBax_kf_index = i
elif p.name == 'tBid_iBax_kr':
tBid_iBax_kr_index = i
# If we couldn't find the parameters, return None for the result
if tBid_iBax_kf_index is None or tBid_iBax_kr_index is None:
return Result(None, None)
# Sample the kr/kf ratio across the pooled chains
kd_dist = np.zeros(num_kds)
for i in range(num_kds):
position = mcmc_set.get_sample_position()
kd_dist[i] = ((10 ** position[tBid_iBax_kr_index]) /
(10 ** position[tBid_iBax_kf_index]))
# Calculate the mean and variance
mean = kd_dist.mean()
sd = kd_dist.std()
# Plot the Kd distribution
plot_filename = '%s_tBidiBax_kd_dist.png' % mcmc_set.name
fig = Figure()
ax = fig.gca()
ax.hist(kd_dist)
canvas = FigureCanvasAgg(fig)
fig.set_canvas(canvas)
fig.savefig(plot_filename)
return MeanSdResult(mean, sd, plot_filename)
class ImpedancePlotDialog(wx.Dialog):
def __init__(self, data, title="LRA Model", parent=None):
wx.Dialog.__init__(self, parent=parent, title=title)
pnl = wx.Panel(self)
pnl.SetBackgroundColour('white')
[freq, Ze] = data
# Plot
self.figure = Figure()
self.axes = self.figure.add_subplot(111)
self.canvas = FigureCanvas(pnl, -1, self.figure)
self.axes.grid(alpha=0.5)
self.figure.set_canvas(self.canvas)
self.axes.clear()
self.axes.set_ylabel("Ze (Ohms)")
self.axes.set_xlabel("Frequency (Hz)")
self.axes.set_title("LRA Impedance Spectrum")
self.axes.grid(alpha=0.5)
self.axes.loglog(freq, abs(Ze))
self.canvas.draw()
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(self.canvas, 0, wx.ALL, 10)
sizer.Add(self.CreateStdDialogButtonSizer(wx.OK), 0, wx.ALIGN_RIGHT)
sizer.SetSizeHints(self)
pnl.SetSizerAndFit(sizer)
self.Center()
def plot_parameter_curve(mcmc_set, p_index, p_name):
# Make sure we've already run the fits for this mcmc set!
if mcmc_set.name not in two_exp_fits_dict.keys():
raise Exception('%s not found in two_exp_fits_dict!' % mcmc_set.name)
# Make sure we've already run the fits for the data!
if 'data' not in two_exp_fits_dict.keys():
fit_data(mcmc_set)
# Get the parameter array
p_arr = two_exp_fits_dict[mcmc_set.name][p_index]
p_arr_data = two_exp_fits_dict['data'][p_index]
data = mcmc_set.chains[0].data
plot_filename = '%s_%s_curve.png' % (mcmc_set.name, p_name)
thumbnail_filename = '%s_%s_curve_th.png' % (mcmc_set.name, p_name)
# Plot of parameter
fig = Figure()
ax = fig.gca()
ax.plot(data.columns, p_arr, 'b')
ax.plot(data.columns, p_arr_data, marker='o', linestyle='', color='r')
ax.set_ylabel('%s value' % p_name)
ax.set_xlabel('[Bax] (nM)')
ax.set_title('%s for %s' % (mcmc_set.name, p_name))
canvas = FigureCanvasAgg(fig)
fig.set_canvas(canvas)
fig.savefig(plot_filename)
fig.savefig(thumbnail_filename, dpi=10)
return ThumbnailResult(thumbnail_filename, plot_filename)
def mathTex_to_QPixmap(mathTex, fs):
# ---- set up a mpl figure instance ----
fig = Figure()
fig.patch.set_facecolor('none')
fig.set_canvas(FigureCanvasAgg(fig))
renderer = fig.canvas.get_renderer()
# ---- plot the mathTex expression ----
ax = fig.add_axes([0, 0, 1, 1])
ax.axis('off')
ax.patch.set_facecolor('none')
t = ax.text(0, 0, mathTex, ha='left', va='bottom', fontsize=fs)
# ---- fit figure size to text artist ----
fwidth, fheight = fig.get_size_inches()
fig_bbox = fig.get_window_extent(renderer)
text_bbox = t.get_window_extent(renderer)
tight_fwidth = text_bbox.width * fwidth / fig_bbox.width
tight_fheight = text_bbox.height * fheight / fig_bbox.height
fig.set_size_inches(tight_fwidth, tight_fheight)
# ---- convert mpl figure to QPixmap ----
buf, size = fig.canvas.print_to_buffer()
qimage = QtGui.QImage.rgbSwapped(
QtGui.QImage(buf, size[0], size[1], QtGui.QImage.Format_ARGB32))
qpixmap = QtGui.QPixmap(qimage)
return qpixmap
def plot_raw_dataset_um(
points_um,
savedir='',
title='images',
grid=(3, 3),
figsize=(8, 8),
size=0.1,
dpi=300,
invert_yaxis=True,
):
'''
Plot the mRNA spots for each gene.
'''
print('Plotting mRNA spots of selected genes...')
if not os.path.exists(savedir):
os.makedirs(savedir)
genes_per_plot = grid[0] * grid[1]
num_plots, remain = divmod(len(points_um), genes_per_plot)
if remain != 0:
num_plots += 1
gene_list = list(points_um.keys())
gene_idx = 0
for plot_num in range(num_plots):
fig = Figure(figsize=figsize, dpi=dpi)
canvas = FigCanvas(fig)
fig.set_canvas(canvas)
for gridpos in range(genes_per_plot):
if gene_idx == len(points_um):
break
ax = fig.add_subplot(grid[0], grid[1], gridpos + 1)
ax.scatter(
points_um[gene_list[gene_idx]][:, 1],
points_um[gene_list[gene_idx]][:, 0],
s=size,
)
ax.set_aspect('equal')
ax.set_title(gene_list[gene_idx])
if invert_yaxis:
ax.invert_yaxis()
gene_idx += 1
fig.suptitle(title + f'\n {plot_num + 1} of {num_plots}')
fig.tight_layout(rect=(0, 0, 1, .94))
savename = (
f'raw_image_{plot_num+1}_{datetime.now().strftime("%Y%m%d_%H%M%S")}.png'
)
fig.savefig(os.path.join(savedir, savename), dpi=dpi)
canvas.close()
fig.clear()
plt.close()
def plot_noise_nc(fglob,chip,**kwargs):
if type(fglob) is str:
fnames = glob.glob(fglob)
else:
fnames = fglob
try:
plotall = kwargs.pop('plot_all')
except KeyError:
plotall = False
fnames.sort()
errors = {}
for fname in fnames:
try:
nc = EasyNetCDF4(fname)
hwg = nc.hw_state.group
fdir,fbase = os.path.split(fname)
fbase,ext = os.path.splitext(fbase)
chipfname = chip.replace(' ','_')
pdf = PdfPages('/home/data/plots/%s_%s.pdf' % (fbase,chipfname))
nms = []
for (k,((sname,swg),(tname,tsg))) in enumerate(zip(nc.sweeps.groups.items(),nc.timestreams.groups.items())):
#fig = plot_noise(swg,tsg,hwg,chip,**kwargs)
indexes = np.unique(swg.variables['index'][:])
for index in indexes:
kwargs['index'] = index
try:
nm = NoiseMeasurement(swg,tsg,hwg,chip,k,**kwargs)
except IndexError:
print "failed to find index",index,"in",sname,tname
continue
if pdf is not None:
if plotall or k == 0:
fig = Figure(figsize=(16,8))
title = ('%s %s' % (sname,tname))
nm.plot(fig=fig,title=title)
canvas = FigureCanvasAgg(fig)
fig.set_canvas(canvas)
pdf.savefig(fig,bbox_inches='tight')
else:
pdf.close()
pdf = None
del nm.fr_fine
del nm.pii_fine
del nm.prr_fine
nms.append(nm)
print fname,nm.start_temp,"K"
if pdf is not None:
pdf.close()
nc.group.close()
fh = open(os.path.join('/home/data','noise_' +fbase+'.pkl'),'w')
cPickle.dump(nms,fh,-1)
fh.close()
except Exception,e:
raise
errors[fname] = e
def scatterplot(points,
metadata,
lims=None,
outpath='/dev/null',
display=False):
f = Figure(figsize=(300 / dpi, 300 / dpi), dpi=dpi)
ax = f.gca()
for p in points:
if p.level is None:
# overrides cmap
color = marker_map[p.shape].color
else:
color = p.level
ax.scatter(p.x,
p.y,
c=color,
vmin=0,
vmax=1,
linewidth=0.5,
marker=marker_map[p.shape].marker,
s=100,
cmap=cmap_bwr)
if lims is None:
all_data = sum(([p.x, p.y] for p in points), [])
dmin = min(all_data)
dmax = max(all_data)
drange = dmax - dmin
lims = dmin - drange * 0.1, dmax + drange * 0.1
ax.set_xlim(lims)
ax.set_ylim(lims)
ax.set_aspect('equal')
ax.set_xlabel(build_label(metadata[0]))
ax.set_ylabel(build_label(metadata[1]))
for loc in 'top', 'right':
ax.spines[loc].set_color('none')
ax.xaxis.set_ticks_position('bottom')
ax.yaxis.set_ticks_position('left')
f.subplots_adjust(left=0.2,
bottom=0.15,
right=1,
top=1,
wspace=0,
hspace=0)
plt.setp(f, 'facecolor', 'none')
canvas = FigureCanvasAgg(f)
f.set_canvas(canvas)
# must always be called, even if outpath is '/dev/null', so that the
# returned figure object yields consistent pixel coordinates
canvas.print_png(outpath)
if display:
plt.show()
return f
def show_figure(fig: Figure) -> None:
"""
create a dummy figure and use its
manager to display "fig"
(to be used when "fig" lacks one)
"""
if not fig.canvas:
dummy = plt.figure()
new_manager = dummy.canvas.manager
new_manager.canvas.figure = fig
fig.set_canvas(new_manager.canvas)
def get_graph_proc(self):
print(f"GET request graph from {self.client_address}")
fig = Figure(figsize=(16, 8), dpi=80, facecolor='w', edgecolor='k')
dummy = plt.figure()
new_manager = dummy.canvas.manager
new_manager.canvas.figure = fig
fig.set_canvas(new_manager.canvas)
# subplots = fig.subplots(1, len(self.data_frames))
# fig, axs = fig.subplots(len(self.data_frames.keys()))
#result = f"<html>\n"
devices = data_frames.get
for device_name in devices:
#result += f"<center>{device_name}</center><br>"
graphs = devices[device_name]
dfl = len(graphs.keys())
if dfl == 0:
ax = fig.subplots()
ax.plot([0], [0])
elif dfl == 1:
dfk = list(graphs.keys())[0]
axs = fig.subplots()
axs.plot(graphs[dfk]['times'], graphs[dfk]['values'])
axs.set_title(dfk)
else:
f, axs = fig.subplots(dfl)
for i, df in enumerate(graphs.keys()):
axs[i].plot(graphs[df]['times'], graphs[df]['values'])
axs[i].set_title(df)
# for i, df in enumerate(self.data_frames):
# #ax = fig.add_subplot(len(self.data_frames), 1, i)
# ax = fig.add_subplot()
# ax.plot(self.data_frames[df]['x'], self.data_frames[df]['y'])
# ax.set_title(df)
plt.close(fig)
# Save it to a temporary buffer.
buf = io.BytesIO()
fig.savefig(buf, format="png")
# with open("result.png", 'wb') as output:
# fig.savefig(output, format="png")
# Embed the result in the html output.
data = base64.b64encode(buf.getbuffer()).decode("ascii")
self._set_response()
try:
self.wfile.write(
f"<html>\n<img src='data:image/png;base64,{data}'/>\n</html>".
encode("ascii"))
except Exception as e:
print(e)
def live_traffic():
with get_conn() as conn:
cur = conn.cursor(cursor_factory=psycopg2.extras.DictCursor)
destination_history_query = """
SELECT * FROM traffic WHERE recorded_at >= now() - INTERVAL '10 minutes';
"""
cur.execute(destination_history_query)
times = cur.fetchall()
fig = Figure(figsize=(30, 8),
dpi=80,
facecolor='w',
edgecolor='k',
tight_layout=True)
ax = fig.add_subplot(111)
begin_times = [row['recorded_at'] for row in times]
upload = [row['upload'] for row in times]
ax.plot_date(x=begin_times, y=upload, label='upload', linestyle='solid')
download = [row['download'] for row in times]
ax.plot_date(x=begin_times,
y=download,
label='download',
linestyle='solid')
ax.set_xlabel('Time')
ax.set_ylabel('Bandwidth')
ax.set_ylim(bottom=0)
ax.xaxis_date()
my_fmt = DateFormatter('%H:%M')
ax.xaxis.set_major_formatter(my_fmt)
ax.xaxis.set_major_locator(SecondLocator(interval=60))
ax.legend()
ax.grid()
png_output = io.BytesIO()
fig.set_canvas(FigureCanvasAgg(fig))
fig.savefig(png_output, transparent=True, format='png')
response = make_response(png_output.getvalue())
response.headers['content-type'] = 'image/png'
return response
class MPLPlotContainer(QWidget):
def __init__(self, tristan_data_plotter):
super().__init__()
self.tristan_data_plotter = tristan_data_plotter
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(0)
self.figure = Figure()
self.ax = self.figure.add_subplot(111)
# self.figure, self.ax = plt.subplots( 1, 1 )
self.canvas = FigureCanvas(self.figure)
self.figure.set_canvas(self.canvas)
layout.addWidget(self.canvas)
self.tristan_data_plotter.plotter.set_mpl_axes(self.ax)
self.setLayout(layout)
def update(self, timestep):
# self.figure.clf()
# print( 'called update' )
self.tristan_data_plotter.plot_timestep(timestep)
# print( 'drawing' )
# print( self.ax.lines[0].get_xydata() )
self.canvas.draw()
self.repaint()
# self.SetSize((self.Size[0],self.figurecanvas.Size[1]))
def get_canvas(self):
return self.ax
def delete(self):
pass
def clear(self):
self.tristan_data_plotter.clear()
def reset(self):
self.tristan_data_plotter.reset()
def chart(self,column):
from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
from matplotlib.figure import Figure
fig = Figure(figsize=(14,6))
canvas = FigureCanvas(fig)
fig.set_canvas(canvas)
ax = fig.add_subplot(111)
series = self.transactions().set_index('Date')[column]
series.plot(ax=ax)
fig.autofmt_xdate()
io = StringIO()
fig.savefig(io, format='svg')
return io.getvalue()
def increase_Bax_5x(mcmc_set):
""" .. todo:: document the basis for this"""
tspan = mcmc_set.chains[0].options.tspan
fig = Figure()
ax = fig.gca()
plot_filename = '%s_Bax_5x.png' % mcmc_set.name
thumbnail_filename = '%s_Bax_5x_th.png' % mcmc_set.name
# Make sure we can call the method 'get_observable_timecourses'
if not hasattr(mcmc_set.chains[0], 'get_observable_timecourses') or \
not hasattr(mcmc_set.chains[0], 'plot_data'):
return Result('None', None)
# Plot the original data
mcmc_set.chains[0].plot_data(ax)
# Plot a sampling of trajectories from the original parameter set
for i in range(num_samples):
position = mcmc_set.get_sample_position()
timecourses = mcmc_set.chains[0].get_observable_timecourses(position=position)
for obs_name, timecourse in timecourses.iteritems():
ax.plot(tspan, timecourse, color='g', alpha=0.5, label=obs_name)
# Now increase Bax 5-fold...
model = mcmc_set.chains[0].options.model
old_Bax_0 = model.parameters['Bax_0'].value
model.parameters['Bax_0'].value = old_Bax_0 * 5
# ...and do the sampling again
for i in range(num_samples):
position = mcmc_set.get_sample_position()
timecourses = mcmc_set.chains[0].get_observable_timecourses(position=position)
for obs_name, timecourse in timecourses.iteritems():
ax.plot(tspan, timecourse, color='r', alpha=0.5, label=obs_name)
canvas = FigureCanvasAgg(fig)
fig.set_canvas(canvas)
fig.savefig(plot_filename)
fig.savefig(thumbnail_filename, dpi=10)
# Make sure to reset the Bax initial condition to its original value!
model.parameters['Bax_0'].value = old_Bax_0
return ThumbnailResult(thumbnail_filename, plot_filename)
def marginals(mcmc_set):
"""Returns the vector of Gelman-Rubin convergence criterion values and a
link to an HTML file containing plots of the traces of the walk for each
parameter fitted."""
# Prepare html for page showing plots of parameter traces
html_str = "<html><head><title>Marginal distributions for " \
"%s</title></head>\n" % mcmc_set.name
html_str += "<body><p>Marginal distributions for for %s</p>\n" \
% mcmc_set.name
img_str_list = []
# Make plots of parameter traces
for i in range(mcmc_set.chains[0].num_estimate):
param_name = mcmc_set.chains[0].options.estimate_params[i].name
fig = Figure()
ax = fig.gca()
# Build a list of arrays containing positions for this parameter
chains_for_param = []
for chain in mcmc_set.chains:
# Don't try to plot marginals for a chain with no accepted steps!
if len(chain.positions) > 0:
chains_for_param.append(chain.positions[:, i])
# Plot the marginals
ax.hist(chains_for_param, histtype='step', bins=25)
ax.set_title("Parameter: %s" % param_name)
plot_filename = '%s_marginal_%s.png' % (mcmc_set.name, param_name)
canvas = FigureCanvasAgg(fig)
fig.set_canvas(canvas)
fig.savefig(plot_filename)
img_str_list.append(plot_filename)
# Make the html file
html_str += '\n'.join([
'<a href="%s"><img src="%s" width=400 /></a>' % (i, i)
for i in img_str_list
])
html_str += "</body></html>"
html_filename = '%s_marginals.html' % mcmc_set.name
with open(html_filename, 'w') as f:
f.write(html_str)
return Result(None, html_filename)
def change_tBid_concentration(mcmc_set, fold_change):
tspan = mcmc_set.chains[0].options.tspan
fig = Figure()
ax = fig.gca()
plot_filename = '%s_tBid_%.1fx.png' % (mcmc_set.name, fold_change)
thumbnail_filename = '%s_tBid_%.1fx_th.png' % (mcmc_set.name, fold_change)
# Make sure we can call the method 'get_observable_timecourses'
if not hasattr(mcmc_set.chains[0], 'get_observable_timecourses') or \
not hasattr(mcmc_set.chains[0], 'plot_data'):
return Result('None', None)
# Plot the original data
mcmc_set.chains[0].plot_data(ax)
# Plot a sampling of trajectories from the original parameter set
for i in range(num_samples):
position = mcmc_set.get_sample_position()
timecourses = mcmc_set.chains[0].get_observable_timecourses(position=position)
for obs_name, timecourse in timecourses.iteritems():
ax.plot(tspan, timecourse, color='g', alpha=0.5, label=obs_name)
# Now change tBid x-fold...
model = mcmc_set.chains[0].options.model
old_tBid_0 = model.parameters['tBid_0'].value
model.parameters['tBid_0'].value = old_tBid_0 * fold_change
# ...and do the sampling again
for i in range(num_samples):
position = mcmc_set.get_sample_position()
timecourses = mcmc_set.chains[0].get_observable_timecourses(position=position)
for obs_name, timecourse in timecourses.iteritems():
ax.plot(tspan, timecourse, color='r', alpha=0.5, label=obs_name)
canvas = FigureCanvasAgg(fig)
fig.set_canvas(canvas)
fig.savefig(plot_filename)
fig.savefig(thumbnail_filename, dpi=10)
# Make sure to reset the tBid initial condition to its original value!
model.parameters['tBid_0'].value = old_tBid_0
return ThumbnailResult(thumbnail_filename, plot_filename)
def fit_plotting_function(self, position):
"""Gets the observable timecourse and plots it against the data.
Useful for visualizing model output by examining the fit of the model
at the maximum likelihood or maximum a posteriori parameters, etc.
Parameters
----------
position : numpy.array
Vector of parameter values to use for simulation and plotting.
Returns
-------
matplotlib.figure.Figure
Figure instance containing the plot of the data and the simulation
at the given position.
"""
# Run the simulation at the given position
timecourses = self.get_observable_timecourses(position)
# Make the plot
fig = Figure()
ax = fig.gca()
# Add the data to the plot
self.plot_data(ax)
# Add the simulations to the plot
for obs_name, timecourse in timecourses.iteritems():
ax.plot(timecourse[0], timecourse[1], label=obs_name)
# Label the plot
ax.set_xlabel('Time')
ax.set_ylabel('Concentration')
fontP = FontProperties()
fontP.set_size('small')
box = ax.get_position()
ax.set_position([box.x0, box.y0, box.width * 0.8, box.height])
ax.legend(loc='upper left', prop=fontP, ncol=1, bbox_to_anchor=(1, 1),
fancybox=True, shadow=True)
#ax.legend(loc='upper center', prop=fontP, ncol=5,
# bbox_to_anchor=(0.5, 1.1), fancybox=True, shadow=True)
canvas = FigureCanvasAgg(fig)
fig.set_canvas(canvas)
return fig
def iBax_monotonically_increasing(mcmc_set):
""" .. todo:: document the basis for this"""
tspan = mcmc_set.chains[0].options.tspan
fig = Figure()
ax = fig.gca()
plot_filename = '%s_iBax_monotonic_increasing.png' % mcmc_set.name
num_true = 0
for i in range(num_samples):
x = mcmc_set.get_sample_simulation()
ax.plot(tspan, x['iBax'], color='r', alpha=0.5)
if monotonic_increasing(x['iBax']):
num_true += 1
canvas = FigureCanvasAgg(fig)
fig.set_canvas(canvas)
fig.savefig(plot_filename)
return FuzzyBooleanResult(float(num_true) / float(num_samples),
plot_filename, expectation=1.0)
def marginals(mcmc_set):
"""Returns the vector of Gelman-Rubin convergence criterion values and a
link to an HTML file containing plots of the traces of the walk for each
parameter fitted."""
# Prepare html for page showing plots of parameter traces
html_str = "<html><head><title>Marginal distributions for " \
"%s</title></head>\n" % mcmc_set.name
html_str += "<body><p>Marginal distributions for for %s</p>\n" \
% mcmc_set.name
img_str_list = []
# Make plots of parameter traces
for i in range(mcmc_set.chains[0].num_estimate):
param_name = mcmc_set.chains[0].options.estimate_params[i].name
fig = Figure()
ax = fig.gca()
# Build a list of arrays containing positions for this parameter
chains_for_param = []
for chain in mcmc_set.chains:
# Don't try to plot marginals for a chain with no accepted steps!
if len(chain.positions) > 0:
chains_for_param.append(chain.positions[:,i])
# Plot the marginals
ax.hist(chains_for_param, histtype='step')
ax.set_title("Parameter: %s" % param_name)
plot_filename = '%s_marginal_%s.png' % (mcmc_set.name, param_name)
canvas = FigureCanvasAgg(fig)
fig.set_canvas(canvas)
fig.savefig(plot_filename)
img_str_list.append(plot_filename)
# Make the html file
html_str += '\n'.join([
'<a href="%s"><img src="%s" width=400 /></a>' %
(i, i) for i in img_str_list])
html_str += "</body></html>"
html_filename = '%s_marginals.html' % mcmc_set.name
with open(html_filename, 'w') as f:
f.write(html_str)
return Result(None, html_filename)
def scatterplot(points, metadata, lims=None, outpath='/dev/null',
display=False):
f = Figure(figsize=(300 / dpi, 300 / dpi), dpi=dpi)
ax = f.gca()
for p in points:
if p.level is None:
# overrides cmap
color = marker_map[p.shape].color
else:
color = p.level
ax.scatter(p.x, p.y, c=color, vmin=0, vmax=1, linewidth=0.5,
marker=marker_map[p.shape].marker, s=100, cmap=cmap_bwr)
if lims is None:
all_data = sum(([p.x, p.y] for p in points), [])
dmin = min(all_data)
dmax = max(all_data)
drange = dmax - dmin
lims = dmin - drange * 0.1, dmax + drange * 0.1
ax.set_xlim(lims)
ax.set_ylim(lims)
ax.set_aspect('equal')
ax.set_xlabel(build_label(metadata[0]))
ax.set_ylabel(build_label(metadata[1]))
for loc in 'top', 'right':
ax.spines[loc].set_color('none')
ax.xaxis.set_ticks_position('bottom')
ax.yaxis.set_ticks_position('left')
f.subplots_adjust(left=0.2, bottom=0.15, right=1, top=1, wspace=0, hspace=0)
plt.setp(f, 'facecolor', 'none')
canvas = FigureCanvasAgg(f)
f.set_canvas(canvas)
# must always be called, even if outpath is '/dev/null', so that the
# returned figure object yields consistent pixel coordinates
canvas.print_png(outpath)
if display:
plt.show()
return f
def fit_plotting_function(self, position):
"""Gets the observable timecourse and plots it against the data."""
# Run the simulation at the given position
timecourses = self.get_observable_timecourses(position)
# Make the plot
fig = Figure()
ax = fig.gca()
# Add the data to the plot
self.plot_data(ax)
# Add the simulations to the plot
for obs_name, timecourse in timecourses.iteritems():
ax.plot(self.mcmc.options.tspan, timecourse, label=obs_name)
# Label the plot
ax.set_xlabel('Time')
ax.set_ylabel('Concentration')
fontP = FontProperties()
fontP.set_size('small')
ax.legend(loc='upper center', prop=fontP, ncol=5,
bbox_to_anchor=(0.5, 1.1), fancybox=True, shadow=True)
canvas = FigureCanvasAgg(fig)
fig.set_canvas(canvas)
return fig
def two_exponential_fits(mcmc_set):
# Use the first MCMC in the chain to get the data, etc.
mcmc = mcmc_set.chains[0]
# Run a simulation
(max_lkl, max_lkl_position) = mcmc_set.maximum_likelihood()
data = mcmc.get_observables_as_dataframe(max_lkl_position)
bax_concs = np.array(data.columns, dtype='float')
plot_filename = '%s_two_exp_fits.png' % (mcmc_set.name)
thumbnail_filename = '%s_two_exp_fits_th.png' % (mcmc_set.name)
fit = TwoExp()
(k1_arr, fmax_arr, k2_arr) = fit.fit_from_dataframe(data)
fig = Figure()
for i, bax_conc in enumerate(bax_concs):
ax = fig.gca()
conc_data = data[bax_conc]
time = conc_data[:, 'TIME']
y = conc_data[:, 'MEAN']
two_exp_fit = fit.fit_func(time, (k1_arr[i], fmax_arr[i], k2_arr[i]))
# Plot original sim
ax.plot(time, y, 'b')
# Plot fitted func
ax.plot(time, two_exp_fit, 'r')
ax.set_title('Two-exponential fits for %s' % mcmc_set.name)
ax.set_xlabel('Time')
ax.set_ylabel('Dye release')
#ax.legend(loc='lower right')
canvas = FigureCanvasAgg(fig)
fig.set_canvas(canvas)
fig.savefig(plot_filename)
fig.savefig(thumbnail_filename, dpi=10)
two_exp_fits_dict[mcmc_set.name] = (fmax_arr, k1_arr, k2_arr)
return ThumbnailResult(thumbnail_filename, plot_filename)
class CanvasPanel(wx.Panel):
def __init__(self, parent):
super().__init__(parent, size=(800, 480))
matplotlib.rc('axes', edgecolor='black', linewidth=1)
self.figure = Figure()
self._axes = self.figure.add_axes([0, 0, 1, 1])
self._axes.set(xlim=(0, 1), ylim=(0, 1))
self._scat = self._axes.scatter(x=[], y=[])
self._canvas = FigureCanvas(self, id=-1, figure=self.figure)
self.figure.set_canvas(self._canvas)
box_sizer = wx.BoxSizer(wx.VERTICAL)
box_sizer.Add(self._canvas, proportion=1, flag=wx.EXPAND | wx.TOP, border=6)
self.SetSizer(box_sizer)
self.Fit()
def draw_markers(self, marker_positions, marker_sizes, marker_colors):
self._scat.set_offsets(marker_positions)
self._scat.set_sizes(marker_sizes)
self._scat.set_facecolors(marker_colors)
def clear(self):
self._scat.remove()
self._scat = self._axes.scatter(x=[], y=[])
def latex_to_qtpixmap(str_, fontsize_=None):
figure_ = Figure()
figure_.set_canvas(FigureCanvasAgg(figure_))
figure_.patch.set_facecolor("none")
ax_ = figure_.add_axes([0, 0, 1, 1])
ax_.axis('off')
text_ = ax_.text(0,
0,
str_,
ha='left',
va='bottom',
fontsize=fontsize_)
f_w_, f_h_ = figure_.get_size_inches()
bbox_f_ = figure_.get_window_extent(figure_.canvas.get_renderer())
bbox_t_ = text_.get_window_extent(figure_.canvas.get_renderer())
figure_.set_size_inches((bbox_t_.width / bbox_f_.width) * f_w_,
(bbox_t_.height / bbox_f_.height) * f_h_)
buf, size = figure_.canvas.print_to_buffer()
return QtGui.QImage.rgbSwapped(
QtGui.QImage(buf, *size, QtGui.QImage.Format_ARGB32))
def sample_fits(mcmc_set):
fig = Figure()
ax = fig.gca()
plot_filename = '%s_sample_fits.png' % mcmc_set.name
thumbnail_filename = '%s_sample_fits_th.png' % mcmc_set.name
# Make sure we can call the method 'get_observable_timecourses'
if not hasattr(mcmc_set.chains[0], 'get_observable_timecourses') or \
not hasattr(mcmc_set.chains[0], 'plot_data'):
return Result('None', None)
# Plot the original data
mcmc_set.chains[0].plot_data(ax)
# Plot a sampling of trajectories from the original parameter set
try:
for i in range(num_samples):
position = mcmc_set.get_sample_position()
timecourses = mcmc_set.chains[0].get_observable_timecourses(
position=position)
for obs_name, timecourse in timecourses.iteritems():
ax.plot(timecourse[0],
timecourse[1],
color='g',
alpha=0.1,
label=obs_name)
except NoPositionsException as npe:
pass
canvas = FigureCanvasAgg(fig)
fig.set_canvas(canvas)
fig.savefig(plot_filename)
fig.savefig(plot_filename.replace('.png', '.pdf'))
fig.savefig(thumbnail_filename, dpi=10)
return ThumbnailResult(thumbnail_filename, plot_filename)
def plot_noise_nc(fglob,**kwargs):
"""
Create noise measurements from all noise sweeps in a netcdf file, make plots, and pickle the noise measurements
fglob : string or list
filename glob. Can be either a filename, which can contain * or ? wildcards, or a list of files
plot_all : bool (default False)
if True, plot all sweeps, otherwise just plot the first one for each resonator
**kwargs are passed to the noise measurement class
"""
if type(fglob) is str:
fnames = glob.glob(fglob)
else:
fnames = fglob
plotall = kwargs.pop('plot_all',False)
fnames.sort()
errors = {}
pdf = None
for fname in fnames:
try:
fdir,fbase = os.path.split(fname)
fbase,ext = os.path.splitext(fbase)
rnc = readoutnc.ReadoutNetCDF(fname)
nms = []
for (k,((sname,swg),(tname,tsg))) in enumerate(zip(rnc.sweeps_dict.items(),rnc.timestreams_dict.items())):
#fig = plot_noise(swg,tsg,hwg,chip,**kwargs)
indexes = np.unique(swg.index)
for index in indexes:
try:
nm = SweepNoiseMeasurement(fname,sweep_group_index=k,timestream_group_index=k,
resonator_index=index,**kwargs)
except IndexError:
print "failed to find index",index,"in",sname,tname
continue
if plotall or k == 0:
try:
if pdf is None:
chipfname = nm.chip_name.replace(' ','_').replace(',','')
pdfname = os.path.join(BASE_DATA_DIR,'plots/%s_%s.pdf') % (fbase,chipfname)
pdf = PdfPages(pdfname)
try:
os.chmod(pdfname,0666)
except OSError:
print "could not change permissions of",pdfname
fig = Figure(figsize=(16,8))
title = ('%s %s' % (sname,tname))
nm.plot(fig=fig,title=title)
canvas = FigureCanvasAgg(fig)
fig.set_canvas(canvas)
pdf.savefig(fig,bbox_inches='tight')
except Exception:
print "failed to plot",k,index,sname,tname,fname
# else:
# if pdf is not None:
# pdf.close()
# pdf = None
nm._fractional_fluctuation_timeseries = None
nms.append(nm)
print fname,nm.start_temp,"K"
if pdf is not None:
pdf.close()
pdf = None
rnc.close()
pklname = os.path.join(BASE_DATA_DIR,'noise_sweeps_' +fbase+'.pkl')
fh = open(pklname,'w')
cPickle.dump(nms,fh,-1)
fh.close()
try:
os.chmod(pklname,0666)
except OSError:
print "could not change permissions of", pklname
except KeyboardInterrupt:
raise
except Exception,e:
# raise
errors[fname] = e
def chromosome_plotter():
def onclick(event):
global Chr, plotted
i = 0
for y in ax_y:
if event.ydata > (y - 0.1) and event.ydata < (y + 0.3):
Chr = chromosomes[i]
print("The chromosome is :" + str(chromosomes[i]))
i += 1
global chromosomes, vcf
root = tk.Tk()
root.title("Variation Visualizer (CHROMOSOME VIEWER)")
root.state('zoomed')
df = allel.vcf_to_dataframe(vcf,
fields=['CHROM', 'POS', 'REF', 'ALT'],
alt_number=1)
chromosome_vcf = df.CHROM
fig = Figure(figsize=(10, 20))
ax = fig.subplots()
ax.set_ylim(0, 50)
ax.set_xlim(1, 200)
canvas = FigureCanvasTkAgg(fig, root)
fig.set_canvas(canvas=canvas)
ax_y = []
ax_labels = []
p = 0
m = 48
v = 47.5
for chr in chromosomes:
print(chr)
chromosome = '{}.{}'.format(chr, 'fa')
with open(chromosome) as fasta_file: # Will close handle cleanly
lengths = []
for record in SeqIO.parse(
fasta_file, "fasta"
): # (generator)...in this case it is not a multi fasta file
lengths.append(record.seq)
seq = str(record.seq)
print("Initial length :" + str(len(seq)))
length = int(len(seq) / 2000000)
print("LEngth is : " + str(length))
start = 0
p = 0
for i in range(start, length):
ax.broken_barh([(p, 1)], (m, 0.2), facecolors='#1a1a00')
p += 1
i = 0
index = []
counter = 0
for chrm in chromosome_vcf:
if chrm == chr:
counter += 1
index.append(i)
i += 1
ax.annotate(str(counter) + " variations", (p + 2, m), fontsize=6)
for j in index:
pos = df.POS[j]
pos = int(pos / 2000000)
ax.broken_barh([(pos, 1)], (v, 1), facecolors='#b30000')
ax_y.append(m + 0.1)
ax_labels.append(chr)
m -= 2
v -= 2
plotted = True
ax.set_yticks(ax_y)
ax.set_yticklabels(ax_labels, fontsize=12)
fig.canvas.mpl_connect('button_press_event', onclick)
canvas.draw()
canvas.get_tk_widget().pack(side=tk.BOTTOM, fill=tk.BOTH, expand=True)
root.mainloop()
def convergence_criterion(mcmc_set):
"""Returns the vector of Gelman-Rubin convergence criterion values and a
link to an HTML file containing plots of the traces of the walk for each
parameter fitted."""
# Prepare html for page showing plots of parameter traces
html_str = "<html><head><title>Parameter traces for %s</title></head>\n" \
% mcmc_set.name
html_str += "<body><p>Parameter traces for %s</p>\n" \
% mcmc_set.name
img_str_list = []
# Useful variables
num_estimate = mcmc_set.chains[0].num_estimate
fontP = FontProperties()
fontP.set_size('small')
legend_kwargs = {
'prop': fontP,
'ncol': 1,
'bbox_to_anchor': (1, 1),
'fancybox': True,
'shadow': True
}
# Make plot of posterior
fig = Figure()
ax = fig.gca()
for i, chain in enumerate(mcmc_set.chains):
color = cm.jet(i / float(num_estimate - 1))
label = 's%d' % chain.options.seed
if chain.pruned:
line = ax.plot(chain.thinned_steps,
chain.posteriors,
color=color,
label=label)
else:
line = ax.plot(chain.posteriors, color=color, label=label)
ax.set_title("Posterior traces")
ax.legend(loc='upper left', **legend_kwargs)
posterior_plot_filename = '%s_posterior_trace.png' % mcmc_set.name
canvas = FigureCanvasAgg(fig)
fig.set_canvas(canvas)
fig.savefig(posterior_plot_filename)
# Make plots of parameter traces
for i in range(num_estimate):
param_name = mcmc_set.chains[0].options.estimate_params[i].name
fig = Figure()
ax = fig.gca()
for j, chain in enumerate(mcmc_set.chains):
color = cm.jet(j / float(num_estimate - 1))
label = 's%d' % chain.options.seed
if chain.pruned:
line = ax.plot(chain.thinned_steps,
chain.positions[:, i],
color=color,
label=label)
else:
line = ax.plot(chain.positions[:, i], color=color, label=label)
ax.set_title("Parameter: %s" % param_name)
ax.legend(loc='upper left', **legend_kwargs)
plot_filename = '%s_trace_%s.png' % (mcmc_set.name, param_name)
canvas = FigureCanvasAgg(fig)
fig.set_canvas(canvas)
fig.savefig(plot_filename)
img_str_list.append(plot_filename)
# Make the html file
html_str += '<a href="%s"><img src="%s" width=400 /></a>' % \
(posterior_plot_filename, posterior_plot_filename)
html_str += '\n'.join([
'<a href="%s"><img src="%s" width=400 /></a>' % (i, i)
for i in img_str_list
])
html_str += "</body></html>"
html_filename = '%s_convergence.html' % mcmc_set.name
with open(html_filename, 'w') as f:
f.write(html_str)
return FloatListResult(convergence.convergence_criterion(mcmc_set),
html_filename)
class realTimeVisualisation(gtk.Window):
def __init__(self,networkVariables):
'''
'''
super(realTimeVisualisation,self).__init__()
self.set_size_request(640,690)
self.set_position(gtk.WIN_POS_CENTER)
self.connect("destroy", gtk.main_quit)
self.fig = Figure(figsize=(5,4), dpi=100)
self.canvas = FigureCanvas(self.fig) # a gtk.DrawingArea
self.canvas.set_size_request(640,690)
vbox = gtk.VBox(False,1)
alignIm = gtk.Alignment(0, 1 , 1, 0)
alignIm.add(self.canvas)
vbox.pack_start(alignIm)
self.add(vbox)
self.initNetworkVariables(networkVariables)
self.createGraph()
updateTime = 1 #len(self.quantitiesToPlot) ## if this time is to fast, it will show nothing
gobject.timeout_add(updateTime,self.updateGraph)
self.show_all()
def initNetworkVariables(self,networkVariables):
'''
'''
self.dt = 0.01
self.filename = '../.realtime.viz'
self.quantitiesToPlot = ['Pressure','Flow']
self.initialValues = [0,0,0,0,0]
try:
self.dt = networkVariables['dt']
self.filename = networkVariables['filename']
self.quantitiesToPlot = networkVariables['quantitiesToPlot']
self.initialValues = networkVariables['initialValues']
except: pass
def updateGraph(self):
'''
'''
try:
with open(''.join([cur,'/',self.filename]),'r') as dataFile:
for dataLine in dataFile:
dataString = dataLine
break
os.remove(''.join([cur,'/',self.filename]))
except: pass
dataDict = {}
try:
dataDict = eval(dataString)
except:
try:
if dataString == 'STOP':
return False
except: pass
pass
try:
for quantity in self.quantitiesToPlot:
newValue = dataDict[quantity]
## update y values
yvals = self.lines[quantity].get_ydata()
yvalsn = np.append(yvals,newValue)
self.lines[quantity].set_ydata(yvalsn)
## update x values
timeOld = self.lines[quantity].get_xdata()
time = np.append(timeOld,[timeOld[-1]+self.dt])
self.lines[quantity].set_xdata(time)
## adjust limits
self.adjustAxis(self.axis[quantity],time,yvalsn)
# update view()
self.canvas.figure = self.fig
self.fig.set_canvas(self.canvas)
self.canvas.queue_resize()
except: pass
return True
def adjustAxis(self,axis,xVals,yVals):
'''
'''
mmF = 0.1
#get values for y
yMaxVals = np.max(yVals)
yMinVals = np.min(yVals)
yMinAx,yMaxAx = axis.get_ylim()
#check and correct if necessary
if yMaxVals > yMaxAx-mmF*abs(yMaxAx):
yMaxAx = yMaxVals+mmF*abs(yMaxVals)
if yMinVals < yMinAx+mmF*abs(yMinAx):
yMinAx = yMinVals-mmF*abs(yMinVals)
#apply y values
axis.set_ylim([yMinAx,yMaxAx])
#get values for x
xMinVals = np.min(xVals)
xMaxVals = np.max(xVals)
xMinAx,xMaxAx = axis.get_xlim()
#check and correct if necessary
if xMaxVals > xMaxAx-mmF*abs(xMaxAx):
xMaxAx = xMaxVals+mmF*abs(xMaxVals)
if xMinVals < xMinAx+mmF*abs(xMinAx):
xMinAx = xMinVals-mmF*abs(xMinVals)
#apply y values
axis.set_xlim([xMinAx,xMaxAx])
def createGraph(self):
'''
'''
numberOfQuantities = len(self.quantitiesToPlot)
self.fig.subplots_adjust(hspace = 0.4)
self.fig.subplots_adjust(right = 0.85)
self.fig.subplots_adjust(top = 0.98)
self.fig.subplots_adjust(bottom = 0.2)
self.fig.subplots_adjust(hspace = 0.5)
self.fig.set_figwidth(8.27)
self.fig.set_figheight((11.69/3)*numberOfQuantities)
self.lines = {}
self.axis = {}
i = 0
colors = ['b','r','m','g','k']
for quantity in self.quantitiesToPlot:
self.axis[quantity] = self.fig.add_subplot(numberOfQuantities,1,i+1, ylabel=quantity, xlabel='Time', ylim = [self.initialValues[i],self.initialValues[i]-0.001], xlim = [0,0.0001])
self.lines[quantity] = self.axis[quantity].plot(0,self.initialValues[i],color=colors[i] ,linestyle = '-',label=quantity, linewidth = 1.)[0]
i = i+1
# update view()
self.canvas.figure = self.fig
self.fig.set_canvas(self.canvas)
self.canvas.queue_resize()
def make_plot_3d(grid, grid_name, x, y, all_z, t, grid_t_idx, grid_x_idx, grid_z_idx, n_cols = 6,
outpath='', filename_prefix='LMA',do_save=True,
image_type='pdf', colormap='cubehelix' , grid_range=None):
n_frames = t.shape[0]
# n_cols = 6
n_rows = int(ceil( float(n_frames) / n_cols ))
if type(colormap) == type(''):
colormap = get_cmap(colormap)
grey_color = (0.5,)*3
frame_color = (0.2,)*3
density_maxes = []
total_counts = []
all_t = []
xedge = centers_to_edges(x)
x_range = xedge.max() - xedge.min()
yedge = centers_to_edges(y)
y_range = yedge.max() - yedge.min()
dx = (xedge[1]-xedge[0])
# count_scale_factor = dx # / 1000.0
# max_count_baseline = 450 * count_scale_factor #/ 10.0
min_count, max_count = 1, grid[:].max() #max_count_baseline*(t[1]-t[0])
if (max_count == 0) | (max_count == 1 ):
max_count = min_count+1
default_vmin = -0.2
if np.log10(max_count) <= default_vmin:
vmin_count = np.log10(max_count) + default_vmin
else:
vmin_count = default_vmin
# If the range of values for the colorbar is manually specified,
# overwrite what we did above
if grid_range is not None:
vmin_count = grid_range[0]
max_count = grid_range[1]
# w, h = figaspect(float(n_rows)/n_cols) # breaks for large numbers of frames - has a hard-coded max figure size
w, h, n_rows_perpage, n_pages = multiples_figaspect(n_rows, n_cols, x_range, y_range, fig_width=8.5, max_height=None)
fig = Figure(figsize=(w,h))
canvas = FigureCanvasAgg(fig)
fig.set_canvas(canvas)
p = small_multiples_plot(fig=fig, rows=n_rows, columns=n_cols)
p.label_edges(True)
pad = 0.0 # for time labels in each frame
for ax in p.multiples.flat:
ax.set_axis_bgcolor('white')
ax.spines['top'].set_edgecolor(frame_color)
ax.spines['bottom'].set_edgecolor(frame_color)
ax.spines['left'].set_edgecolor(frame_color)
ax.spines['right'].set_edgecolor(frame_color)
# ax.yaxis.set_major_formatter(kilo_formatter)
# ax.xaxis.set_major_formatter(kilo_formatter)
base_date = datetime.strptime(t.units, "seconds since %Y-%m-%d %H:%M:%S")
time_delta = timedelta(0,float(t[0]),0)
start_time = base_date + time_delta
for zi in range(len(all_z)):
indexer = [slice(None),]*len(grid.shape)
frame_start_times = []
altitude = all_z[zi]
for i in range(n_frames):
p.multiples.flat[i].clear() # reset (clear) the axes
frame_start = base_date + timedelta(0,float(t[i]),0)
frame_start_times.append(frame_start)
indexer[grid_t_idx] = i
indexer[grid_z_idx] = zi
density = grid[indexer]
density = np.ma.masked_where(density<=0.0, density) # mask grids 0 grids to reveal background color
# density,edges = np.histogramdd((x,y), bins=(xedge,yedge))
density_plot = p.multiples.flat[i].pcolormesh(xedge,yedge,
np.log10(density.transpose()),
vmin=vmin_count,
vmax=np.log10(max_count),
cmap=colormap)
label_string = frame_start.strftime('%H%M:%S')
x_lab = xedge[0]-pad+x_range*.015
y_lab = yedge[0]-pad+y_range*.015
text_label = p.multiples.flat[i].text(x_lab, y_lab, label_string, color=grey_color, size=6)
density_plot.set_rasterized(True)
density_maxes.append(density.max())
total_counts.append(density.sum())
all_t.append(frame_start)
print(label_string, x_lab, y_lab, grid_name, density.max(), density.sum())
color_scale = ColorbarBase(p.colorbar_ax, cmap=density_plot.cmap,
norm=density_plot.norm,
orientation='horizontal')
# color_scale.set_label('count per pixel')
color_scale.set_label('log10(count per pixel)')
view_x = (xedge.min(), xedge.max())
view_y = (yedge.min(), yedge.max())
print('making multiples')
p.multiples.flat[0].axis(view_x+view_y)
filename = '%s-%s_%s_%05.2fkm_%04.1fkm_%05.1fs.%s' % (filename_prefix, grid_name, start_time.strftime('%Y%m%d_%H%M%S'), dx, altitude, time_delta.seconds, image_type)
filename = os.path.join(outpath, filename)
if do_save:
fig.savefig(filename, dpi=150)
print('done ', zi)
return fig, p, frame_start_times, filename
print(' ... done with loop')
def plotALot(
img_array,
gene_index_dict, # list of genes to plot
reordered_genes=None,
savedir="",
title="images",
grid=(3, 6), # grid to plot for each figure
figsize=(16, 9),
dpi=300,
):
"""
plot a lot of images from a list of genes
"""
genes_per_plot = grid[0] * grid[1]
num_plots, remainder = divmod(len(gene_index_dict), (genes_per_plot))
# add an extra plot if
# number of genes is not perfectly divisible by number of plots
if remainder != 0:
num_plots += 1
if reordered_genes is None:
reordered_genes = [
None,
] * len(gene_index_dict)
for gene in gene_index_dict:
reordered_genes[gene_index_dict[gene]["index"]] = gene
# set up index for number of genes already plotted
# ------------------------------------------------
array_idx = 0
for plot_num in range(num_plots):
# set up figure canvas
# --------------------
fig = Figure(figsize=figsize, dpi=dpi)
canvas = FigCanvas(fig)
fig.set_canvas(canvas)
for gridpos in range(genes_per_plot):
# check if we have reached end of gene list
# -----------------------------------------
if array_idx == len(gene_index_dict):
break
# create temporary axes reference
# -------------------------------
ax = fig.add_subplot(grid[0], grid[1], gridpos + 1)
# plot the current gene (array_idx)
# ---------------------
gene = reordered_genes[array_idx]
ax.imshow(img_array[gene_index_dict[gene]["index"], ...],
cmap="hot")
ax.set_title(gene)
ax.grid(False)
# increment gene index
# --------------------
array_idx += 1
fig.suptitle(title + f" ({plot_num + 1} of {num_plots})")
fig.tight_layout(rect=(0, 0, 1, .94))
# save the plot
# time_now = datetime.datetime.now().strftime("%Y%m%d_%H%M")
savename = (f"{title.replace(' ','_')}"
f"_{plot_num + 1}of{num_plots}.png")
if not os.path.exists(savedir):
os.mkdir(savedir)
fig.savefig(os.path.join(savedir, savename), dpi=dpi)
canvas.close()
fig.clear()
def plot(self, parname, **kwargs):
'''\
keywords:
errorbar - shows errorbars in fit, true by default
legend - shows legend, true by default
other kywords are passed to Figure.add_axes()
Most important ones:
xscale, yscale - [‘linear’ | ‘log’ | ‘symlog’]
xlim, ylim - length 2 sequence of floats - to determine plot bounds'''
showerr = kwargs.pop('errorbar', True)
showleg = kwargs.pop('legend', True)
figure = Figure(figsize=[6, 4.5])
rect = (rcParams['figure.subplot.left'],
rcParams['figure.subplot.bottom'],
rcParams['figure.subplot.right'] -
rcParams['figure.subplot.left'],
rcParams['figure.subplot.top'] -
rcParams['figure.subplot.bottom'])
figure.suptitle(parname)
main_plot = figure.add_axes(rect, **kwargs)
main_plot.set_xlabel(pretty_str_units(pq.Quantity(self.xcol[0]).units))
main_plot.set_ylabel(parname)
x = []
redx = []
yelx = []
y = []
redy = []
yely = []
ex = None
ey = []
if parname == 'chisqr':
getval = lambda fit, pname: fit.chisqr
geterr = lambda fit, pname: 0
else:
getval = lambda fit, pname: fit.params[pname].value
geterr = lambda fit, pname: fit.params[parname].stderr
for i, fit in enumerate(self.results_list):
try:
xypair = (np.float64(self.xcol[i]), getval(fit, parname),
geterr(fit, parname))
except KeyError:
continue
if fit.success is False:
yelx.append(xypair[0])
yely.append(xypair[1])
elif not hasattr(fit, 'covar'):
redx.append(xypair[0])
redy.append(xypair[1])
elif fit.covar is None:
redx.append(xypair[0])
redy.append(xypair[1])
else:
x.append(xypair[0])
y.append(xypair[1])
ey.append(xypair[2])
if not showerr:
ey = None
main_plot.errorbar(
x,
y,
ey,
ex,
fmt='.',
color='blue',
ecolor='orange',
label="good fit",
)
main_plot.errorbar(
redx,
redy,
None,
None,
fmt='.',
color='red',
ecolor='orange',
label="overparametrized",
)
main_plot.errorbar(
yelx,
yely,
None,
None,
fmt='.',
color='yellow',
ecolor='orange',
label="not succeeded",
)
if showleg:
main_plot.legend(fancybox=True)
figure.set_canvas(FigureCanvasAgg(figure))
if test_ipython():
#print ('ipython')
import tempfile
tmpimg = tempfile.NamedTemporaryFile(suffix='.png', delete=True)
figure.savefig(tmpimg.name, format='png')
from IPython.display import Image, display
display(Image(filename=tmpimg.name))
else:
#print (' no ipython')
figure.savefig(parname + '.svg')
import numpy as np
from matplotlib.figure import Figure
from matplotlib.backends.backend_agg import new_figure_manager
def f(t):
return np.exp(-t) * np.cos(2 * np.pi * t)
def graph(fig):
t1 = np.arange(0.0, 5.0, 0.1)
t2 = np.arange(0.0, 5.0, 0.02)
ax = fig.add_subplot(1, 1, 1)
ax.plot(t1, f(t1), 'bo', t2, f(t2), 'k')
fig = Figure()
graph(fig)
manager = new_figure_manager(1, dpi=72)
manager.canvas.figure = fig
fig.set_canvas(manager.canvas)
fig.savefig("dist/no-pyplot.png")
class CanvasWidget(FigureCanvas):
"""Widget to draw plots on.
This class keep track of all the axes in a dictionary. The key for
an axis is its index number in sequence of creation.
next_id: The key for the next axis.
current_id: Key for current axis (anu plotting will happen on
this).
"""
updateSignal = pyqtSignal()
def __init__(self, model, graph, index, *args, **kwargs):
self.model = model
self.graph = graph
self.index = index
# QColor(243, 239, 238, 255)
self.figure = Figure(facecolor = '#F3EFEE')#figsize=(1,1))
FigureCanvas.__init__(self, self.figure, *args, **kwargs)
self.figure.set_canvas(self)
# self.set_xlabel('Time (s)')
# self.set_ylabel('Concentration (mM)')
if len(args) > 0 and isinstance(args[0], QtGui.QWidget):
self.reparent(args[0])
elif (kwargs is not None) and ('parent' in kwargs):
self.reparent(kwargs['parent'])
#self.setAcceptDrops(True)
# self.setMaximumSize(100, 100)
FigureCanvas.updateGeometry(self)
self.axes = {}
self.next_id = 0
self.current_id = -1
tabList = []
self.addTabletoPlot = ''
self.setAcceptDrops(True)
self.gridMode = False
def dragEnterEvent(self, event):
if event.mimeData().hasFormat('text/plain'):
event.acceptProposedAction()
def dragMoveEvent(self, event):
if event.mimeData().hasFormat('text/plain'):
event.acceptProposedAction()
def eventFilter(self, source, event):
if (event.type() == QtCore.QEvent.Drop):
pass
def dropEvent(self, event):
"""Insert an element of the specified class in drop location"""
if not event.mimeData().hasFormat('text/plain'):
return
# print " active window ", self.isActiveWindow()
# print "Mouse : ", self.mouse
# pos = self.mapFromGlobal(QCursor.pos())
# print "Mouse Position : ", pos
modelRoot, element = event.mimeData().data
if isinstance (element,moose.PoolBase):
tablePath = moose.utils.create_table_path(self.model, self.graph, element, "Conc")
table = moose.utils.create_table(tablePath, element, "Conc","Table2")
# moose.connect(table, 'requestOut', element, 'getConc')
self.updateSignal.emit()
elif isinstance(element, moose.CompartmentBase):
tablePath = moose.utils.create_table_path(self.model, self.graph, element, "Vm")
table = moose.utils.create_table(tablePath, element, "Vm","Table")
self.updateSignal.emit()
else:
QtGui.QMessageBox.question(self, 'Message',"This element's properties cannot be plotted.", QtGui.QMessageBox.Ok)
def addSubplot(self, rows, cols):
"""Add a subplot to figure and set it as current axes."""
assert(self.next_id <= rows * cols)
axes = self.figure.add_subplot(rows, cols, self.next_id+1)
axes.set_xlabel("Time (s)")
axes.set_ylabel("Concentration (mM)")
axes.set_xlim(left=0.0)
axes.set_ylim(bottom=0.0)
self.axes[self.next_id] = axes
axes.set_title("Graph " + str(self.index + 1))
self.current_id = self.next_id
self.next_id += 1
labelList = []
axes.legend(loc='upper center')
return axes
def plot(self, *args, **kwargs):
#self.callAxesFn('legend',loc='lower center',bbox_to_anchor=(0.5, -0.03),fancybox=True, shadow=True, ncol=3)
return self.callAxesFn('plot', *args, **kwargs)
def callAxesFn(self, fname, *args, **kwargs):
"""Call any arbitrary function of current axes object."""
if self.current_id < 0:
self.addSubplot(1,1)
fn = eval('self.axes[self.current_id].%s' % (fname))
return fn(*args, **kwargs)
def resize_event(self, event):
print("Resize event called ", event)
def toggleGrid(self):
self.gridMode = not self.gridMode
for key in self.axes:
self.axes[key].grid(self.gridMode)
self.draw()
def setXLimit(self, minX, maxX):
for key in self.axes:
self.axes[key].set_xlim([minX, maxX])
self.draw()
class CanvasWidget(FigureCanvas):
"""Widget to draw plots on.
This class keep track of all the axes in a dictionary. The key for
an axis is its index number in sequence of creation.
next_id: The key for the next axis.
current_id: Key for current axis (anu plotting will happen on
this).
"""
updateSignal = pyqtSignal()
def __init__(self, model, graph, index, *args, **kwargs):
self.model = model
self.graph = graph
self.index = index
# QColor(243, 239, 238, 255)
self.figure = Figure(facecolor='#F3EFEE') #figsize=(1,1))
FigureCanvas.__init__(self, self.figure, *args, **kwargs)
self.figure.set_canvas(self)
# self.set_xlabel('Time (s)')
# self.set_ylabel('Concentration (mM)')
if len(args) > 0 and isinstance(args[0], QtGui.QWidget):
self.reparent(args[0])
elif (kwargs is not None) and ('parent' in kwargs):
self.reparent(kwargs['parent'])
#self.setAcceptDrops(True)
# self.setMaximumSize(100, 100)
FigureCanvas.updateGeometry(self)
self.axes = {}
self.next_id = 0
self.current_id = -1
tabList = []
self.addTabletoPlot = ''
self.setAcceptDrops(True)
self.gridMode = False
def dragEnterEvent(self, event):
if event.mimeData().hasFormat('text/plain'):
event.acceptProposedAction()
def dragMoveEvent(self, event):
if event.mimeData().hasFormat('text/plain'):
event.acceptProposedAction()
def eventFilter(self, source, event):
if (event.type() == QtCore.QEvent.Drop):
pass
def dropEvent(self, event):
"""Insert an element of the specified class in drop location"""
if not event.mimeData().hasFormat('text/plain'):
return
# print " active window ", self.isActiveWindow()
# print "Mouse : ", self.mouse
# pos = self.mapFromGlobal(QCursor.pos())
# print "Mouse Position : ", pos
modelRoot, element = event.mimeData().data
if isinstance(element, moose.PoolBase):
tablePath = moose.utils.create_table_path(self.model, self.graph,
element, "Conc")
table = moose.utils.create_table(tablePath, element, "Conc",
"Table2")
# moose.connect(table, 'requestOut', element, 'getConc')
self.updateSignal.emit()
elif isinstance(element, moose.CompartmentBase):
tablePath = moose.utils.create_table_path(self.model, self.graph,
element, "Vm")
table = moose.utils.create_table(tablePath, element, "Vm", "Table")
self.updateSignal.emit()
else:
QtGui.QMessageBox.question(
self, 'Message',
"This element's properties cannot be plotted.",
QtGui.QMessageBox.Ok)
def addSubplot(self, rows, cols):
"""Add a subplot to figure and set it as current axes."""
assert (self.next_id <= rows * cols)
axes = self.figure.add_subplot(rows, cols, self.next_id + 1)
axes.set_xlabel("Time (s)")
axes.set_ylabel("Concentration (mM)")
axes.set_xlim(left=0.0)
axes.set_ylim(bottom=0.0)
self.axes[self.next_id] = axes
axes.set_title("Graph " + str(self.index + 1))
self.current_id = self.next_id
self.next_id += 1
labelList = []
axes.legend(loc='upper center')
return axes
def plot(self, *args, **kwargs):
#self.callAxesFn('legend',loc='lower center',bbox_to_anchor=(0.5, -0.03),fancybox=True, shadow=True, ncol=3)
return self.callAxesFn('plot', *args, **kwargs)
def callAxesFn(self, fname, *args, **kwargs):
"""Call any arbitrary function of current axes object."""
if self.current_id < 0:
self.addSubplot(1, 1)
fn = eval('self.axes[self.current_id].%s' % (fname))
return fn(*args, **kwargs)
def resize_event(self, event):
print("Resize event called ", event)
def toggleGrid(self):
self.gridMode = not self.gridMode
for key in self.axes:
self.axes[key].grid(self.gridMode)
self.draw()
def setXLimit(self, minX, maxX):
for key in self.axes:
self.axes[key].set_xlim([minX, maxX])
self.draw()
class ApplicationWindow(QMainWindow):
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self.column_names = ["Column A", "Column B", "Column C"]
# Central widget
self._main = QWidget()
self.setCentralWidget(self._main)
# Main menu bar
self.menu = self.menuBar()
self.menu_file = self.menu.addMenu("File")
exit = QAction("Exit", self, triggered=qApp.quit)
self.menu_file.addAction(exit)
self.menu_about = self.menu.addMenu("&About")
about = QAction("About Qt", self, shortcut=QKeySequence(QKeySequence.HelpContents),
triggered=qApp.aboutQt)
self.menu_about.addAction(about)
# Figure (Left)
self.fig = Figure(figsize=(5, 3))
self.canvas = FigureCanvas(self.fig)
# Sliders (Left)
self.slider_azim = QSlider(minimum=0, maximum=360, orientation=Qt.Horizontal)
self.slider_elev = QSlider(minimum=0, maximum=360, orientation=Qt.Horizontal)
self.slider_azim_layout = QHBoxLayout()
self.slider_azim_layout.addWidget(QLabel("{}".format(self.slider_azim.minimum())))
self.slider_azim_layout.addWidget(self.slider_azim)
self.slider_azim_layout.addWidget(QLabel("{}".format(self.slider_azim.maximum())))
self.slider_elev_layout = QHBoxLayout()
self.slider_elev_layout.addWidget(QLabel("{}".format(self.slider_elev.minimum())))
self.slider_elev_layout.addWidget(self.slider_elev)
self.slider_elev_layout.addWidget(QLabel("{}".format(self.slider_elev.maximum())))
# Table (Right)
self.table = QTableWidget()
header = self.table.horizontalHeader()
header.setSectionResizeMode(QHeaderView.Stretch)
# ComboBox (Right)
self.combo = QComboBox()
self.combo.addItems(["Wired", "Surface", "Triangular Surface", "Sphere"])
# Right layout
rlayout = QVBoxLayout()
rlayout.setContentsMargins(1, 1, 1, 1)
rlayout.addWidget(QLabel("Plot type:"))
rlayout.addWidget(self.combo)
rlayout.addWidget(self.table)
# Left layout
llayout = QVBoxLayout()
rlayout.setContentsMargins(1, 1, 1, 1)
llayout.addWidget(self.canvas, 88)
llayout.addWidget(QLabel("Azimuth:"), 1)
llayout.addLayout(self.slider_azim_layout, 5)
llayout.addWidget(QLabel("Elevation:"), 1)
llayout.addLayout(self.slider_elev_layout, 5)
# Main layout
layout = QHBoxLayout(self._main)
layout.addLayout(llayout, 70)
layout.addLayout(rlayout, 30)
# Signal and Slots connections
self.combo.currentTextChanged.connect(self.combo_option)
self.slider_azim.valueChanged.connect(self.rotate_azim)
self.slider_elev.valueChanged.connect(self.rotate_elev)
# Initial setup
self.plot_wire()
self._ax.view_init(30, 30)
self.slider_azim.setValue(30)
self.slider_elev.setValue(30)
self.fig.canvas.mpl_connect("button_release_event", self.on_click)
# Matplotlib slot method
def on_click(self, event):
azim, elev = self._ax.azim, self._ax.elev
self.slider_azim.setValue(azim + 180)
self.slider_elev.setValue(elev + 180)
# Utils methods
def set_table_data(self, X, Y, Z):
for i in range(len(X)):
self.table.setItem(i, 0, QTableWidgetItem("{:.2f}".format(X[i])))
self.table.setItem(i, 1, QTableWidgetItem("{:.2f}".format(Y[i])))
self.table.setItem(i, 2, QTableWidgetItem("{:.2f}".format(Z[i])))
def set_canvas_table_configuration(self, row_count, data):
self.fig.set_canvas(self.canvas)
self._ax = self.canvas.figure.add_subplot(projection="3d")
self._ax.set_xlabel(self.column_names[0])
self._ax.set_ylabel(self.column_names[1])
self._ax.set_zlabel(self.column_names[2])
self.table.setRowCount(row_count)
self.table.setColumnCount(3)
self.table.setHorizontalHeaderLabels(self.column_names)
self.set_table_data(data[0], data[1], data[2])
# Plot methods
def plot_wire(self):
# Data
self.X, self.Y, self.Z = axes3d.get_test_data(0.03)
self.set_canvas_table_configuration(len(self.X[0]), (self.X[0], self.Y[0], self.Z[0]))
self._ax.plot_wireframe(self.X, self.Y, self.Z, rstride=10, cstride=10, cmap="viridis")
self.canvas.draw()
def plot_surface(self):
# Data
self.X, self.Y = np.meshgrid(np.linspace(-6, 6, 30), np.linspace(-6, 6, 30))
self.Z = np.sin(np.sqrt(self.X ** 2 + self.Y ** 2))
self.set_canvas_table_configuration(len(self.X[0]), (self.X[0], self.Y[0], self.Z[0]))
self._ax.plot_surface(self.X, self.Y, self.Z,
rstride=1, cstride=1, cmap="viridis", edgecolor="none")
self.canvas.draw()
def plot_triangular_surface(self):
# Data
radii = np.linspace(0.125, 1.0, 8)
angles = np.linspace(0, 2 * np.pi, 36, endpoint=False)[..., np.newaxis]
self.X = np.append(0, (radii * np.cos(angles)).flatten())
self.Y = np.append(0, (radii * np.sin(angles)).flatten())
self.Z = np.sin(-self.X * self.Y)
self.set_canvas_table_configuration(len(self.X), (self.X, self.Y, self.Z))
self._ax.plot_trisurf(self.X, self.Y, self.Z, linewidth=0.2, antialiased=True)
self.canvas.draw()
def plot_sphere(self):
# Data
u = np.linspace(0, 2 * np.pi, 100)
v = np.linspace(0, np.pi, 100)
self.X = 10 * np.outer(np.cos(u), np.sin(v))
self.Y = 10 * np.outer(np.sin(u), np.sin(v))
self.Z = 9 * np.outer(np.ones(np.size(u)), np.cos(v))
self.set_canvas_table_configuration(len(self.X), (self.X[0], self.Y[0], self.Z[0]))
self._ax.plot_surface(self.X, self.Y, self.Z)
self.canvas.draw()
# Slots
@Slot()
def combo_option(self, text):
if text == "Wired":
self.plot_wire()
elif text == "Surface":
self.plot_surface()
elif text == "Triangular Surface":
self.plot_triangular_surface()
elif text == "Sphere":
self.plot_sphere()
@Slot()
def rotate_azim(self, value):
self._ax.view_init(self._ax.elev, value)
self.fig.set_canvas(self.canvas)
self.canvas.draw()
@Slot()
def rotate_elev(self, value):
self._ax.view_init(value, self._ax.azim)
self.fig.set_canvas(self.canvas)
self.canvas.draw()
def convergence_criterion(mcmc_set):
"""Returns the vector of Gelman-Rubin convergence criterion values and a
link to an HTML file containing plots of the traces of the walk for each
parameter fitted."""
# Prepare html for page showing plots of parameter traces
html_str = "<html><head><title>Parameter traces for %s</title></head>\n" \
% mcmc_set.name
html_str += "<body><p>Parameter traces for %s</p>\n" \
% mcmc_set.name
img_str_list = []
# Useful variables
num_estimate = mcmc_set.chains[0].num_estimate
fontP = FontProperties()
fontP.set_size('small')
legend_kwargs = {'prop':fontP, 'ncol':1, 'bbox_to_anchor':(1, 1),
'fancybox': True, 'shadow': True}
# Make plot of posterior
fig = Figure()
ax = fig.gca()
for i, chain in enumerate(mcmc_set.chains):
color = cm.jet(i/float(num_estimate - 1))
label = 's%d' % chain.options.seed
if chain.pruned:
line = ax.plot(chain.thinned_accept_steps, chain.posteriors, color=color,
label=label)
else:
line = ax.plot(chain.posteriors, color=color, label=label)
ax.set_title("Posterior traces")
ax.legend(loc='upper left', **legend_kwargs)
posterior_plot_filename = '%s_posterior_trace.png' % mcmc_set.name
canvas = FigureCanvasAgg(fig)
fig.set_canvas(canvas)
fig.savefig(posterior_plot_filename)
# Make plots of parameter traces
for i in range(num_estimate):
param_name = mcmc_set.chains[0].options.estimate_params[i].name
fig = Figure()
ax = fig.gca()
for j, chain in enumerate(mcmc_set.chains):
color = cm.jet(j/float(num_estimate - 1))
label = 's%d' % chain.options.seed
if chain.pruned:
line = ax.plot(chain.thinned_accept_steps, chain.positions[:,i],
color=color, label=label)
else:
line = ax.plot(chain.positions[:, i], color=color, label=label)
ax.set_title("Parameter: %s" % param_name)
ax.legend(loc='upper left', **legend_kwargs)
plot_filename = '%s_trace_%s.png' % (mcmc_set.name, param_name)
canvas = FigureCanvasAgg(fig)
fig.set_canvas(canvas)
fig.savefig(plot_filename)
img_str_list.append(plot_filename)
# Make the html file
html_str += '<a href="%s"><img src="%s" width=400 /></a>' % \
(posterior_plot_filename, posterior_plot_filename)
html_str += '\n'.join([
'<a href="%s"><img src="%s" width=400 /></a>' %
(i, i) for i in img_str_list])
html_str += "</body></html>"
html_filename = '%s_convergence.html' % mcmc_set.name
with open(html_filename, 'w') as f:
f.write(html_str)
return FloatListResult(convergence.convergence_criterion(mcmc_set),
html_filename)
def make_plot_3d(grid, grid_name, x, y, all_z, t, grid_t_idx, grid_x_idx, grid_z_idx, n_cols = 6,
outpath='', filename_prefix='LMA',do_save=True,
image_type='pdf', colormap='cubehelix' , grid_range=None):
n_frames = t.shape[0]
# n_cols = 6
n_rows = int(ceil( float(n_frames) / n_cols ))
if type(colormap) == type(''):
colormap = get_cmap(colormap)
grey_color = (0.5,)*3
frame_color = (0.2,)*3
density_maxes = []
total_counts = []
all_t = []
xedge = centers_to_edges(x)
x_range = xedge.max() - xedge.min()
yedge = centers_to_edges(y)
y_range = yedge.max() - yedge.min()
dx = (xedge[1]-xedge[0])
# count_scale_factor = dx # / 1000.0
# max_count_baseline = 450 * count_scale_factor #/ 10.0
min_count, max_count = 1, grid[:].max() #max_count_baseline*(t[1]-t[0])
if (max_count == 0) | (max_count == 1 ):
max_count = min_count+1
default_vmin = -0.2
if np.log10(max_count) <= default_vmin:
vmin_count = np.log10(max_count) + default_vmin
else:
vmin_count = default_vmin
# If the range of values for the colorbar is manually specified,
# overwrite what we did above
if grid_range is not None:
vmin_count = grid_range[0]
max_count = grid_range[1]
# w, h = figaspect(float(n_rows)/n_cols) # breaks for large numbers of frames - has a hard-coded max figure size
w, h, n_rows_perpage, n_pages = multiples_figaspect(n_rows, n_cols, x_range, y_range, fig_width=8.5, max_height=None)
fig = Figure(figsize=(w,h))
canvas = FigureCanvasAgg(fig)
fig.set_canvas(canvas)
p = small_multiples_plot(fig=fig, rows=n_rows, columns=n_cols)
p.label_edges(True)
pad = 0.0 # for time labels in each frame
for ax in p.multiples.flat:
if int(matplotlib.__version__[0]) <= 1:
ax.set_axis_bgcolor('white')
else:
ax.set_facecolor('white')
ax.spines['top'].set_edgecolor(frame_color)
ax.spines['bottom'].set_edgecolor(frame_color)
ax.spines['left'].set_edgecolor(frame_color)
ax.spines['right'].set_edgecolor(frame_color)
# ax.yaxis.set_major_formatter(kilo_formatter)
# ax.xaxis.set_major_formatter(kilo_formatter)
base_date = datetime.strptime(t.units, "seconds since %Y-%m-%d %H:%M:%S")
time_delta = timedelta(0,float(t[0]),0)
start_time = base_date + time_delta
for zi in range(len(all_z)):
indexer = [slice(None),]*len(grid.shape)
frame_start_times = []
altitude = all_z[zi]
for i in range(n_frames):
p.multiples.flat[i].clear() # reset (clear) the axes
frame_start = base_date + timedelta(0,float(t[i]),0)
frame_start_times.append(frame_start)
indexer[grid_t_idx] = i
indexer[grid_z_idx] = zi
density = grid[indexer]
density = np.ma.masked_where(density<=0.0, density) # mask grids 0 grids to reveal background color
# density,edges = np.histogramdd((x,y), bins=(xedge,yedge))
density_plot = p.multiples.flat[i].pcolormesh(xedge,yedge,
np.log10(density.transpose()),
vmin=vmin_count,
vmax=np.log10(max_count),
cmap=colormap)
label_string = frame_start.strftime('%H%M:%S')
x_lab = xedge[0]-pad+x_range*.015
y_lab = yedge[0]-pad+y_range*.015
text_label = p.multiples.flat[i].text(x_lab, y_lab, label_string, color=grey_color, size=6)
density_plot.set_rasterized(True)
density_maxes.append(density.max())
total_counts.append(density.sum())
all_t.append(frame_start)
print(label_string, x_lab, y_lab, grid_name, density.max(), density.sum())
color_scale = ColorbarBase(p.colorbar_ax, cmap=density_plot.cmap,
norm=density_plot.norm,
orientation='horizontal')
# color_scale.set_label('count per pixel')
color_scale.set_label('log10(count per pixel)')
view_x = (xedge.min(), xedge.max())
view_y = (yedge.min(), yedge.max())
print('making multiples')
p.multiples.flat[0].axis(view_x+view_y)
filename = '%s-%s_%s_%05.2fkm_%04.1fkm_%05.1fs.%s' % (filename_prefix, grid_name, start_time.strftime('%Y%m%d_%H%M%S'), dx, altitude, time_delta.seconds, image_type)
filename = os.path.join(outpath, filename)
if do_save:
fig.savefig(filename, dpi=150)
print('done ', zi)
return fig, p, frame_start_times, filename
print(' ... done with loop')
def make_plot(filename,
grid_name,
x_name='x',
y_name='y',
t_name='time',
n_cols=6,
outpath='',
filename_prefix='LMA',
do_save=True,
image_type='pdf',
colormap='gist_earth'):
""" colormap: a string giving the name of a matplotlib built-in colormap,
or a matplotlib.colors.Colormap instance
"""
f = nc.NetCDFFile(filename)
data = f.variables # dictionary of variable names to nc_var objects
dims = f.dimensions # dictionary of dimension names to sizes
x = data[x_name]
y = data[y_name]
t = data[t_name]
grid = data[grid_name]
assert len(x.shape) == 1
assert len(y.shape) == 1
assert len(t.shape) == 1
grid_dims = grid.dimensions # tuple of dimension names
name_to_idx = dict((k, i) for i, k in enumerate(grid_dims))
grid_t_idx = name_to_idx[t.dimensions[0]]
grid_x_idx = name_to_idx[x.dimensions[0]]
grid_y_idx = name_to_idx[y.dimensions[0]]
n_frames = t.shape[0]
# n_cols = 6
n_rows = int(ceil(float(n_frames) / n_cols))
if type(colormap) == type(''):
colormap = get_cmap(colormap)
grey_color = (0.5, ) * 3
frame_color = (0.2, ) * 3
density_maxes = []
total_counts = []
all_t = []
xedge = centers_to_edges(x)
x_range = xedge.max() - xedge.min()
yedge = centers_to_edges(y)
y_range = yedge.max() - yedge.min()
dx = (xedge[1] - xedge[0])
# w, h = figaspect(float(n_rows)/n_cols) # breaks for large numbers of frames - has a hard-coded max figure size
w, h, n_rows_perpage, n_pages = multiples_figaspect(n_rows,
n_cols,
x_range,
y_range,
fig_width=8.5,
max_height=None)
# count_scale_factor = dx # / 1000.0
# max_count_baseline = 450 * count_scale_factor #/ 10.0
min_count, max_count = 1, grid[:].max() #max_count_baseline*(t[1]-t[0])
if (max_count == 0) | (max_count == 1):
max_count = min_count + 1
f.close()
default_vmin = -0.2
if np.log10(max_count) <= default_vmin:
vmin_count = np.log10(max_count) + default_vmin
else:
vmin_count = default_vmin
fig = Figure(figsize=(w, h))
canvas = FigureCanvasAgg(fig)
fig.set_canvas(canvas)
p = small_multiples_plot(fig=fig, rows=n_rows, columns=n_cols)
p.label_edges(True)
pad = 0.0 # for time labels in each frame
for ax in p.multiples.flat:
ax.set_axis_bgcolor('black')
ax.spines['top'].set_edgecolor(frame_color)
ax.spines['bottom'].set_edgecolor(frame_color)
ax.spines['left'].set_edgecolor(frame_color)
ax.spines['right'].set_edgecolor(frame_color)
# ax.yaxis.set_major_formatter(kilo_formatter)
# ax.xaxis.set_major_formatter(kilo_formatter)
base_date = datetime.strptime(t.units, "seconds since %Y-%m-%d %H:%M:%S")
time_delta = timedelta(0, float(t[0]), 0)
start_time = base_date + time_delta
indexer = [
slice(None),
] * len(grid.shape)
frame_start_times = []
for i in range(n_frames):
frame_start = base_date + timedelta(0, float(t[i]), 0)
frame_start_times.append(frame_start)
indexer[grid_t_idx] = i
density = grid[indexer]
# density,edges = np.histogramdd((x,y), bins=(xedge,yedge))
density_plot = p.multiples.flat[i].pcolormesh(xedge,
yedge,
np.log10(
density.transpose()),
vmin=vmin_count,
vmax=np.log10(max_count),
cmap=colormap)
label_string = frame_start.strftime('%H%M:%S')
text_label = p.multiples.flat[i].text(xedge[0] - pad + x_range * .015,
yedge[0] - pad + y_range * .015,
label_string,
color=grey_color,
size=6)
density_plot.set_rasterized(True)
density_maxes.append(density.max())
total_counts.append(density.sum())
all_t.append(frame_start)
print label_string, x.shape, density.max(), density.sum()
color_scale = ColorbarBase(p.colorbar_ax,
cmap=density_plot.cmap,
norm=density_plot.norm,
orientation='horizontal')
# color_scale.set_label('count per pixel')
color_scale.set_label('log10(count per pixel)')
view_x = (xedge.min(), xedge.max())
view_y = (yedge.min(), yedge.max())
print 'making multiples',
p.multiples.flat[0].axis(view_x + view_y)
filename = '%s-%s_%s_%05.2fkm_%05.1fs.%s' % (
filename_prefix, grid_name, start_time.strftime('%Y%m%d_%H%M%S'), dx,
time_delta.seconds, image_type)
filename = os.path.join(outpath, filename)
if do_save:
fig.savefig(filename, dpi=150)
return fig, p, frame_start_times, filename
print ' ... done'
class CanvasWidget(FigureCanvas):
"""Widget to draw plots on.
This class keep track of all the axes in a dictionary. The key for
an axis is its index number in sequence of creation.
next_id: The key for the next axis.
current_id: Key for current axis (anu plotting will happen on
this).
"""
def __init__(self, *args, **kwargs):
self.figure = Figure()
FigureCanvas.__init__(self, self.figure, *args, **kwargs)
self.figure.set_canvas(self)
if len(args) > 0 and isinstance(args[0], QtGui.QWidget):
self.reparent(args[0])
elif (kwargs is not None) and ('parent' in kwargs):
self.reparent(kwargs['parent'])
#self.setAcceptDrops(True)
FigureCanvas.updateGeometry(self)
self.axes = {}
self.next_id = 0
self.current_id = -1
tabList = []
self.addTabletoPlot = ''
self.setAcceptDrops(True)
def dragEnterEvent(self, event):
if event.mimeData().hasFormat('text/plain'):
event.acceptProposedAction()
def dragMoveEvent(self, event):
if event.mimeData().hasFormat('text/plain'):
event.acceptProposedAction()
def eventFilter(self, source, event):
if (event.type() == QtCore.QEvent.Drop):
pass
def dropEvent(self, event):
"""Insert an element of the specified class in drop location"""
if not event.mimeData().hasFormat('text/plain'):
return
# print " active window ", self.isActiveWindow()
# print "Mouse : ", self.mouse
# pos = self.mapFromGlobal(QCursor.pos())
# print "Mouse Position : ", pos
self.modelRoot, self.element = event.mimeData().data
if isinstance (self.element,moose.PoolBase):
moose.utils.create(self.modelRoot,self.element,"Conc")
else:
QtGui.QMessageBox.question(self, 'Message',"This field is not plottable", QtGui.QMessageBox.Ok)
def addSubplot(self, rows, cols):
"""Add a subplot to figure and set it as current axes."""
assert(self.next_id <= rows * cols)
axes = self.figure.add_subplot(rows, cols, self.next_id+1)
self.axes[self.next_id] = axes
axes.set_title(chr(self.next_id + ord('A')))
self.current_id = self.next_id
self.next_id += 1
labelList = []
axes.legend(loc='upper center')
return axes
def plot(self, *args, **kwargs):
#self.callAxesFn('legend',loc='lower center',bbox_to_anchor=(0.5, -0.03),fancybox=True, shadow=True, ncol=3)
return self.callAxesFn('plot', *args, **kwargs)
def callAxesFn(self, fname, *args, **kwargs):
"""Call any arbitrary function of current axes object."""
if self.current_id < 0:
self.addSubplot(1,1)
fn = eval('self.axes[self.current_id].%s' % (fname))
return fn(*args, **kwargs)
class SquidGui(QtGui.QMainWindow):
defaults = {}
defaults.update(SquidAxon.defaults)
defaults.update(ClampCircuit.defaults)
defaults.update({
'runtime': 50.0,
'simdt': 0.01,
'plotdt': 0.1,
'vclamp.holdingV': 0.0,
'vclamp.holdingT': 10.0,
'vclamp.prepulseV': 0.0,
'vclamp.prepulseT': 0.0,
'vclamp.clampV': 50.0,
'vclamp.clampT': 20.0,
'iclamp.baseI': 0.0,
'iclamp.firstI': 0.1,
'iclamp.firstT': 40.0,
'iclamp.firstD': 5.0,
'iclamp.secondI': 0.0,
'iclamp.secondT': 0.0,
'iclamp.secondD': 0.0
})
def __init__(self, *args):
QtGui.QMainWindow.__init__(self, *args)
self.squid_setup = SquidSetup()
self._plotdt = SquidGui.defaults['plotdt']
self._plot_dict = defaultdict(list)
self.setWindowTitle('Squid Axon simulation')
self.setDockNestingEnabled(True)
self._createRunControl()
self.addDockWidget(QtCore.Qt.LeftDockWidgetArea, self._runControlDock)
self._runControlDock.setFeatures(
QtGui.QDockWidget.AllDockWidgetFeatures)
self._createChannelControl()
self._channelCtrlBox.setWindowTitle('Channel properties')
self._channelControlDock.setFeatures(
QtGui.QDockWidget.AllDockWidgetFeatures)
self.addDockWidget(QtCore.Qt.LeftDockWidgetArea,
self._channelControlDock)
self._createElectronicsControl()
self._electronicsDock.setFeatures(
QtGui.QDockWidget.AllDockWidgetFeatures)
self._electronicsDock.setWindowTitle('Electronics')
self.addDockWidget(QtCore.Qt.LeftDockWidgetArea, self._electronicsDock)
self._createPlotWidget()
self.setCentralWidget(self._plotWidget)
self._createStatePlotWidget()
self._createHelpMessage()
self._helpWindow.setVisible(False)
self._statePlotWidget.setWindowFlags(QtCore.Qt.Window)
self._statePlotWidget.setWindowTitle('State plot')
self._initActions()
self._createRunToolBar()
self._createPlotToolBar()
def _createPlotWidget(self):
self._plotWidget = QtGui.QWidget()
self._plotFigure = Figure()
self._plotCanvas = FigureCanvas(self._plotFigure)
self._plotCanvas.setSizePolicy(QtGui.QSizePolicy.Expanding,
QtGui.QSizePolicy.Expanding)
self._plotCanvas.updateGeometry()
self._plotCanvas.setParent(self._plotWidget)
self._plotCanvas.mpl_connect('scroll_event', self._onScroll)
self._plotFigure.set_canvas(self._plotCanvas)
# Vm and command voltage go in the same subplot
self._vm_axes = self._plotFigure.add_subplot(
2, 2, 1, title='Membrane potential')
self._vm_axes.set_ylim(-20.0, 120.0)
# Channel conductances go to the same subplot
self._g_axes = self._plotFigure.add_subplot(
2, 2, 2, title='Channel conductance')
self._g_axes.set_ylim(0.0, 0.5)
# Injection current for Vclamp/Iclamp go to the same subplot
self._im_axes = self._plotFigure.add_subplot(2,
2,
3,
title='Injection current')
self._im_axes.set_ylim(-0.5, 0.5)
# Channel currents go to the same subplot
self._i_axes = self._plotFigure.add_subplot(2,
2,
4,
title='Channel current')
self._i_axes.set_ylim(-10, 10)
for axis in self._plotFigure.axes:
axis.set_autoscale_on(False)
layout = QtGui.QVBoxLayout()
layout.addWidget(self._plotCanvas)
self._plotNavigator = NavigationToolbar(self._plotCanvas,
self._plotWidget)
layout.addWidget(self._plotNavigator)
self._plotWidget.setLayout(layout)
def _createStatePlotWidget(self):
self._statePlotWidget = QtGui.QWidget()
self._statePlotFigure = Figure()
self._statePlotCanvas = FigureCanvas(self._statePlotFigure)
self._statePlotCanvas.setSizePolicy(QtGui.QSizePolicy.Expanding,
QtGui.QSizePolicy.Expanding)
self._statePlotCanvas.updateGeometry()
self._statePlotCanvas.setParent(self._statePlotWidget)
self._statePlotFigure.set_canvas(self._statePlotCanvas)
self._statePlotFigure.subplots_adjust(hspace=0.5)
self._statePlotAxes = self._statePlotFigure.add_subplot(
2, 1, 1, title='State plot')
self._state_plot, = self._statePlotAxes.plot([], [], label='state')
self._activationParamAxes = self._statePlotFigure.add_subplot(
2, 1, 2, title='H-H activation parameters vs time')
self._activationParamAxes.set_xlabel('Time (ms)')
#for axis in self._plotFigure.axes:
# axis.autoscale(False)
self._stateplot_xvar_label = QtGui.QLabel('Variable on X-axis')
self._stateplot_xvar_combo = QtGui.QComboBox()
self._stateplot_xvar_combo.addItems(['V', 'm', 'n', 'h'])
self._stateplot_xvar_combo.setCurrentIndex(0)
self._stateplot_xvar_combo.setEditable(False)
self.connect(self._stateplot_xvar_combo,
QtCore.SIGNAL('currentIndexChanged(const QString&)'),
self._statePlotXSlot)
self._stateplot_yvar_label = QtGui.QLabel('Variable on Y-axis')
self._stateplot_yvar_combo = QtGui.QComboBox()
self._stateplot_yvar_combo.addItems(['V', 'm', 'n', 'h'])
self._stateplot_yvar_combo.setCurrentIndex(2)
self._stateplot_yvar_combo.setEditable(False)
self.connect(self._stateplot_yvar_combo,
QtCore.SIGNAL('currentIndexChanged(const QString&)'),
self._statePlotYSlot)
self._statePlotNavigator = NavigationToolbar(self._statePlotCanvas,
self._statePlotWidget)
frame = QtGui.QFrame()
frame.setFrameStyle(QtGui.QFrame.StyledPanel + QtGui.QFrame.Raised)
layout = QtGui.QHBoxLayout()
layout.addWidget(self._stateplot_xvar_label)
layout.addWidget(self._stateplot_xvar_combo)
layout.addWidget(self._stateplot_yvar_label)
layout.addWidget(self._stateplot_yvar_combo)
frame.setLayout(layout)
self._closeStatePlotAction = QtGui.QAction('Close', self)
self.connect(self._closeStatePlotAction, QtCore.SIGNAL('triggered()'),
self._statePlotWidget.close)
self._closeStatePlotButton = QtGui.QToolButton()
self._closeStatePlotButton.setDefaultAction(self._closeStatePlotAction)
layout = QtGui.QVBoxLayout()
layout.addWidget(frame)
layout.addWidget(self._statePlotCanvas)
layout.addWidget(self._statePlotNavigator)
layout.addWidget(self._closeStatePlotButton)
self._statePlotWidget.setLayout(layout)
# Setting the close event so that when the help window is
# closed the ``State plot`` button becomes unchecked
self._statePlotWidget.closeEvent = lambda event: self._showStatePlotAction.setChecked(
False)
def _createRunControl(self):
self._runControlBox = QtGui.QGroupBox(self)
self._runControlBox.setSizePolicy(QtGui.QSizePolicy.Preferred,
QtGui.QSizePolicy.Preferred)
self._runTimeLabel = QtGui.QLabel("Run time (ms)", self._runControlBox)
self._simTimeStepLabel = QtGui.QLabel("Simulation time step (ms)",
self._runControlBox)
self._runTimeEdit = QtGui.QLineEdit(
'%g' % (SquidGui.defaults['runtime']), self._runControlBox)
set_default_line_edit_size(self._runTimeEdit)
self._simTimeStepEdit = QtGui.QLineEdit(
'%g' % (SquidGui.defaults['simdt']), self._runControlBox)
set_default_line_edit_size(self._simTimeStepEdit)
layout = QtGui.QGridLayout()
layout.addWidget(self._runTimeLabel, 0, 0)
layout.addWidget(self._runTimeEdit, 0, 1)
layout.addWidget(self._simTimeStepLabel, 1, 0)
layout.addWidget(self._simTimeStepEdit, 1, 1)
layout.setColumnStretch(2, 1.0)
layout.setRowStretch(2, 1.0)
self._runControlBox.setLayout(layout)
self._runControlDock = QtGui.QDockWidget('Simulation', self)
self._runControlDock.setWidget(self._runControlBox)
def _createChannelControl(self):
self._channelControlDock = QtGui.QDockWidget('Channels', self)
self._channelCtrlBox = QtGui.QGroupBox(self)
self._naConductanceToggle = QtGui.QCheckBox('Block Na+ channel',
self._channelCtrlBox)
self._naConductanceToggle.setToolTip('<html>%s</html>' %
(tooltip_NaChan))
self._kConductanceToggle = QtGui.QCheckBox('Block K+ channel',
self._channelCtrlBox)
self._kConductanceToggle.setToolTip('<html>%s</html>' %
(tooltip_KChan))
self._kOutLabel = QtGui.QLabel('[K+]out (mM)', self._channelCtrlBox)
self._kOutEdit = QtGui.QLineEdit(
'%g' % (self.squid_setup.squid_axon.K_out), self._channelCtrlBox)
self._kOutLabel.setToolTip('<html>%s</html>' % (tooltip_Nernst))
self._kOutEdit.setToolTip('<html>%s</html>' % (tooltip_Nernst))
set_default_line_edit_size(self._kOutEdit)
self._naOutLabel = QtGui.QLabel('[Na+]out (mM)', self._channelCtrlBox)
self._naOutEdit = QtGui.QLineEdit(
'%g' % (self.squid_setup.squid_axon.Na_out), self._channelCtrlBox)
self._naOutLabel.setToolTip('<html>%s</html>' % (tooltip_Nernst))
self._naOutEdit.setToolTip('<html>%s</html>' % (tooltip_Nernst))
set_default_line_edit_size(self._naOutEdit)
self._kInLabel = QtGui.QLabel('[K+]in (mM)', self._channelCtrlBox)
self._kInEdit = QtGui.QLabel('%g' % (self.squid_setup.squid_axon.K_in),
self._channelCtrlBox)
self._kInEdit.setToolTip(tooltip_Nernst)
self._naInLabel = QtGui.QLabel('[Na+]in (mM)', self._channelCtrlBox)
self._naInEdit = QtGui.QLabel(
'%g' % (self.squid_setup.squid_axon.Na_in), self._channelCtrlBox)
self._naInEdit.setToolTip('<html>%s</html>' % (tooltip_Nernst))
self._temperatureLabel = QtGui.QLabel('Temperature (C)',
self._channelCtrlBox)
self._temperatureEdit = QtGui.QLineEdit(
'%g' % (self.defaults['temperature'] - CELSIUS_TO_KELVIN),
self._channelCtrlBox)
self._temperatureEdit.setToolTip('<html>%s</html>' % (tooltip_Nernst))
set_default_line_edit_size(self._temperatureEdit)
for child in self._channelCtrlBox.children():
if isinstance(child, QtGui.QLineEdit):
set_default_line_edit_size(child)
layout = QtGui.QGridLayout(self._channelCtrlBox)
layout.addWidget(self._naConductanceToggle, 0, 0)
layout.addWidget(self._kConductanceToggle, 1, 0)
layout.addWidget(self._naOutLabel, 2, 0)
layout.addWidget(self._naOutEdit, 2, 1)
layout.addWidget(self._naInLabel, 3, 0)
layout.addWidget(self._naInEdit, 3, 1)
layout.addWidget(self._kOutLabel, 4, 0)
layout.addWidget(self._kOutEdit, 4, 1)
layout.addWidget(self._kInLabel, 5, 0)
layout.addWidget(self._kInEdit, 5, 1)
layout.addWidget(self._temperatureLabel, 6, 0)
layout.addWidget(self._temperatureEdit, 6, 1)
layout.setRowStretch(7, 1.0)
self._channelCtrlBox.setLayout(layout)
self._channelControlDock.setWidget(self._channelCtrlBox)
return self._channelCtrlBox
def __get_stateplot_data(self, name):
data = []
if name == 'V':
data = self.squid_setup.vm_table.vector
elif name == 'm':
data = self.squid_setup.m_table.vector
elif name == 'h':
data = self.squid_setup.h_table.vector
elif name == 'n':
data = self.squid_setup.n_table.vector
else:
raise ValueError('Unrecognized selection: %s' % (name))
return numpy.asarray(data)
def _statePlotYSlot(self, selectedItem):
ydata = self.__get_stateplot_data(str(selectedItem))
self._state_plot.set_ydata(ydata)
self._statePlotAxes.set_ylabel(selectedItem)
if str(selectedItem) == 'V':
self._statePlotAxes.set_ylim(-20, 120)
else:
self._statePlotAxes.set_ylim(0, 1)
self._statePlotCanvas.draw()
def _statePlotXSlot(self, selectedItem):
xdata = self.__get_stateplot_data(str(selectedItem))
self._state_plot.set_xdata(xdata)
self._statePlotAxes.set_xlabel(selectedItem)
if str(selectedItem) == 'V':
self._statePlotAxes.set_xlim(-20, 120)
else:
self._statePlotAxes.set_xlim(0, 1)
self._statePlotCanvas.draw()
def _createElectronicsControl(self):
"""Creates a tabbed widget of voltage clamp and current clamp controls"""
self._electronicsTab = QtGui.QTabWidget(self)
self._electronicsTab.addTab(self._getIClampCtrlBox(), 'Current clamp')
self._electronicsTab.addTab(self._getVClampCtrlBox(), 'Voltage clamp')
self._electronicsDock = QtGui.QDockWidget(self)
self._electronicsDock.setWidget(self._electronicsTab)
def _getVClampCtrlBox(self):
vClampPanel = QtGui.QGroupBox(self)
self._vClampCtrlBox = vClampPanel
self._holdingVLabel = QtGui.QLabel("Holding Voltage (mV)", vClampPanel)
self._holdingVEdit = QtGui.QLineEdit(
'%g' % (SquidGui.defaults['vclamp.holdingV']), vClampPanel)
self._holdingTimeLabel = QtGui.QLabel("Holding Time (ms)", vClampPanel)
self._holdingTimeEdit = QtGui.QLineEdit(
'%g' % (SquidGui.defaults['vclamp.holdingT']), vClampPanel)
self._prePulseVLabel = QtGui.QLabel("Pre-pulse Voltage (mV)",
vClampPanel)
self._prePulseVEdit = QtGui.QLineEdit(
'%g' % (SquidGui.defaults['vclamp.prepulseV']), vClampPanel)
self._prePulseTimeLabel = QtGui.QLabel("Pre-pulse Time (ms)",
vClampPanel)
self._prePulseTimeEdit = QtGui.QLineEdit(
'%g' % (SquidGui.defaults['vclamp.prepulseT']), vClampPanel)
self._clampVLabel = QtGui.QLabel("Clamp Voltage (mV)", vClampPanel)
self._clampVEdit = QtGui.QLineEdit(
'%g' % (SquidGui.defaults['vclamp.clampV']), vClampPanel)
self._clampTimeLabel = QtGui.QLabel("Clamp Time (ms)", vClampPanel)
self._clampTimeEdit = QtGui.QLineEdit(
'%g' % (SquidGui.defaults['vclamp.clampT']), vClampPanel)
for child in vClampPanel.children():
if isinstance(child, QtGui.QLineEdit):
set_default_line_edit_size(child)
layout = QtGui.QGridLayout(vClampPanel)
layout.addWidget(self._holdingVLabel, 0, 0)
layout.addWidget(self._holdingVEdit, 0, 1)
layout.addWidget(self._holdingTimeLabel, 1, 0)
layout.addWidget(self._holdingTimeEdit, 1, 1)
layout.addWidget(self._prePulseVLabel, 2, 0)
layout.addWidget(self._prePulseVEdit, 2, 1)
layout.addWidget(self._prePulseTimeLabel, 3, 0)
layout.addWidget(self._prePulseTimeEdit, 3, 1)
layout.addWidget(self._clampVLabel, 4, 0)
layout.addWidget(self._clampVEdit, 4, 1)
layout.addWidget(self._clampTimeLabel, 5, 0)
layout.addWidget(self._clampTimeEdit, 5, 1)
layout.setRowStretch(6, 1.0)
vClampPanel.setLayout(layout)
return self._vClampCtrlBox
def _getIClampCtrlBox(self):
iClampPanel = QtGui.QGroupBox(self)
self._iClampCtrlBox = iClampPanel
self._baseCurrentLabel = QtGui.QLabel("Base Current Level (uA)",
iClampPanel)
self._baseCurrentEdit = QtGui.QLineEdit(
'%g' % (SquidGui.defaults['iclamp.baseI']), iClampPanel)
self._firstPulseLabel = QtGui.QLabel("First Pulse Current (uA)",
iClampPanel)
self._firstPulseEdit = QtGui.QLineEdit(
'%g' % (SquidGui.defaults['iclamp.firstI']), iClampPanel)
self._firstDelayLabel = QtGui.QLabel("First Onset Delay (ms)",
iClampPanel)
self._firstDelayEdit = QtGui.QLineEdit(
'%g' % (SquidGui.defaults['iclamp.firstD']), iClampPanel)
self._firstPulseWidthLabel = QtGui.QLabel("First Pulse Width (ms)",
iClampPanel)
self._firstPulseWidthEdit = QtGui.QLineEdit(
'%g' % (SquidGui.defaults['iclamp.firstT']), iClampPanel)
self._secondPulseLabel = QtGui.QLabel("Second Pulse Current (uA)",
iClampPanel)
self._secondPulseEdit = QtGui.QLineEdit(
'%g' % (SquidGui.defaults['iclamp.secondI']), iClampPanel)
self._secondDelayLabel = QtGui.QLabel("Second Onset Delay (ms)",
iClampPanel)
self._secondDelayEdit = QtGui.QLineEdit(
'%g' % (SquidGui.defaults['iclamp.secondD']), iClampPanel)
self._secondPulseWidthLabel = QtGui.QLabel("Second Pulse Width (ms)",
iClampPanel)
self._secondPulseWidthEdit = QtGui.QLineEdit(
'%g' % (SquidGui.defaults['iclamp.secondT']), iClampPanel)
self._pulseMode = QtGui.QComboBox(iClampPanel)
self._pulseMode.addItem("Single Pulse")
self._pulseMode.addItem("Pulse Train")
for child in iClampPanel.children():
if isinstance(child, QtGui.QLineEdit):
set_default_line_edit_size(child)
layout = QtGui.QGridLayout(iClampPanel)
layout.addWidget(self._baseCurrentLabel, 0, 0)
layout.addWidget(self._baseCurrentEdit, 0, 1)
layout.addWidget(self._firstPulseLabel, 1, 0)
layout.addWidget(self._firstPulseEdit, 1, 1)
layout.addWidget(self._firstDelayLabel, 2, 0)
layout.addWidget(self._firstDelayEdit, 2, 1)
layout.addWidget(self._firstPulseWidthLabel, 3, 0)
layout.addWidget(self._firstPulseWidthEdit, 3, 1)
layout.addWidget(self._secondPulseLabel, 4, 0)
layout.addWidget(self._secondPulseEdit, 4, 1)
layout.addWidget(self._secondDelayLabel, 5, 0)
layout.addWidget(self._secondDelayEdit, 5, 1)
layout.addWidget(self._secondPulseWidthLabel, 6, 0)
layout.addWidget(self._secondPulseWidthEdit, 6, 1)
layout.addWidget(self._pulseMode, 7, 0, 1, 2)
layout.setRowStretch(8, 1.0)
# layout.setSizeConstraint(QtGui.QLayout.SetFixedSize)
iClampPanel.setLayout(layout)
return self._iClampCtrlBox
def _overlayPlots(self, overlay):
if not overlay:
for axis in (self._plotFigure.axes + self._statePlotFigure.axes):
title = axis.get_title()
axis.clear()
axis.set_title(title)
suffix = ''
else:
suffix = '_%d' % (len(self._plot_dict['vm']))
self._vm_axes.set_xlim(0.0, self._runtime)
self._g_axes.set_xlim(0.0, self._runtime)
self._im_axes.set_xlim(0.0, self._runtime)
self._i_axes.set_xlim(0.0, self._runtime)
self._vm_plot, = self._vm_axes.plot([], [], label='Vm%s' % (suffix))
self._plot_dict['vm'].append(self._vm_plot)
self._command_plot, = self._vm_axes.plot([], [],
label='command%s' % (suffix))
self._plot_dict['command'].append(self._command_plot)
# Channel conductances go to the same subplot
self._gna_plot, = self._g_axes.plot([], [], label='Na%s' % (suffix))
self._plot_dict['gna'].append(self._gna_plot)
self._gk_plot, = self._g_axes.plot([], [], label='K%s' % (suffix))
self._plot_dict['gk'].append(self._gk_plot)
# Injection current for Vclamp/Iclamp go to the same subplot
self._iclamp_plot, = self._im_axes.plot([], [],
label='Iclamp%s' % (suffix))
self._vclamp_plot, = self._im_axes.plot([], [],
label='Vclamp%s' % (suffix))
self._plot_dict['iclamp'].append(self._iclamp_plot)
self._plot_dict['vclamp'].append(self._vclamp_plot)
# Channel currents go to the same subplot
self._ina_plot, = self._i_axes.plot([], [], label='Na%s' % (suffix))
self._plot_dict['ina'].append(self._ina_plot)
self._ik_plot, = self._i_axes.plot([], [], label='K%s' % (suffix))
self._plot_dict['ik'].append(self._ik_plot)
# self._i_axes.legend()
# State plots
self._state_plot, = self._statePlotAxes.plot([], [],
label='state%s' %
(suffix))
self._plot_dict['state'].append(self._state_plot)
self._m_plot, = self._activationParamAxes.plot([], [],
label='m%s' % (suffix))
self._h_plot, = self._activationParamAxes.plot([], [],
label='h%s' % (suffix))
self._n_plot, = self._activationParamAxes.plot([], [],
label='n%s' % (suffix))
self._plot_dict['m'].append(self._m_plot)
self._plot_dict['h'].append(self._h_plot)
self._plot_dict['n'].append(self._n_plot)
if self._showLegendAction.isChecked():
for axis in (self._plotFigure.axes + self._statePlotFigure.axes):
axis.legend()
def _updateAllPlots(self):
self._updatePlots()
self._updateStatePlot()
def _updatePlots(self):
if len(self.squid_setup.vm_table.vector) <= 0:
return
vm = numpy.asarray(self.squid_setup.vm_table.vector)
cmd = numpy.asarray(self.squid_setup.cmd_table.vector)
ik = numpy.asarray(self.squid_setup.ik_table.vector)
ina = numpy.asarray(self.squid_setup.ina_table.vector)
iclamp = numpy.asarray(self.squid_setup.iclamp_table.vector)
vclamp = numpy.asarray(self.squid_setup.vclamp_table.vector)
gk = numpy.asarray(self.squid_setup.gk_table.vector)
gna = numpy.asarray(self.squid_setup.gna_table.vector)
time_series = numpy.linspace(0, self._plotdt * len(vm), len(vm))
self._vm_plot.set_data(time_series, vm)
time_series = numpy.linspace(0, self._plotdt * len(cmd), len(cmd))
self._command_plot.set_data(time_series, cmd)
time_series = numpy.linspace(0, self._plotdt * len(ik), len(ik))
self._ik_plot.set_data(time_series, ik)
time_series = numpy.linspace(0, self._plotdt * len(ina), len(ina))
self._ina_plot.set_data(time_series, ina)
time_series = numpy.linspace(0, self._plotdt * len(iclamp),
len(iclamp))
self._iclamp_plot.set_data(time_series, iclamp)
time_series = numpy.linspace(0, self._plotdt * len(vclamp),
len(vclamp))
self._vclamp_plot.set_data(time_series, vclamp)
time_series = numpy.linspace(0, self._plotdt * len(gk), len(gk))
self._gk_plot.set_data(time_series, gk)
time_series = numpy.linspace(0, self._plotdt * len(gna), len(gna))
self._gna_plot.set_data(time_series, gna)
if self._autoscaleAction.isChecked():
for axis in self._plotFigure.axes:
axis.relim()
axis.set_autoscale_on(True)
else:
self._vm_axes.set_ylim(-20.0, 120.0)
self._g_axes.set_ylim(0.0, 0.5)
self._im_axes.set_ylim(-0.5, 0.5)
self._i_axes.set_ylim(-10, 10)
self._vm_axes.set_xlim(0.0, time_series[-1])
self._g_axes.set_xlim(0.0, time_series[-1])
self._im_axes.set_xlim(0.0, time_series[-1])
self._i_axes.set_xlim(0.0, time_series[-1])
self._plotCanvas.draw()
def _updateStatePlot(self):
if len(self.squid_setup.vm_table.vector) <= 0:
return
sx = str(self._stateplot_xvar_combo.currentText())
sy = str(self._stateplot_yvar_combo.currentText())
xdata = self.__get_stateplot_data(sx)
ydata = self.__get_stateplot_data(sy)
minlen = min(len(xdata), len(ydata))
self._state_plot.set_data(xdata[:minlen], ydata[:minlen])
self._statePlotAxes.set_xlabel(sx)
self._statePlotAxes.set_ylabel(sy)
if sx == 'V':
self._statePlotAxes.set_xlim(-20, 120)
else:
self._statePlotAxes.set_xlim(0, 1)
if sy == 'V':
self._statePlotAxes.set_ylim(-20, 120)
else:
self._statePlotAxes.set_ylim(0, 1)
self._activationParamAxes.set_xlim(0, self._runtime)
m = self.__get_stateplot_data('m')
n = self.__get_stateplot_data('n')
h = self.__get_stateplot_data('h')
time_series = numpy.linspace(0, self._plotdt * len(m), len(m))
self._m_plot.set_data(time_series, m)
time_series = numpy.linspace(0, self._plotdt * len(h), len(h))
self._h_plot.set_data(time_series, h)
time_series = numpy.linspace(0, self._plotdt * len(n), len(n))
self._n_plot.set_data(time_series, n)
if self._autoscaleAction.isChecked():
for axis in self._statePlotFigure.axes:
axis.relim()
axis.set_autoscale_on(True)
self._statePlotCanvas.draw()
def _runSlot(self):
if moose.isRunning():
print 'Stopping simulation in progress ...'
moose.stop()
self._runtime = float(str(self._runTimeEdit.text()))
self._overlayPlots(self._overlayAction.isChecked())
self._simdt = float(str(self._simTimeStepEdit.text()))
clampMode = None
singlePulse = True
if self._electronicsTab.currentWidget() == self._vClampCtrlBox:
clampMode = 'vclamp'
baseLevel = float(str(self._holdingVEdit.text()))
firstDelay = float(str(self._holdingTimeEdit.text()))
firstWidth = float(str(self._prePulseTimeEdit.text()))
firstLevel = float(str(self._prePulseVEdit.text()))
secondDelay = firstWidth
secondWidth = float(str(self._clampTimeEdit.text()))
secondLevel = float(str(self._clampVEdit.text()))
self._im_axes.set_ylim(-10.0, 10.0)
else:
clampMode = 'iclamp'
baseLevel = float(str(self._baseCurrentEdit.text()))
firstDelay = float(str(self._firstDelayEdit.text()))
firstWidth = float(str(self._firstPulseWidthEdit.text()))
firstLevel = float(str(self._firstPulseEdit.text()))
secondDelay = float(str(self._secondDelayEdit.text()))
secondLevel = float(str(self._secondPulseEdit.text()))
secondWidth = float(str(self._secondPulseWidthEdit.text()))
singlePulse = (self._pulseMode.currentIndex() == 0)
self._im_axes.set_ylim(-0.4, 0.4)
self.squid_setup.clamp_ckt.configure_pulses(baseLevel=baseLevel,
firstDelay=firstDelay,
firstWidth=firstWidth,
firstLevel=firstLevel,
secondDelay=secondDelay,
secondWidth=secondWidth,
secondLevel=secondLevel,
singlePulse=singlePulse)
if self._kConductanceToggle.isChecked():
self.squid_setup.squid_axon.specific_gK = 0.0
else:
self.squid_setup.squid_axon.specific_gK = SquidAxon.defaults[
'specific_gK']
if self._naConductanceToggle.isChecked():
self.squid_setup.squid_axon.specific_gNa = 0.0
else:
self.squid_setup.squid_axon.specific_gNa = SquidAxon.defaults[
'specific_gNa']
self.squid_setup.squid_axon.celsius = float(
str(self._temperatureEdit.text()))
self.squid_setup.squid_axon.K_out = float(str(self._kOutEdit.text()))
self.squid_setup.squid_axon.Na_out = float(str(self._naOutEdit.text()))
self.squid_setup.squid_axon.updateEk()
self.squid_setup.schedule(self._simdt, self._plotdt, clampMode)
# The following line is for use with Qthread
self.squid_setup.run(self._runtime)
self._updateAllPlots()
def _toggleDocking(self, on):
self._channelControlDock.setFloating(on)
self._electronicsDock.setFloating(on)
self._runControlDock.setFloating(on)
def _restoreDocks(self):
self._channelControlDock.setVisible(True)
self._electronicsDock.setVisible(True)
self._runControlDock.setVisible(True)
def _initActions(self):
self._runAction = QtGui.QAction(self.tr('Run'), self)
self._runAction.setShortcut(self.tr('F5'))
self._runAction.setToolTip('Run simulation (F5)')
self.connect(self._runAction, QtCore.SIGNAL('triggered()'),
self._runSlot)
self._resetToDefaultsAction = QtGui.QAction(
self.tr('Restore defaults'), self)
self._resetToDefaultsAction.setToolTip(
'Reset all settings to their default values')
self.connect(self._resetToDefaultsAction, QtCore.SIGNAL('triggered()'),
self._useDefaults)
self._showLegendAction = QtGui.QAction(self.tr('Display legend'), self)
self._showLegendAction.setCheckable(True)
self.connect(self._showLegendAction, QtCore.SIGNAL('toggled(bool)'),
self._showLegend)
self._showStatePlotAction = QtGui.QAction(self.tr('State plot'), self)
self._showStatePlotAction.setCheckable(True)
self._showStatePlotAction.setChecked(False)
self.connect(self._showStatePlotAction, QtCore.SIGNAL('toggled(bool)'),
self._statePlotWidget.setVisible)
self._autoscaleAction = QtGui.QAction(self.tr('Auto-scale plots'),
self)
self._autoscaleAction.setCheckable(True)
self._autoscaleAction.setChecked(False)
self.connect(self._autoscaleAction, QtCore.SIGNAL('toggled(bool)'),
self._autoscale)
self._overlayAction = QtGui.QAction('Overlay plots', self)
self._overlayAction.setCheckable(True)
self._overlayAction.setChecked(False)
self._dockAction = QtGui.QAction('Undock all', self)
self._dockAction.setCheckable(True)
self._dockAction.setChecked(False)
self.connect(self._dockAction, QtCore.SIGNAL('toggled(bool)'),
self._toggleDocking)
self._restoreDocksAction = QtGui.QAction('Show all', self)
self.connect(self._restoreDocksAction, QtCore.SIGNAL('triggered()'),
self._restoreDocks)
self._quitAction = QtGui.QAction(self.tr('&Quit'), self)
self._quitAction.setShortcut(self.tr('Ctrl+Q'))
self.connect(self._quitAction, QtCore.SIGNAL('triggered()'),
QtGui.qApp.closeAllWindows)
def _createRunToolBar(self):
self._simToolBar = self.addToolBar(self.tr('Simulation control'))
self._simToolBar.addAction(self._quitAction)
self._simToolBar.addAction(self._runAction)
self._simToolBar.addAction(self._resetToDefaultsAction)
self._simToolBar.addAction(self._dockAction)
self._simToolBar.addAction(self._restoreDocksAction)
def _createPlotToolBar(self):
self._plotToolBar = self.addToolBar(self.tr('Plotting control'))
self._plotToolBar.addAction(self._showLegendAction)
self._plotToolBar.addAction(self._autoscaleAction)
self._plotToolBar.addAction(self._overlayAction)
self._plotToolBar.addAction(self._showStatePlotAction)
self._plotToolBar.addAction(self._helpAction)
self._plotToolBar.addAction(self._helpBiophysicsAction)
def _showLegend(self, on):
if on:
for axis in (self._plotFigure.axes + self._statePlotFigure.axes):
axis.legend().set_visible(True)
else:
for axis in (self._plotFigure.axes + self._statePlotFigure.axes):
axis.legend().set_visible(False)
self._plotCanvas.draw()
self._statePlotCanvas.draw()
def _autoscale(self, on):
if on:
for axis in (self._plotFigure.axes + self._statePlotFigure.axes):
axis.relim()
axis.set_autoscale_on(True)
else:
for axis in self._plotFigure.axes:
axis.set_autoscale_on(False)
self._vm_axes.set_ylim(-20.0, 120.0)
self._g_axes.set_ylim(0.0, 0.5)
self._im_axes.set_ylim(-0.5, 0.5)
self._i_axes.set_ylim(-10, 10)
self._plotCanvas.draw()
self._statePlotCanvas.draw()
def _useDefaults(self):
self._runTimeEdit.setText('%g' % (self.defaults['runtime']))
self._simTimeStepEdit.setText('%g' % (self.defaults['simdt']))
self._overlayAction.setChecked(False)
self._naConductanceToggle.setChecked(False)
self._kConductanceToggle.setChecked(False)
self._kOutEdit.setText('%g' % (SquidGui.defaults['K_out']))
self._naOutEdit.setText('%g' % (SquidGui.defaults['Na_out']))
self._temperatureEdit.setText(
'%g' % (SquidGui.defaults['temperature'] - CELSIUS_TO_KELVIN))
self._holdingVEdit.setText('%g' %
(SquidGui.defaults['vclamp.holdingV']))
self._holdingTimeEdit.setText('%g' %
(SquidGui.defaults['vclamp.holdingT']))
self._prePulseVEdit.setText('%g' %
(SquidGui.defaults['vclamp.prepulseV']))
self._prePulseTimeEdit.setText('%g' %
(SquidGui.defaults['vclamp.prepulseT']))
self._clampVEdit.setText('%g' % (SquidGui.defaults['vclamp.clampV']))
self._clampTimeEdit.setText('%g' %
(SquidGui.defaults['vclamp.clampT']))
self._baseCurrentEdit.setText('%g' %
(SquidGui.defaults['iclamp.baseI']))
self._firstPulseEdit.setText('%g' %
(SquidGui.defaults['iclamp.firstI']))
self._firstDelayEdit.setText('%g' %
(SquidGui.defaults['iclamp.firstD']))
self._firstPulseWidthEdit.setText('%g' %
(SquidGui.defaults['iclamp.firstT']))
self._secondPulseEdit.setText('%g' %
(SquidGui.defaults['iclamp.secondI']))
self._secondDelayEdit.setText('%g' %
(SquidGui.defaults['iclamp.secondD']))
self._secondPulseWidthEdit.setText(
'%g' % (SquidGui.defaults['iclamp.secondT']))
self._pulseMode.setCurrentIndex(0)
def _onScroll(self, event):
if event.inaxes is None:
return
axes = event.inaxes
zoom = 0.0
if event.button == 'up':
zoom = -1.0
elif event.button == 'down':
zoom = 1.0
if zoom != 0.0:
self._plotNavigator.push_current()
axes.get_xaxis().zoom(zoom)
axes.get_yaxis().zoom(zoom)
self._plotCanvas.draw()
def closeEvent(self, event):
QtGui.qApp.closeAllWindows()
def _showBioPhysicsHelp(self):
print '11111'
self._createHelpMessage()
self._helpMessageText.setText(
'<html><p>%s</p><p>%s</p><p>%s</p><p>%s</p><p>%s</p></html>' %
(tooltip_Nernst, tooltip_Erest, tooltip_KChan, tooltip_NaChan,
tooltip_Im))
self._helpWindow.setVisible(True)
def _showRunningHelp(self):
self._createHelpMessage()
self._helpMessageText.setSource(QtCore.QUrl(self._helpBaseURL))
self._helpWindow.setVisible(True)
def _createHelpMessage(self):
if hasattr(self, '_helpWindow'):
return
self._helpWindow = QtGui.QWidget()
self._helpWindow.setWindowFlags(QtCore.Qt.Window)
layout = QtGui.QVBoxLayout()
self._helpWindow.setLayout(layout)
self._helpMessageArea = QtGui.QScrollArea()
self._helpMessageText = QtGui.QTextBrowser()
self._helpMessageText.setOpenExternalLinks(True)
self._helpMessageArea.setWidget(self._helpMessageText)
layout.addWidget(self._helpMessageText)
self._squidGuiPath = os.path.dirname(os.path.abspath(__file__))
self._helpBaseURL = os.path.join(self._squidGuiPath, 'help.html')
self._helpMessageText.setSource(QtCore.QUrl(self._helpBaseURL))
self._helpMessageText.setSizePolicy(QtGui.QSizePolicy.Expanding,
QtGui.QSizePolicy.Expanding)
self._helpMessageArea.setSizePolicy(QtGui.QSizePolicy.Expanding,
QtGui.QSizePolicy.Expanding)
self._helpMessageText.setMinimumSize(800, 600)
self._closeHelpAction = QtGui.QAction('Close', self)
self.connect(self._closeHelpAction, QtCore.SIGNAL('triggered()'),
self._helpWindow.close)
# Setting the close event so that the ``Help`` button is
# unchecked when the help window is closed
self._helpWindow.closeEvent = lambda event: self._helpAction.setChecked(
False)
self._helpTOCAction = QtGui.QAction('Help running demo', self)
self.connect(self._helpTOCAction, QtCore.SIGNAL('triggered()'),
self._jumpToHelpTOC)
# This panel is for putting two buttons using horizontal
# layout
panel = QtGui.QFrame()
panel.setFrameStyle(QtGui.QFrame.StyledPanel + QtGui.QFrame.Raised)
layout.addWidget(panel)
layout = QtGui.QHBoxLayout()
panel.setLayout(layout)
self._helpAction = QtGui.QAction('Help running', self)
self.connect(self._helpAction, QtCore.SIGNAL('triggered()'),
self._showRunningHelp)
self._helpBiophysicsAction = QtGui.QAction('Help biophysics', self)
self.connect(self._helpBiophysicsAction, QtCore.SIGNAL('triggered()'),
self._showBioPhysicsHelp)
self._helpTOCButton = QtGui.QToolButton()
self._helpTOCButton.setDefaultAction(self._helpTOCAction)
self._helpBiophysicsButton = QtGui.QToolButton()
self._helpBiophysicsButton.setDefaultAction(self._helpBiophysicsAction)
layout.addWidget(self._helpTOCButton)
layout.addWidget(self._helpBiophysicsButton)
self._closeHelpButton = QtGui.QToolButton()
self._closeHelpButton.setDefaultAction(self._closeHelpAction)
layout.addWidget(self._closeHelpButton)
def _jumpToHelpTOC(self):
self._helpMessageText.setSource(QtCore.QUrl(self._helpBaseURL))
def make_plot(filename, grid_name, x_name='x', y_name='y', t_name='time',
n_cols=6, outpath='', filename_prefix='LMA',
do_save=True, image_type='pdf', colormap='gist_earth'):
""" colormap: a string giving the name of a matplotlib built-in colormap,
or a matplotlib.colors.Colormap instance
"""
f = nc.NetCDFFile(filename)
data = f.variables # dictionary of variable names to nc_var objects
dims = f.dimensions # dictionary of dimension names to sizes
x = data[x_name]
y = data[y_name]
t = data[t_name]
grid = data[grid_name]
assert len(x.shape) == 1
assert len(y.shape) == 1
assert len(t.shape) == 1
grid_dims = grid.dimensions # tuple of dimension names
name_to_idx = dict((k, i) for i, k in enumerate(grid_dims))
grid_t_idx = name_to_idx[t.dimensions[0]]
grid_x_idx = name_to_idx[x.dimensions[0]]
grid_y_idx = name_to_idx[y.dimensions[0]]
n_frames = t.shape[0]
# n_cols = 6
n_rows = int(ceil( float(n_frames) / n_cols ))
if type(colormap) == type(''):
colormap = get_cmap(colormap)
grey_color = (0.5,)*3
frame_color = (0.2,)*3
density_maxes = []
total_counts = []
all_t = []
xedge = centers_to_edges(x)
x_range = xedge.max() - xedge.min()
yedge = centers_to_edges(y)
y_range = yedge.max() - yedge.min()
dx = (xedge[1]-xedge[0])
# w, h = figaspect(float(n_rows)/n_cols) # breaks for large numbers of frames - has a hard-coded max figure size
w, h, n_rows_perpage, n_pages = multiples_figaspect(n_rows, n_cols, x_range, y_range, fig_width=8.5, max_height=None)
# count_scale_factor = dx # / 1000.0
# max_count_baseline = 450 * count_scale_factor #/ 10.0
min_count, max_count = 1, grid[:].max() #max_count_baseline*(t[1]-t[0])
if (max_count == 0) | (max_count == 1 ):
max_count = min_count+1
f.close()
default_vmin = -0.2
if np.log10(max_count) <= default_vmin:
vmin_count = np.log10(max_count) + default_vmin
else:
vmin_count = default_vmin
fig = Figure(figsize=(w,h))
canvas = FigureCanvasAgg(fig)
fig.set_canvas(canvas)
p = small_multiples_plot(fig=fig, rows=n_rows, columns=n_cols)
p.label_edges(True)
pad = 0.0 # for time labels in each frame
for ax in p.multiples.flat:
ax.set_axis_bgcolor('black')
ax.spines['top'].set_edgecolor(frame_color)
ax.spines['bottom'].set_edgecolor(frame_color)
ax.spines['left'].set_edgecolor(frame_color)
ax.spines['right'].set_edgecolor(frame_color)
# ax.yaxis.set_major_formatter(kilo_formatter)
# ax.xaxis.set_major_formatter(kilo_formatter)
base_date = datetime.strptime(t.units, "seconds since %Y-%m-%d %H:%M:%S")
time_delta = timedelta(0,float(t[0]),0)
start_time = base_date + time_delta
indexer = [slice(None),]*len(grid.shape)
frame_start_times = []
for i in range(n_frames):
frame_start = base_date + timedelta(0,float(t[i]),0)
frame_start_times.append(frame_start)
indexer[grid_t_idx] = i
density = grid[indexer]
# density,edges = np.histogramdd((x,y), bins=(xedge,yedge))
density_plot = p.multiples.flat[i].pcolormesh(xedge,yedge,
np.log10(density.transpose()),
vmin=vmin_count,
vmax=np.log10(max_count),
cmap=colormap)
label_string = frame_start.strftime('%H%M:%S')
text_label = p.multiples.flat[i].text(xedge[0]-pad+x_range*.015, yedge[0]-pad+y_range*.015, label_string, color=grey_color, size=6)
density_plot.set_rasterized(True)
density_maxes.append(density.max())
total_counts.append(density.sum())
all_t.append(frame_start)
print label_string, x.shape, density.max(), density.sum()
color_scale = ColorbarBase(p.colorbar_ax, cmap=density_plot.cmap,
norm=density_plot.norm,
orientation='horizontal')
# color_scale.set_label('count per pixel')
color_scale.set_label('log10(count per pixel)')
view_x = (xedge.min(), xedge.max())
view_y = (yedge.min(), yedge.max())
print 'making multiples',
p.multiples.flat[0].axis(view_x+view_y)
filename = '%s-%s_%s_%05.2fkm_%05.1fs.%s' % (filename_prefix, grid_name, start_time.strftime('%Y%m%d_%H%M%S'), dx, time_delta.seconds, image_type)
filename = os.path.join(outpath, filename)
if do_save:
fig.savefig(filename, dpi=150)
return fig, p, frame_start_times, filename
print ' ... done'
class myApp(wx.Frame):
def __init__(self, title="Haptic Waveform Designer v1.3"):
wx.Frame.__init__(self, None, title=title, size=(1000, 750))
self.freq = 1
self.amp = 1
self.statusBar = self.CreateStatusBar(style=wx.BORDER_NONE)
#self.t = []
#self.x = []
#self.wavRate = 44100
#self.samWidth = 3
#self.whichPlot = "builder"
self.theUI()
self.currentFile = ""
self.statusBar.SetStatusText("working on new file")
self.waveSegment = []
self.loadedInfo = 0
#pub.sendMessage("test", data = 0)
def theUI(self):
# define main panel
mainPanel = wx.Panel(self)
mainPanel.SetBackgroundColour("#ffffff")
# All the statics
font = wx.Font(36,
family=wx.FONTFAMILY_SWISS,
style=0,
weight=90,
underline=False,
faceName="",
encoding=wx.FONTENCODING_DEFAULT)
# menubar
menuBar = wx.MenuBar()
fileMenu = wx.Menu()
aboutMenu = wx.Menu()
openFileMenu = fileMenu.Append(wx.ID_ANY, "&Load Waveform")
saveFileMenu = fileMenu.Append(wx.ID_ANY, "&Save Waveform")
exportFileMenu = fileMenu.Append(wx.ID_ANY, "&Export as .wav")
aboutSubMenu = aboutMenu.Append(wx.ID_ANY, "&About")
menuBar.Append(fileMenu, "&File")
menuBar.Append(aboutMenu, "&About")
self.SetMenuBar(menuBar)
self.Bind(wx.EVT_MENU, self.onOpen, openFileMenu)
self.Bind(wx.EVT_MENU, self.onSaveAs, saveFileMenu)
self.Bind(wx.EVT_MENU, self.onExportAs, exportFileMenu)
self.Bind(wx.EVT_MENU, self.About, aboutSubMenu)
# Plot
self.figure = Figure()
self.axes = self.figure.add_subplot(111)
self.axes.set_ylabel("Voltage")
self.axes.set_xlabel("Time (ms)")
self.axes.set_title("Waveform")
self.canvas = FigureCanvas(mainPanel, -1, self.figure)
self.axes.grid(alpha=0.5)
self.whichPlot = "builder"
#register for waveform plot updates
pub.subscribe(self.update_plot, 'update_waveform_data')
pub.subscribe(self.getWaveSegment, "waveSegmentData")
wvfm_panel = waveform_panel.waveform_builder(mainPanel)
lra_pnl = lra_panel.lra_panel(mainPanel)
# declare sizers
mainSizer = wx.BoxSizer(wx.VERTICAL)
top_sizer = wx.BoxSizer(wx.HORIZONTAL)
top_sizer.Add(self.canvas, 1, wx.EXPAND)
top_sizer.Add(lra_pnl, 0, wx.TOP | wx.RIGHT, 60)
mainSizer.Add(top_sizer, 1, wx.EXPAND)
mainSizer.Add(wvfm_panel, 0, wx.ALL | wx.EXPAND, 10)
# Put sizer to the main panel
mainPanel.SetSizerAndFit(mainSizer)
self.Center()
def getWaveSegment(self, data):
self.waveSegment = data
def getLRACoeff(self, data):
self.LRACoeff = data
#update waveform plot with new data
def update_plot(self, data):
[time, values, low, high] = data
self.figure.set_canvas(self.canvas)
self.axes.clear()
self.axes.set_ylabel("Voltage")
self.axes.set_xlabel("Time (ms)")
self.axes.set_title("Waveform")
self.axes.grid(alpha=0.5)
self.axes.plot(time, values)
self.axes.axvspan(low, high, color='red', alpha=0.25)
self.canvas.draw()
self.dataToExport = values
# Must update this
def updateStatus(self):
self.statusBar.SetStatusText("file loaded! Using info from {}".format(
self.currentFile))
# Displays About Dialog
def About(self, evt):
text = """
A project for ME-396P @ UT Austin.
Built by Knights of Ni!:
Rahmat Ashari
Colin Campell
Peter Wang
"""
dlg = wx.MessageDialog(self, text, "Haptic Waveform Designer", wx.OK)
dlg.ShowModal()
dlg.Destroy()
#export current waveform as .wav file
def onExportAs(self, event):
with wx.FileDialog(self,
"Save .wav file",
wildcard="WAV files (*.wav)|*.wav",
style=wx.FD_SAVE
| wx.FD_OVERWRITE_PROMPT) as fileDialog:
# the user changed their mind
if fileDialog.ShowModal() == wx.ID_CANCEL:
return
# save the current contents in the file
pathname = fileDialog.GetPath()
try:
wavWrite(str(pathname), 44100,
self.dataToExport) # in 1 data every 1 milisecond
except IOError:
wx.LogError(
"Cannot export current data in file {}.".format(pathname))
#save current waveform segments as file (JSON)
def onSaveAs(self, event):
with wx.FileDialog(self,
"Save workflow",
wildcard="Waveform files (*.wvfm)|*.wvfm",
style=wx.FD_SAVE
| wx.FD_OVERWRITE_PROMPT) as fileDialog:
# the user changed their mind
if fileDialog.ShowModal() == wx.ID_CANCEL:
return
# save the current contents in the file
pathname = fileDialog.GetPath()
fileToSave = self.waveSegment
try:
with open(pathname, "w") as file:
json.dump(fileToSave, file, indent=4, sort_keys=False)
except IOError:
wx.LogError(
"Cannot save current data in file {}.".format(pathname))
#load waveform file (JSON)
def onOpen(self, event):
with wx.FileDialog(self,
"Open workflow",
wildcard="Waveform files (*.wvfm)|*.wvfm",
style=wx.FD_OPEN
| wx.FD_FILE_MUST_EXIST) as fileDialog:
if fileDialog.ShowModal() == wx.ID_CANCEL:
return
pathname = fileDialog.GetPath()
try:
self.currentFile = pathname
with open(pathname, 'r') as file:
self.loadedInfo = json.load(file)
pub.sendMessage("sendLoadData", data=self.loadedInfo)
self.updateStatus()
except IOError:
wx.LogError("something went wrong lol")
class PlotWidget(custom_result.ResultWidget):
__gsignals__ = {
'button-press-event': 'override',
'button-release-event': 'override',
'expose-event': 'override',
'size-allocate': 'override',
'unrealize': 'override'
}
def __init__(self, result):
custom_result.ResultWidget.__init__(self)
figsize=(DEFAULT_FIGURE_WIDTH, DEFAULT_FIGURE_HEIGHT)
self.figure = Figure(facecolor='white', figsize=figsize)
self.canvas = _PlotResultCanvas(self.figure)
self.axes = self.figure.add_subplot(111)
self.add_events(gtk.gdk.BUTTON_PRESS_MASK | gtk.gdk.BUTTON_RELEASE)
self.cached_contents = None
self.sidebar_width = -1
def do_expose_event(self, event):
cr = self.window.cairo_create()
if not self.cached_contents:
self.cached_contents = cr.get_target().create_similar(cairo.CONTENT_COLOR,
self.allocation.width, self.allocation.height)
renderer = RendererCairo(self.figure.dpi)
renderer.set_width_height(self.allocation.width, self.allocation.height)
renderer.set_ctx_from_surface(self.cached_contents)
self.figure.draw(renderer)
# event.region is not bound: http://bugzilla.gnome.org/show_bug.cgi?id=487158
# gdk_context = gtk.gdk.CairoContext(renderer.ctx)
# gdk_context.region(event.region)
# gdk_context.clip()
cr.set_source_surface(self.cached_contents, 0, 0)
cr.paint()
def do_size_allocate(self, allocation):
if allocation.width != self.allocation.width or allocation.height != self.allocation.height:
self.cached_contents = None
gtk.DrawingArea.do_size_allocate(self, allocation)
def do_unrealize(self):
gtk.DrawingArea.do_unrealize(self)
self.cached_contents = None
def do_button_press_event(self, event):
if event.button == 3:
custom_result.show_menu(self, event, save_callback=self.__save)
return True
else:
return True
def do_button_release_event(self, event):
return True
def do_realize(self):
gtk.DrawingArea.do_realize(self)
cursor = gtk.gdk.Cursor(gtk.gdk.LEFT_PTR)
self.window.set_cursor(cursor)
def do_size_request(self, requisition):
try:
# matplotlib < 0.98
requisition.width = self.figure.bbox.width()
requisition.height = self.figure.bbox.height()
except TypeError:
# matplotlib >= 0.98
requisition.width = self.figure.bbox.width
requisition.height = self.figure.bbox.height
def recompute_figure_size(self):
width = (self.sidebar_width / self.figure.dpi)
height = width / DEFAULT_ASPECT_RATIO
self.figure.set_figwidth(width)
self.figure.set_figheight(height)
self.queue_resize()
def sync_dpi(self, dpi):
self.figure.set_dpi(dpi)
if self.sidebar_width >= 0:
self.recompute_figure_size()
def set_sidebar_width(self, width):
if self.sidebar_width == width:
return
self.sidebar_width = width
if self.sidebar_width >= 0:
self.recompute_figure_size()
def sync_style(self, style):
self.cached_contents = None
matplotlib.rcParams['font.size'] = self.parent.style.font_desc.get_size() / pango.SCALE
def __save(self, filename):
# The save/restore here was added to matplotlib's after 0.90. We duplicate
# it for compatibility with older versions. (The code would need modification
# for 0.98 and newer, which is the reason for the particular version in the
# check)
version = [int(x) for x in matplotlib.__version__.split('.')]
need_save = version[:2] < [0, 98]
if need_save:
orig_dpi = self.figure.dpi.get()
orig_facecolor = self.figure.get_facecolor()
orig_edgecolor = self.figure.get_edgecolor()
try:
self.canvas.print_figure(filename)
finally:
if need_save:
self.figure.dpi.set(orig_dpi)
self.figure.set_facecolor(orig_facecolor)
self.figure.set_edgecolor(orig_edgecolor)
self.figure.set_canvas(self.canvas)
class ModelView(wx.Panel):
title = 'Profile'
default_size = (600,400)
def __init__( self, *args, **kw):
wx.Panel.__init__(self, *args, **kw)
# Fig
self.fig = Figure( figsize = (1,1),
dpi = 75,
facecolor = 'white',
edgecolor = 'white',
)
# Canvas
self.canvas = FigureCanvas(self, -1, self.fig)
self.fig.set_canvas(self.canvas)
# Axes
self.axes = self.fig.add_axes( Subplot(self.fig, 111))
self.axes.set_autoscale_on(False)
self.theta_axes = self.axes.twinx()
self.theta_axes.set_autoscale_on(False)
# Show toolbar or not?
self.toolbar = NavigationToolbar2WxAgg( self.canvas )
self.toolbar.Show(True)
# Create a figure manager to manage things
self.figmgr = FigureManager( self.canvas, 1, self )
# Panel layout
self.profile_selector_label = wx.StaticText(self, label="Sample")
self.profile_selector = wx.Choice(self)
self.profile_selector.Hide()
self.profile_selector_label.Hide()
self.Bind(wx.EVT_CHOICE, self.OnProfileSelect)
self.sizer = wx.BoxSizer( wx.VERTICAL )
self.sizer.Add( self.canvas,1, border=2, flag= wx.LEFT|wx.TOP|wx.GROW)
self.tbsizer = wx.BoxSizer(wx.HORIZONTAL)
self.tbsizer.Add(self.toolbar,0,wx.ALIGN_CENTER_VERTICAL)
self.tbsizer.AddSpacer(20)
self.tbsizer.Add(self.profile_selector_label,
0, wx.ALIGN_CENTER_VERTICAL)
self.tbsizer.AddSpacer(5)
self.tbsizer.Add(self.profile_selector,
0, wx.ALIGN_CENTER_VERTICAL)
self.sizer.Add(self.tbsizer)
self.SetSizer( self.sizer)
self.sizer.Fit(self)
# Status bar
frame = self.GetTopLevelParent()
self.statusbar = frame.GetStatusBar()
if self.statusbar is None:
self.statusbar = frame.CreateStatusBar()
status_update = lambda msg: self.statusbar.SetStatusText(msg)
# Set the profile interactor
self.profile = ProfileInteractor(self.axes,self.theta_axes,
status_update=status_update)
# Add context menu and keyboard support to canvas
self.canvas.Bind(wx.EVT_RIGHT_DOWN, self.OnContextMenu)
#self.canvas.Bind(wx.EVT_LEFT_DOWN, lambda evt: self.canvas.SetFocus())
self.model = None
self._need_set_model = self._need_redraw = False
self.Bind(wx.EVT_SHOW, self.OnShow)
def OnContextMenu(self,event):
"""
Forward the context menu invocation to profile, if profile exists.
"""
sx,sy = event.GetX(), event.GetY()
#transform = self.axes.transData
#data_x,data_y = pixel_to_data(transform, sx, self.fig.bbox.height-sy)
popup = wx.Menu()
item = popup.Append(wx.ID_ANY,'&Grid on/off', 'Toggle grid lines')
wx.EVT_MENU(self, item.GetId(),
lambda _: (self.axes.grid(),self.fig.canvas.draw_idle()))
item = popup.Append(wx.ID_ANY,'&Rescale', 'Show entire profile')
wx.EVT_MENU(self, item.GetId(),
lambda _: (self.profile.reset_limits(),self.profile.draw_idle()))
self.PopupMenu(popup, (sx,sy))
return False
def OnProfileSelect(self, event):
self.set_profile(*self.profiles[event.GetInt()])
# ==== Model view interface ===
def OnShow(self, event):
if not event.Show: return
#print "showing profile"
if self._need_set_model:
#print "-set model"
self.set_model(self.model)
elif self._need_redraw:
#print "-redraw"
self.profile.redraw()
event.Skip()
def get_state(self):
return self.model
def set_state(self, state):
self.set_model(state)
def set_model(self, model):
self.model = model
if not self.IsShown():
self._need_set_model = True
else:
self._need_set_model = self._need_redraw = False
self._set_model()
def update_model(self, model):
#print "profile update model"
if self.model != model: return
if not IS_MAC and not self.IsShown():
self._need_set_model = True
else:
self._need_set_model = self._need_redraw = False
self._set_model()
def update_parameters(self, model):
#print "profile update parameters"
if self.model != model: return
if not IS_MAC and not self.IsShown():
self._need_redraw = True
else:
self._need_redraw = False
self.profile.redraw()
# =============================================
def _set_model(self):
"""Initialize model by profile."""
self.profiles = []
def add_profiles(name, exp, idx):
if isinstance(exp,MixedExperiment):
for i,p in enumerate(exp.parts):
self.profiles.append( (name+chr(ord("a")+i), p, idx) )
else:
self.profiles.append( (name, exp, idx) )
if isinstance(self.model,MultiFitProblem):
for i,p in enumerate(self.model.models):
if hasattr(p.fitness,"reflectivity"):
name = p.fitness.name
if not name: name = "M%d"%(i+1)
add_profiles(name, p.fitness, i)
else:
add_profiles("", self.model.fitness, -1)
self.profile_selector.Clear()
if len(self.profiles) > 1:
self.profile_selector.AppendItems([k for k,_,_ in self.profiles])
self.profile_selector_label.Show()
self.profile_selector.Show()
self.profile_selector.SetSelection(0)
else:
self.profile_selector_label.Hide()
self.profile_selector.Hide()
self.set_profile(*self.profiles[0])
# update the figure
self.profile.redraw(reset_limits=True)
def set_profile(self, name, experiment, idx):
# Turn the model into a user interface
# It is the responsibility of the party that is indicating
# that a redraw is necessary to clear the precalculated
# parts of the view; otherwise the theory function calculator
# is going to be triggered twice. This happens inside profile
# before the profile is calculated. Note that the profile
# panel will receive its own signal, which will cause the
# profile interactor to draw itself again. We hope this isn't
# too much of a problem.
def signal_update():
"""Notify other views that the model has changed"""
signal.update_parameters(model=self.model)
def force_recalc():
self.model.model_update()
if isinstance(self.model,MultiFitProblem):
self.model.set_active_model(idx)
self.profile.set_experiment(experiment,
force_recalc=force_recalc,
signal_update=signal_update)
def onPrinterSetup(self,event=None):
self.canvas.Printer_Setup(event=event)
def onPrinterPreview(self,event=None):
self.canvas.Printer_Preview(event=event)
def onPrint(self,event=None):
self.canvas.Printer_Print(event=event)
def OnSaveFigureMenu(self, evt ):
"""
Save the current figure as an image file
"""
dlg = wx.FileDialog(self,
message="Save Figure As ...",
defaultDir=os.getcwd(),
defaultFile="",
wildcard="PNG files (*.png)|*.png|BMP files (*.bmp)|*.bmp|All files (*.*)|*.*",
style=wx.SAVE
)
_val = dlg.ShowModal()
if _val == wx.ID_CANCEL: return #Do nothing
if _val == wx.ID_OK:
outfile = dlg.GetPath()
dlg.Destroy()
# Save
self.fig.savefig( outfile )
def GetToolBar(self):
"""
backend_wx call this function. KEEP it
"""
return None
def OnPanelFrameClose(self, evt):
"""
On Close this Frame
"""
self.Destroy()
evt.Skip()
def OnCopyFigureMenu(self, evt ):
"""
Copy the current figure
"""
CopyImage(self.canvas)
def CanShowContextMenu(self):
return True
def quit_on_error(self):
numpy.seterr(all='raise')
ProfileInteractor._debug = True
BaseInteractor._debug = True
class ModelView(wx.Panel):
title = 'Profile'
default_size = (600, 400)
def __init__(self, *args, **kw):
wx.Panel.__init__(self, *args, **kw)
# Fig
self.fig = Figure(
figsize=(1, 1),
dpi=75,
facecolor='white',
edgecolor='white',
)
# Canvas
self.canvas = FigureCanvas(self, -1, self.fig)
self.fig.set_canvas(self.canvas)
# Axes
self.axes = self.fig.add_axes(Subplot(self.fig, 111))
self.axes.set_autoscale_on(False)
self.theta_axes = self.axes.twinx()
self.theta_axes.set_autoscale_on(False)
# Show toolbar or not?
self.toolbar = NavigationToolbar2WxAgg(self.canvas)
self.toolbar.Show(True)
# Create a figure manager to manage things
self.figmgr = FigureManager(self.canvas, 1, self)
# Panel layout
self.profile_selector_label = wx.StaticText(self, label="Sample")
self.profile_selector = wx.Choice(self)
self.profile_selector.Hide()
self.profile_selector_label.Hide()
self.Bind(wx.EVT_CHOICE, self.OnProfileSelect)
self.sizer = wx.BoxSizer(wx.VERTICAL)
self.sizer.Add(self.canvas,
1,
border=2,
flag=wx.LEFT | wx.TOP | wx.GROW)
self.tbsizer = wx.BoxSizer(wx.HORIZONTAL)
self.tbsizer.Add(self.toolbar, 0, wx.ALIGN_CENTER_VERTICAL)
self.tbsizer.AddSpacer(20)
self.tbsizer.Add(self.profile_selector_label, 0,
wx.ALIGN_CENTER_VERTICAL)
self.tbsizer.AddSpacer(5)
self.tbsizer.Add(self.profile_selector, 0, wx.ALIGN_CENTER_VERTICAL)
self.sizer.Add(self.tbsizer)
self.SetSizer(self.sizer)
self.sizer.Fit(self)
# Status bar
frame = self.GetTopLevelParent()
self.statusbar = frame.GetStatusBar()
if self.statusbar is None:
self.statusbar = frame.CreateStatusBar()
status_update = lambda msg: self.statusbar.SetStatusText(msg)
# Set the profile interactor
self.profile = ProfileInteractor(self.axes,
self.theta_axes,
status_update=status_update)
# Add context menu and keyboard support to canvas
self.canvas.Bind(wx.EVT_RIGHT_DOWN, self.OnContextMenu)
#self.canvas.Bind(wx.EVT_LEFT_DOWN, lambda evt: self.canvas.SetFocus())
self.model = None
self._need_interactors = self._need_redraw = False
self.Bind(wx.EVT_SHOW, self.OnShow)
def OnContextMenu(self, event):
"""
Forward the context menu invocation to profile, if profile exists.
"""
sx, sy = event.GetX(), event.GetY()
#transform = self.axes.transData
#data_x,data_y = pixel_to_data(transform, sx, self.fig.bbox.height-sy)
popup = wx.Menu()
item = popup.Append(wx.ID_ANY, '&Grid on/off', 'Toggle grid lines')
wx.EVT_MENU(self, item.GetId(), lambda _:
(self.axes.grid(), self.fig.canvas.draw_idle()))
item = popup.Append(wx.ID_ANY, '&Rescale', 'Show entire profile')
wx.EVT_MENU(
self, item.GetId(), lambda _:
(self.profile.reset_limits(), self.profile.draw_idle()))
self.PopupMenu(popup, (sx, sy))
return False
def OnProfileSelect(self, event):
self._set_profile(*self.profiles[event.GetInt()])
# ==== Model view interface ===
def OnShow(self, event):
if not event.Show:
return
#print "showing profile"
if self._need_redraw:
self.redraw(reset_interactors=False, reset_limits=True)
#event.Skip()
def get_state(self):
return self.model
def set_state(self, state):
self.set_model(state)
def set_model(self, model):
# print ">>>>>>> refl1d profile set model"
self.model = model
self.redraw(reset_interactors=True, reset_limits=True)
def update_model(self, model):
# print ">>>>>>> refl1d profile update model"
if self.model == model:
self.redraw(reset_interactors=False, reset_limits=True)
def update_parameters(self, model):
# print ">>>>>>> refl1d profile update parameters"
if self.model == model:
self.redraw(reset_interactors=False, reset_limits=False)
def redraw(self, reset_interactors=False, reset_limits=False):
if reset_interactors:
self._need_interactors = True
if not self.IsShown():
self._need_redraw = True
return
if self._need_interactors:
self._create_interactors()
self._set_profile(*self.profiles[0])
self._need_interactors = False
self.profile.redraw(reset_limits=reset_limits)
# =============================================
def _create_interactors(self):
self.profiles = []
def add_profiles(name, exp, idx):
if isinstance(exp, MixedExperiment):
for i, p in enumerate(exp.parts):
self.profiles.append((name + chr(ord("a") + i), p, idx))
else:
self.profiles.append((name, exp, idx))
if isinstance(self.model, MultiFitProblem):
for i, p in enumerate(self.model.models):
if hasattr(p.fitness, "reflectivity"):
name = p.fitness.name
if not name: name = "M%d" % (i + 1)
add_profiles(name, p.fitness, i)
else:
add_profiles("", self.model.fitness, -1)
self.profile_selector.Clear()
if len(self.profiles) > 1:
self.profile_selector.AppendItems([k for k, _, _ in self.profiles])
self.profile_selector_label.Show()
self.profile_selector.Show()
self.profile_selector.SetSelection(0)
else:
self.profile_selector_label.Hide()
self.profile_selector.Hide()
def _set_profile(self, name, experiment, idx):
# Turn the model into a user interface
# It is the responsibility of the party that is indicating
# that a redraw is necessary to clear the precalculated
# parts of the view; otherwise the theory function calculator
# is going to be triggered twice. This happens inside profile
# before the profile is calculated. Note that the profile
# panel will receive its own signal, which will cause the
# profile interactor to draw itself again. We hope this isn't
# too much of a problem.
def signal_update():
"""Notify other views that the model has changed"""
signal.update_parameters(model=self.model)
def force_recalc():
self.model.model_update()
if isinstance(self.model, MultiFitProblem):
self.model.set_active_model(idx)
self.profile.set_experiment(experiment,
force_recalc=force_recalc,
signal_update=signal_update)
def onPrinterSetup(self, event=None):
self.canvas.Printer_Setup(event=event)
def onPrinterPreview(self, event=None):
self.canvas.Printer_Preview(event=event)
def onPrint(self, event=None):
self.canvas.Printer_Print(event=event)
def OnSaveFigureMenu(self, evt):
"""
Save the current figure as an image file
"""
dlg = wx.FileDialog(
self,
message="Save Figure As ...",
defaultDir=os.getcwd(),
defaultFile="",
wildcard=
"PNG files (*.png)|*.png|BMP files (*.bmp)|*.bmp|All files (*.*)|*.*",
style=wx.SAVE)
_val = dlg.ShowModal()
if _val == wx.ID_CANCEL: return #Do nothing
if _val == wx.ID_OK:
outfile = dlg.GetPath()
dlg.Destroy()
# Save
self.fig.savefig(outfile)
def GetToolBar(self):
"""
backend_wx call this function. KEEP it
"""
return None
def OnPanelFrameClose(self, evt):
"""
On Close this Frame
"""
self.Destroy()
evt.Skip()
def OnCopyFigureMenu(self, evt):
"""
Copy the current figure
"""
CopyImage(self.canvas)
def CanShowContextMenu(self):
return True
def quit_on_error(self):
numpy.seterr(all='raise')
ProfileInteractor._debug = True
BaseInteractor._debug = True
class SquidGui( QMainWindow ):
defaults = {}
defaults.update(SquidAxon.defaults)
defaults.update(ClampCircuit.defaults)
defaults.update({'runtime': 50.0,
'simdt': 0.01,
'plotdt': 0.1,
'vclamp.holdingV': 0.0,
'vclamp.holdingT': 10.0,
'vclamp.prepulseV': 0.0,
'vclamp.prepulseT': 0.0,
'vclamp.clampV': 50.0,
'vclamp.clampT': 20.0,
'iclamp.baseI': 0.0,
'iclamp.firstI': 0.1,
'iclamp.firstT': 40.0,
'iclamp.firstD': 5.0,
'iclamp.secondI': 0.0,
'iclamp.secondT': 0.0,
'iclamp.secondD': 0.0
})
def __init__(self, *args):
QMainWindow.__init__(self, *args)
self.squid_setup = SquidSetup()
self._plotdt = SquidGui.defaults['plotdt']
self._plot_dict = defaultdict(list)
self.setWindowTitle('Squid Axon simulation')
self.setDockNestingEnabled(True)
self._createRunControl()
self.addDockWidget(QtCore.Qt.LeftDockWidgetArea, self._runControlDock)
self._runControlDock.setFeatures(QDockWidget.AllDockWidgetFeatures)
self._createChannelControl()
self._channelCtrlBox.setWindowTitle('Channel properties')
self._channelControlDock.setFeatures(QDockWidget.AllDockWidgetFeatures)
self.addDockWidget(QtCore.Qt.LeftDockWidgetArea, self._channelControlDock)
self._createElectronicsControl()
self._electronicsDock.setFeatures(QDockWidget.AllDockWidgetFeatures)
self._electronicsDock.setWindowTitle('Electronics')
self.addDockWidget(QtCore.Qt.LeftDockWidgetArea, self._electronicsDock)
self._createPlotWidget()
self.setCentralWidget(self._plotWidget)
self._createStatePlotWidget()
self._createHelpMessage()
self._helpWindow.setVisible(False)
self._statePlotWidget.setWindowFlags(QtCore.Qt.Window)
self._statePlotWidget.setWindowTitle('State plot')
self._initActions()
self._createRunToolBar()
self._createPlotToolBar()
def getFloatInput(self, widget, name):
try:
return float(str(widget.text()))
except ValueError:
QMessageBox.critical(self, 'Invalid input', 'Please enter a valid number for {}'.format(name))
raise
def _createPlotWidget(self):
self._plotWidget = QWidget()
self._plotFigure = Figure()
self._plotCanvas = FigureCanvas(self._plotFigure)
self._plotCanvas.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self._plotCanvas.updateGeometry()
self._plotCanvas.setParent(self._plotWidget)
self._plotCanvas.mpl_connect('scroll_event', self._onScroll)
self._plotFigure.set_canvas(self._plotCanvas)
# Vm and command voltage go in the same subplot
self._vm_axes = self._plotFigure.add_subplot(2,2,1, title='Membrane potential')
self._vm_axes.set_ylim(-20.0, 120.0)
# Channel conductances go to the same subplot
self._g_axes = self._plotFigure.add_subplot(2,2,2, title='Channel conductance')
self._g_axes.set_ylim(0.0, 0.5)
# Injection current for Vclamp/Iclamp go to the same subplot
self._im_axes = self._plotFigure.add_subplot(2,2,3, title='Injection current')
self._im_axes.set_ylim(-0.5, 0.5)
# Channel currents go to the same subplot
self._i_axes = self._plotFigure.add_subplot(2,2,4, title='Channel current')
self._i_axes.set_ylim(-10, 10)
for axis in self._plotFigure.axes:
axis.set_autoscale_on(False)
layout = QVBoxLayout()
layout.addWidget(self._plotCanvas)
self._plotNavigator = NavigationToolbar(self._plotCanvas, self._plotWidget)
layout.addWidget(self._plotNavigator)
self._plotWidget.setLayout(layout)
def _createStatePlotWidget(self):
self._statePlotWidget = QWidget()
self._statePlotFigure = Figure()
self._statePlotCanvas = FigureCanvas(self._statePlotFigure)
self._statePlotCanvas.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self._statePlotCanvas.updateGeometry()
self._statePlotCanvas.setParent(self._statePlotWidget)
self._statePlotFigure.set_canvas(self._statePlotCanvas)
self._statePlotFigure.subplots_adjust(hspace=0.5)
self._statePlotAxes = self._statePlotFigure.add_subplot(2,1,1, title='State plot')
self._state_plot, = self._statePlotAxes.plot([], [], label='state')
self._activationParamAxes = self._statePlotFigure.add_subplot(2,1,2, title='H-H activation parameters vs time')
self._activationParamAxes.set_xlabel('Time (ms)')
#for axis in self._plotFigure.axes:
# axis.autoscale(False)
self._stateplot_xvar_label = QLabel('Variable on X-axis')
self._stateplot_xvar_combo = QComboBox()
self._stateplot_xvar_combo.addItems(['V', 'm', 'n', 'h'])
self._stateplot_xvar_combo.setCurrentText('V')
self._stateplot_xvar_combo.setEditable(False)
self._stateplot_xvar_combo.currentIndexChanged[str].connect( self._statePlotXSlot )
self._stateplot_yvar_label = QLabel('Variable on Y-axis')
self._stateplot_yvar_combo = QComboBox()
self._stateplot_yvar_combo.addItems(['V', 'm', 'n', 'h'])
self._stateplot_yvar_combo.setCurrentIndex(2)
self._stateplot_yvar_combo.setEditable(False)
self._stateplot_yvar_combo.currentIndexChanged[str].connect(self._statePlotYSlot)
self._statePlotNavigator = NavigationToolbar(self._statePlotCanvas, self._statePlotWidget)
frame = QFrame()
frame.setFrameStyle(QFrame.StyledPanel + QFrame.Raised)
layout = QHBoxLayout()
layout.addWidget(self._stateplot_xvar_label)
layout.addWidget(self._stateplot_xvar_combo)
layout.addWidget(self._stateplot_yvar_label)
layout.addWidget(self._stateplot_yvar_combo)
frame.setLayout(layout)
self._closeStatePlotAction = QAction('Close', self)
self._closeStatePlotAction.triggered.connect(self._statePlotWidget.close)
self._closeStatePlotButton = QToolButton()
self._closeStatePlotButton.setDefaultAction(self._closeStatePlotAction)
layout = QVBoxLayout()
layout.addWidget(frame)
layout.addWidget(self._statePlotCanvas)
layout.addWidget(self._statePlotNavigator)
layout.addWidget(self._closeStatePlotButton)
self._statePlotWidget.setLayout(layout)
# Setting the close event so that when the help window is
# closed the ``State plot`` button becomes unchecked
self._statePlotWidget.closeEvent = lambda event: self._showStatePlotAction.setChecked(False)
def _createRunControl(self):
self._runControlBox = QGroupBox(self)
self._runControlBox.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
self._runTimeLabel = QLabel("Run time (ms)", self._runControlBox)
self._simTimeStepLabel = QLabel("Simulation time step (ms)", self._runControlBox)
self._runTimeEdit = QLineEdit('%g' % (SquidGui.defaults['runtime']), self._runControlBox)
set_default_line_edit_size(self._runTimeEdit)
self._simTimeStepEdit = QLineEdit('%g' % (SquidGui.defaults['simdt']), self._runControlBox)
set_default_line_edit_size(self._simTimeStepEdit)
layout = QGridLayout()
layout.addWidget(self._runTimeLabel, 0, 0)
layout.addWidget(self._runTimeEdit, 0, 1)
layout.addWidget(self._simTimeStepLabel, 1, 0)
layout.addWidget(self._simTimeStepEdit, 1, 1)
layout.setColumnStretch(2, 1.0)
layout.setRowStretch(2, 1.0)
self._runControlBox.setLayout(layout)
self._runControlDock = QDockWidget('Simulation', self)
self._runControlDock.setWidget(self._runControlBox)
def _createChannelControl(self):
self._channelControlDock = QDockWidget('Channels', self)
self._channelCtrlBox = QGroupBox(self)
self._naConductanceToggle = QCheckBox('Block Na+ channel', self._channelCtrlBox)
self._naConductanceToggle.setToolTip('<html>%s</html>' % (tooltip_NaChan))
self._kConductanceToggle = QCheckBox('Block K+ channel', self._channelCtrlBox)
self._kConductanceToggle.setToolTip('<html>%s</html>' % (tooltip_KChan))
self._kOutLabel = QLabel('[K+]out (mM)', self._channelCtrlBox)
self._kOutEdit = QLineEdit('%g' % (self.squid_setup.squid_axon.K_out),
self._channelCtrlBox)
self._kOutLabel.setToolTip('<html>%s</html>' % (tooltip_Nernst))
self._kOutEdit.setToolTip('<html>%s</html>' % (tooltip_Nernst))
set_default_line_edit_size(self._kOutEdit)
self._naOutLabel = QLabel('[Na+]out (mM)', self._channelCtrlBox)
self._naOutEdit = QLineEdit('%g' % (self.squid_setup.squid_axon.Na_out),
self._channelCtrlBox)
self._naOutLabel.setToolTip('<html>%s</html>' % (tooltip_Nernst))
self._naOutEdit.setToolTip('<html>%s</html>' % (tooltip_Nernst))
set_default_line_edit_size(self._naOutEdit)
self._kInLabel = QLabel('[K+]in (mM)', self._channelCtrlBox)
self._kInEdit = QLineEdit('%g' % (self.squid_setup.squid_axon.K_in),
self._channelCtrlBox)
self._kInEdit.setToolTip(tooltip_Nernst)
self._naInLabel = QLabel('[Na+]in (mM)', self._channelCtrlBox)
self._naInEdit = QLineEdit('%g' % (self.squid_setup.squid_axon.Na_in),
self._channelCtrlBox)
self._naInEdit.setToolTip('<html>%s</html>' % (tooltip_Nernst))
self._temperatureLabel = QLabel('Temperature (C)', self._channelCtrlBox)
self._temperatureEdit = QLineEdit('%g' % (self.defaults['temperature'] - CELSIUS_TO_KELVIN),
self._channelCtrlBox)
self._temperatureEdit.setToolTip('<html>%s</html>' % (tooltip_Nernst))
set_default_line_edit_size(self._temperatureEdit)
for child in self._channelCtrlBox.children():
if isinstance(child, QLineEdit):
set_default_line_edit_size(child)
layout = QGridLayout(self._channelCtrlBox)
layout.addWidget(self._naConductanceToggle, 0, 0)
layout.addWidget(self._kConductanceToggle, 1, 0)
layout.addWidget(self._naOutLabel, 2, 0)
layout.addWidget(self._naOutEdit, 2, 1)
layout.addWidget(self._naInLabel, 3, 0)
layout.addWidget(self._naInEdit, 3, 1)
layout.addWidget(self._kOutLabel, 4, 0)
layout.addWidget(self._kOutEdit, 4, 1)
layout.addWidget(self._kInLabel, 5, 0)
layout.addWidget(self._kInEdit, 5, 1)
layout.addWidget(self._temperatureLabel, 6, 0)
layout.addWidget(self._temperatureEdit, 6, 1)
layout.setRowStretch(7, 1.0)
self._channelCtrlBox.setLayout(layout)
self._channelControlDock.setWidget(self._channelCtrlBox)
return self._channelCtrlBox
def __get_stateplot_data(self, name):
data = []
if name == 'V':
data = self.squid_setup.vm_table.vector
elif name == 'm':
data = self.squid_setup.m_table.vector
elif name == 'h':
data = self.squid_setup.h_table.vector
elif name == 'n':
data = self.squid_setup.n_table.vector
else:
raise ValueError('Unrecognized selection: %s' % name )
return numpy.asarray(data)
def _statePlotYSlot(self, selectedItem):
ydata = self.__get_stateplot_data(str(selectedItem))
self._state_plot.set_ydata(ydata)
self._statePlotAxes.set_ylabel(selectedItem)
if str(selectedItem) == 'V':
self._statePlotAxes.set_ylim(-20, 120)
else:
self._statePlotAxes.set_ylim(0, 1)
self._statePlotCanvas.draw()
def _statePlotXSlot(self, selectedItem):
xdata = self.__get_stateplot_data(str(selectedItem))
self._state_plot.set_xdata(xdata)
self._statePlotAxes.set_xlabel(selectedItem)
if str(selectedItem) == 'V':
self._statePlotAxes.set_xlim(-20, 120)
else:
self._statePlotAxes.set_xlim(0, 1)
self._statePlotCanvas.draw()
def _createElectronicsControl(self):
"""Creates a tabbed widget of voltage clamp and current clamp controls"""
self._electronicsTab = QTabWidget(self)
self._electronicsTab.addTab(self._getIClampCtrlBox(), 'Current clamp')
self._electronicsTab.addTab(self._getVClampCtrlBox(), 'Voltage clamp')
self._electronicsDock = QDockWidget(self)
self._electronicsDock.setWidget(self._electronicsTab)
def _getVClampCtrlBox(self):
vClampPanel = QGroupBox(self)
self._vClampCtrlBox = vClampPanel
self._holdingVLabel = QLabel("Holding Voltage (mV)", vClampPanel)
self._holdingVEdit = QLineEdit('%g' % (SquidGui.defaults['vclamp.holdingV']), vClampPanel)
self._holdingTimeLabel = QLabel("Holding Time (ms)", vClampPanel)
self._holdingTimeEdit = QLineEdit('%g' % (SquidGui.defaults['vclamp.holdingT']), vClampPanel)
self._prePulseVLabel = QLabel("Pre-pulse Voltage (mV)", vClampPanel)
self._prePulseVEdit = QLineEdit('%g' % (SquidGui.defaults['vclamp.prepulseV']), vClampPanel)
self._prePulseTimeLabel = QLabel("Pre-pulse Time (ms)", vClampPanel)
self._prePulseTimeEdit = QLineEdit('%g' % (SquidGui.defaults['vclamp.prepulseT']), vClampPanel)
self._clampVLabel = QLabel("Clamp Voltage (mV)", vClampPanel)
self._clampVEdit = QLineEdit('%g' % (SquidGui.defaults['vclamp.clampV']), vClampPanel)
self._clampTimeLabel = QLabel("Clamp Time (ms)", vClampPanel)
self._clampTimeEdit = QLineEdit('%g' % (SquidGui.defaults['vclamp.clampT']), vClampPanel)
for child in vClampPanel.children():
if isinstance(child, QLineEdit):
set_default_line_edit_size(child)
layout = QGridLayout(vClampPanel)
layout.addWidget(self._holdingVLabel, 0, 0)
layout.addWidget(self._holdingVEdit, 0, 1)
layout.addWidget(self._holdingTimeLabel, 1, 0)
layout.addWidget(self._holdingTimeEdit, 1, 1)
layout.addWidget(self._prePulseVLabel, 2, 0)
layout.addWidget(self._prePulseVEdit, 2, 1)
layout.addWidget(self._prePulseTimeLabel,3,0)
layout.addWidget(self._prePulseTimeEdit, 3, 1)
layout.addWidget(self._clampVLabel, 4, 0)
layout.addWidget(self._clampVEdit, 4, 1)
layout.addWidget(self._clampTimeLabel, 5, 0)
layout.addWidget(self._clampTimeEdit, 5, 1)
layout.setRowStretch(6, 1.0)
vClampPanel.setLayout(layout)
return self._vClampCtrlBox
def _getIClampCtrlBox(self):
iClampPanel = QGroupBox(self)
self._iClampCtrlBox = iClampPanel
self._baseCurrentLabel = QLabel("Base Current Level (uA)",iClampPanel)
self._baseCurrentEdit = QLineEdit('%g' % (SquidGui.defaults['iclamp.baseI']),iClampPanel)
self._firstPulseLabel = QLabel("First Pulse Current (uA)", iClampPanel)
self._firstPulseEdit = QLineEdit('%g' % (SquidGui.defaults['iclamp.firstI']), iClampPanel)
self._firstDelayLabel = QLabel("First Onset Delay (ms)", iClampPanel)
self._firstDelayEdit = QLineEdit('%g' % (SquidGui.defaults['iclamp.firstD']),iClampPanel)
self._firstPulseWidthLabel = QLabel("First Pulse Width (ms)", iClampPanel)
self._firstPulseWidthEdit = QLineEdit('%g' % (SquidGui.defaults['iclamp.firstT']), iClampPanel)
self._secondPulseLabel = QLabel("Second Pulse Current (uA)", iClampPanel)
self._secondPulseEdit = QLineEdit('%g' % (SquidGui.defaults['iclamp.secondI']), iClampPanel)
self._secondDelayLabel = QLabel("Second Onset Delay (ms)", iClampPanel)
self._secondDelayEdit = QLineEdit('%g' % (SquidGui.defaults['iclamp.secondD']),iClampPanel)
self._secondPulseWidthLabel = QLabel("Second Pulse Width (ms)", iClampPanel)
self._secondPulseWidthEdit = QLineEdit('%g' % (SquidGui.defaults['iclamp.secondT']), iClampPanel)
self._pulseMode = QComboBox(iClampPanel)
self._pulseMode.addItem("Single Pulse")
self._pulseMode.addItem("Pulse Train")
for child in iClampPanel.children():
if isinstance(child, QLineEdit):
set_default_line_edit_size(child)
layout = QGridLayout(iClampPanel)
layout.addWidget(self._baseCurrentLabel, 0, 0)
layout.addWidget(self._baseCurrentEdit, 0, 1)
layout.addWidget(self._firstPulseLabel, 1, 0)
layout.addWidget(self._firstPulseEdit, 1, 1)
layout.addWidget(self._firstDelayLabel, 2, 0)
layout.addWidget(self._firstDelayEdit, 2, 1)
layout.addWidget(self._firstPulseWidthLabel, 3, 0)
layout.addWidget(self._firstPulseWidthEdit, 3, 1)
layout.addWidget(self._secondPulseLabel, 4, 0)
layout.addWidget(self._secondPulseEdit, 4, 1)
layout.addWidget(self._secondDelayLabel, 5, 0)
layout.addWidget(self._secondDelayEdit, 5, 1)
layout.addWidget(self._secondPulseWidthLabel, 6, 0)
layout.addWidget(self._secondPulseWidthEdit, 6, 1)
layout.addWidget(self._pulseMode, 7, 0, 1, 2)
layout.setRowStretch(8, 1.0)
# layout.setSizeConstraint(QLayout.SetFixedSize)
iClampPanel.setLayout(layout)
return self._iClampCtrlBox
def _overlayPlots(self, overlay):
if not overlay:
for axis in (self._plotFigure.axes + self._statePlotFigure.axes):
title = axis.get_title()
axis.clear()
axis.set_title(title)
suffix = ''
else:
suffix = '_%d' % (len(self._plot_dict['vm']))
self._vm_axes.set_xlim(0.0, self._runtime)
self._g_axes.set_xlim(0.0, self._runtime)
self._im_axes.set_xlim(0.0, self._runtime)
self._i_axes.set_xlim(0.0, self._runtime)
self._vm_plot, = self._vm_axes.plot([], [], label='Vm%s'%(suffix))
self._plot_dict['vm'].append(self._vm_plot)
self._command_plot, = self._vm_axes.plot([], [], label='command%s'%(suffix))
self._plot_dict['command'].append(self._command_plot)
# Channel conductances go to the same subplot
self._gna_plot, = self._g_axes.plot([], [], label='Na%s'%(suffix))
self._plot_dict['gna'].append(self._gna_plot)
self._gk_plot, = self._g_axes.plot([], [], label='K%s'%(suffix))
self._plot_dict['gk'].append(self._gk_plot)
# Injection current for Vclamp/Iclamp go to the same subplot
self._iclamp_plot, = self._im_axes.plot([], [], label='Iclamp%s'%(suffix))
self._vclamp_plot, = self._im_axes.plot([], [], label='Vclamp%s'%(suffix))
self._plot_dict['iclamp'].append(self._iclamp_plot)
self._plot_dict['vclamp'].append(self._vclamp_plot)
# Channel currents go to the same subplot
self._ina_plot, = self._i_axes.plot([], [], label='Na%s'%(suffix))
self._plot_dict['ina'].append(self._ina_plot)
self._ik_plot, = self._i_axes.plot([], [], label='K%s'%(suffix))
self._plot_dict['ik'].append(self._ik_plot)
# self._i_axes.legend()
# State plots
self._state_plot, = self._statePlotAxes.plot([], [], label='state%s'%(suffix))
self._plot_dict['state'].append(self._state_plot)
self._m_plot, = self._activationParamAxes.plot([],[], label='m%s'%(suffix))
self._h_plot, = self._activationParamAxes.plot([], [], label='h%s'%(suffix))
self._n_plot, = self._activationParamAxes.plot([], [], label='n%s'%(suffix))
self._plot_dict['m'].append(self._m_plot)
self._plot_dict['h'].append(self._h_plot)
self._plot_dict['n'].append(self._n_plot)
if self._showLegendAction.isChecked():
for axis in (self._plotFigure.axes + self._statePlotFigure.axes):
axis.legend()
def _updateAllPlots(self):
self._updatePlots()
self._updateStatePlot()
def _updatePlots(self):
if len(self.squid_setup.vm_table.vector) <= 0:
return
vm = numpy.asarray(self.squid_setup.vm_table.vector)
cmd = numpy.asarray(self.squid_setup.cmd_table.vector)
ik = numpy.asarray(self.squid_setup.ik_table.vector)
ina = numpy.asarray(self.squid_setup.ina_table.vector)
iclamp = numpy.asarray(self.squid_setup.iclamp_table.vector)
vclamp = numpy.asarray(self.squid_setup.vclamp_table.vector)
gk = numpy.asarray(self.squid_setup.gk_table.vector)
gna = numpy.asarray(self.squid_setup.gna_table.vector)
time_series = numpy.linspace(0, self._plotdt * len(vm), len(vm))
self._vm_plot.set_data(time_series, vm)
time_series = numpy.linspace(0, self._plotdt * len(cmd), len(cmd))
self._command_plot.set_data(time_series, cmd)
time_series = numpy.linspace(0, self._plotdt * len(ik), len(ik))
self._ik_plot.set_data(time_series, ik)
time_series = numpy.linspace(0, self._plotdt * len(ina), len(ina))
self._ina_plot.set_data(time_series, ina)
time_series = numpy.linspace(0, self._plotdt * len(iclamp), len(iclamp))
self._iclamp_plot.set_data(time_series, iclamp)
time_series = numpy.linspace(0, self._plotdt * len(vclamp), len(vclamp))
self._vclamp_plot.set_data(time_series, vclamp)
time_series = numpy.linspace(0, self._plotdt * len(gk), len(gk))
self._gk_plot.set_data(time_series, gk)
time_series = numpy.linspace(0, self._plotdt * len(gna), len(gna))
self._gna_plot.set_data(time_series, gna)
# self._vm_axes.margins(y=0.1)
# self._g_axes.margin(y=0.1)
# self._im_axes.margins(y=0.1)
# self._i_axes.margins(y=0.1)
if self._autoscaleAction.isChecked():
for axis in self._plotFigure.axes:
axis.relim()
axis.margins(0.1, 0.1)
axis.autoscale_view(tight=True)
else:
self._vm_axes.set_ylim(-20.0, 120.0)
self._g_axes.set_ylim(0.0, 0.5)
self._im_axes.set_ylim(-0.5, 0.5)
self._i_axes.set_ylim(-10, 10)
self._vm_axes.set_xlim(0.0, time_series[-1])
self._g_axes.set_xlim(0.0, time_series[-1])
self._im_axes.set_xlim(0.0, time_series[-1])
self._i_axes.set_xlim(0.0, time_series[-1])
self._plotCanvas.draw()
def _updateStatePlot(self):
if len(self.squid_setup.vm_table.vector) <= 0:
return
sx = str(self._stateplot_xvar_combo.currentText())
sy = str(self._stateplot_yvar_combo.currentText())
xdata = self.__get_stateplot_data(sx)
ydata = self.__get_stateplot_data(sy)
minlen = min(len(xdata), len(ydata))
self._state_plot.set_data(xdata[:minlen], ydata[:minlen])
self._statePlotAxes.set_xlabel(sx)
self._statePlotAxes.set_ylabel(sy)
if sx == 'V':
self._statePlotAxes.set_xlim(-20, 120)
else:
self._statePlotAxes.set_xlim(0, 1)
if sy == 'V':
self._statePlotAxes.set_ylim(-20, 120)
else:
self._statePlotAxes.set_ylim(0, 1)
self._activationParamAxes.set_xlim(0, self._runtime)
m = self.__get_stateplot_data('m')
n = self.__get_stateplot_data('n')
h = self.__get_stateplot_data('h')
time_series = numpy.linspace(0, self._plotdt*len(m), len(m))
self._m_plot.set_data(time_series, m)
time_series = numpy.linspace(0, self._plotdt*len(h), len(h))
self._h_plot.set_data(time_series, h)
time_series = numpy.linspace(0, self._plotdt*len(n), len(n))
self._n_plot.set_data(time_series, n)
if self._autoscaleAction.isChecked():
for axis in self._statePlotFigure.axes:
axis.relim()
axis.set_autoscale_on(True)
axis.autoscale_view(True)
self._statePlotCanvas.draw()
def _runSlot(self):
if moose.isRunning():
print('Stopping simulation in progress ...')
moose.stop()
self._runtime = self.getFloatInput(self._runTimeEdit, self._runTimeLabel.text())
self._overlayPlots(self._overlayAction.isChecked())
self._simdt = self.getFloatInput(self._simTimeStepEdit, self._simTimeStepLabel.text())
clampMode = None
singlePulse = True
if self._electronicsTab.currentWidget() == self._vClampCtrlBox:
clampMode = 'vclamp'
baseLevel = self.getFloatInput(self._holdingVEdit, self._holdingVLabel.text())
firstDelay = self.getFloatInput(self._holdingTimeEdit, self._holdingTimeLabel.text())
firstWidth = self.getFloatInput(self._prePulseTimeEdit, self._prePulseTimeLabel.text())
firstLevel = self.getFloatInput(self._prePulseVEdit, self._prePulseVLabel.text())
secondDelay = firstWidth
secondWidth = self.getFloatInput(self._clampTimeEdit, self._clampTimeLabel.text())
secondLevel = self.getFloatInput(self._clampVEdit, self._clampVLabel.text())
if not self._autoscaleAction.isChecked():
self._im_axes.set_ylim(-10.0, 10.0)
else:
clampMode = 'iclamp'
baseLevel = self.getFloatInput(self._baseCurrentEdit, self._baseCurrentLabel.text())
firstDelay = self.getFloatInput(self._firstDelayEdit, self._firstDelayLabel.text())
firstWidth = self.getFloatInput(self._firstPulseWidthEdit, self._firstPulseWidthLabel.text())
firstLevel = self.getFloatInput(self._firstPulseEdit, self._firstPulseLabel.text())
secondDelay = self.getFloatInput(self._secondDelayEdit, self._secondDelayLabel.text())
secondLevel = self.getFloatInput(self._secondPulseEdit, self._secondPulseLabel.text())
secondWidth = self.getFloatInput(self._secondPulseWidthEdit, self._secondPulseWidthLabel.text())
singlePulse = (self._pulseMode.currentIndex() == 0)
if not self._autoscaleAction.isChecked():
self._im_axes.set_ylim(-0.4, 0.4)
self.squid_setup.clamp_ckt.configure_pulses(baseLevel=baseLevel,
firstDelay=firstDelay,
firstWidth=firstWidth,
firstLevel=firstLevel,
secondDelay=secondDelay,
secondWidth=secondWidth,
secondLevel=secondLevel,
singlePulse=singlePulse)
if self._kConductanceToggle.isChecked():
self.squid_setup.squid_axon.specific_gK = 0.0
else:
self.squid_setup.squid_axon.specific_gK = SquidAxon.defaults['specific_gK']
if self._naConductanceToggle.isChecked():
self.squid_setup.squid_axon.specific_gNa = 0.0
else:
self.squid_setup.squid_axon.specific_gNa = SquidAxon.defaults['specific_gNa']
self.squid_setup.squid_axon.celsius = self.getFloatInput(self._temperatureEdit, self._temperatureLabel.text())
self.squid_setup.squid_axon.K_out = self.getFloatInput(self._kOutEdit, self._kOutLabel.text())
self.squid_setup.squid_axon.Na_out = self.getFloatInput(self._naOutEdit, self._naOutLabel.text())
self.squid_setup.squid_axon.K_in = self.getFloatInput(self._kInEdit, self._kInLabel.text())
self.squid_setup.squid_axon.Na_in = self.getFloatInput(self._naInEdit, self._naInLabel.text())
self.squid_setup.squid_axon.updateEk()
self.squid_setup.schedule(self._simdt, self._plotdt, clampMode)
# The following line is for use with Qthread
self.squid_setup.run(self._runtime)
self._updateAllPlots()
def _toggleDocking(self, on):
self._channelControlDock.setFloating(on)
self._electronicsDock.setFloating(on)
self._runControlDock.setFloating(on)
def _restoreDocks(self):
self._channelControlDock.setVisible(True)
self._electronicsDock.setVisible(True)
self._runControlDock.setVisible(True)
def _initActions(self):
self._runAction = QAction(self.tr('Run'), self)
self._runAction.setShortcut(self.tr('F5'))
self._runAction.setToolTip('Run simulation (F5)')
self._runAction.triggered.connect( self._runSlot)
self._resetToDefaultsAction = QAction(self.tr('Restore defaults'), self)
self._resetToDefaultsAction.setToolTip('Reset all settings to their default values')
self._resetToDefaultsAction.triggered.connect( self._useDefaults)
self._showLegendAction = QAction(self.tr('Display legend'), self)
self._showLegendAction.setCheckable(True)
self._showLegendAction.toggled.connect(self._showLegend)
self._showStatePlotAction = QAction(self.tr('State plot'), self)
self._showStatePlotAction.setCheckable(True)
self._showStatePlotAction.setChecked(False)
self._showStatePlotAction.toggled.connect(self._statePlotWidget.setVisible)
self._autoscaleAction = QAction(self.tr('Auto-scale plots'), self)
self._autoscaleAction.setCheckable(True)
self._autoscaleAction.setChecked(False)
self._autoscaleAction.toggled.connect(self._autoscale)
self._overlayAction = QAction('Overlay plots', self)
self._overlayAction.setCheckable(True)
self._overlayAction.setChecked(False)
self._dockAction = QAction('Undock all', self)
self._dockAction.setCheckable(True)
self._dockAction.setChecked(False)
# self._dockAction.toggle.connect( self._toggleDocking)
self._restoreDocksAction = QAction('Show all', self)
self._restoreDocksAction.triggered.connect( self._restoreDocks)
self._quitAction = QAction(self.tr('&Quit'), self)
self._quitAction.setShortcut(self.tr('Ctrl+Q'))
self._quitAction.triggered.connect(qApp.closeAllWindows)
def _createRunToolBar(self):
self._simToolBar = self.addToolBar(self.tr('Simulation control'))
self._simToolBar.addAction(self._quitAction)
self._simToolBar.addAction(self._runAction)
self._simToolBar.addAction(self._resetToDefaultsAction)
self._simToolBar.addAction(self._dockAction)
self._simToolBar.addAction(self._restoreDocksAction)
def _createPlotToolBar(self):
self._plotToolBar = self.addToolBar(self.tr('Plotting control'))
self._plotToolBar.addAction(self._showLegendAction)
self._plotToolBar.addAction(self._autoscaleAction)
self._plotToolBar.addAction(self._overlayAction)
self._plotToolBar.addAction(self._showStatePlotAction)
self._plotToolBar.addAction(self._helpAction)
self._plotToolBar.addAction(self._helpBiophysicsAction)
def _showLegend(self, on):
if on:
for axis in (self._plotFigure.axes + self._statePlotFigure.axes):
axis.legend().set_visible(True)
else:
for axis in (self._plotFigure.axes + self._statePlotFigure.axes):
axis.legend().set_visible(False)
self._plotCanvas.draw()
self._statePlotCanvas.draw()
def _autoscale(self, on):
if on:
for axis in (self._plotFigure.axes + self._statePlotFigure.axes):
axis.relim()
axis.set_autoscale_on(True)
axis.autoscale_view(True)
else:
for axis in self._plotFigure.axes:
axis.set_autoscale_on(False)
self._vm_axes.set_ylim(-20.0, 120.0)
self._g_axes.set_ylim(0.0, 0.5)
self._im_axes.set_ylim(-0.5, 0.5)
self._i_axes.set_ylim(-10, 10)
self._plotCanvas.draw()
self._statePlotCanvas.draw()
def _useDefaults(self):
self._runTimeEdit.setText('%g' % (self.defaults['runtime']))
self._simTimeStepEdit.setText('%g' % (self.defaults['simdt']))
self._overlayAction.setChecked(False)
self._naConductanceToggle.setChecked(False)
self._kConductanceToggle.setChecked(False)
self._kOutEdit.setText('%g' % (SquidGui.defaults['K_out']))
self._naOutEdit.setText('%g' % (SquidGui.defaults['Na_out']))
self._kInEdit.setText('%g' % (SquidGui.defaults['K_in']))
self._naInEdit.setText('%g' % (SquidGui.defaults['Na_in']))
self._temperatureEdit.setText('%g' % (SquidGui.defaults['temperature'] - CELSIUS_TO_KELVIN))
self._holdingVEdit.setText('%g' % (SquidGui.defaults['vclamp.holdingV']))
self._holdingTimeEdit.setText('%g' % (SquidGui.defaults['vclamp.holdingT']))
self._prePulseVEdit.setText('%g' % (SquidGui.defaults['vclamp.prepulseV']))
self._prePulseTimeEdit.setText('%g' % (SquidGui.defaults['vclamp.prepulseT']))
self._clampVEdit.setText('%g' % (SquidGui.defaults['vclamp.clampV']))
self._clampTimeEdit.setText('%g' % (SquidGui.defaults['vclamp.clampT']))
self._baseCurrentEdit.setText('%g' % (SquidGui.defaults['iclamp.baseI']))
self._firstPulseEdit.setText('%g' % (SquidGui.defaults['iclamp.firstI']))
self._firstDelayEdit.setText('%g' % (SquidGui.defaults['iclamp.firstD']))
self._firstPulseWidthEdit.setText('%g' % (SquidGui.defaults['iclamp.firstT']))
self._secondPulseEdit.setText('%g' % (SquidGui.defaults['iclamp.secondI']))
self._secondDelayEdit.setText('%g' % (SquidGui.defaults['iclamp.secondD']))
self._secondPulseWidthEdit.setText('%g' % (SquidGui.defaults['iclamp.secondT']))
self._pulseMode.setCurrentIndex(0)
def _onScroll(self, event):
if event.inaxes is None:
return
axes = event.inaxes
zoom = 0.0
if event.button == 'up':
zoom = -1.0
elif event.button == 'down':
zoom = 1.0
if zoom != 0.0:
self._plotNavigator.push_current()
axes.get_xaxis().zoom(zoom)
axes.get_yaxis().zoom(zoom)
self._plotCanvas.draw()
def closeEvent(self, event):
qApp.closeAllWindows()
def _showBioPhysicsHelp(self):
self._createHelpMessage()
self._helpMessageText.setText('<html><p>%s</p><p>%s</p><p>%s</p><p>%s</p><p>%s</p></html>' %
(tooltip_Nernst,
tooltip_Erest,
tooltip_KChan,
tooltip_NaChan,
tooltip_Im))
self._helpWindow.setVisible(True)
def _showRunningHelp(self):
self._createHelpMessage()
self._helpMessageText.setSource(QtCore.QUrl(self._helpBaseURL))
self._helpWindow.setVisible(True)
def _createHelpMessage(self):
if hasattr(self, '_helpWindow'):
return
self._helpWindow = QWidget()
self._helpWindow.setWindowFlags(QtCore.Qt.Window)
layout = QVBoxLayout()
self._helpWindow.setLayout(layout)
self._helpMessageArea = QScrollArea()
self._helpMessageText = QTextBrowser()
self._helpMessageText.setOpenExternalLinks(True)
self._helpMessageArea.setWidget(self._helpMessageText)
layout.addWidget(self._helpMessageText)
self._squidGuiPath = os.path.dirname(os.path.abspath(__file__))
self._helpBaseURL = os.path.join(self._squidGuiPath,'help.html')
self._helpMessageText.setSource(QtCore.QUrl(self._helpBaseURL))
self._helpMessageText.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self._helpMessageArea.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self._helpMessageText.setMinimumSize(800, 600)
self._closeHelpAction = QAction('Close', self)
self._closeHelpAction.triggered.connect(self._helpWindow.close)
# Setting the close event so that the ``Help`` button is
# unchecked when the help window is closed
self._helpWindow.closeEvent = lambda event: self._helpAction.setChecked(False)
self._helpTOCAction = QAction('Help running demo', self)
self._helpTOCAction.triggered.connect( self._jumpToHelpTOC)
# This panel is for putting two buttons using horizontal
# layout
panel = QFrame()
panel.setFrameStyle(QFrame.StyledPanel + QFrame.Raised)
layout.addWidget(panel)
layout = QHBoxLayout()
panel.setLayout(layout)
self._helpAction = QAction('Help running', self)
self._helpAction.triggered.connect(self._showRunningHelp)
self._helpBiophysicsAction = QAction('Help biophysics', self)
self._helpBiophysicsAction.triggered.connect(self._showBioPhysicsHelp)
self._helpTOCButton = QToolButton()
self._helpTOCButton.setDefaultAction(self._helpTOCAction)
self._helpBiophysicsButton = QToolButton()
self._helpBiophysicsButton.setDefaultAction(self._helpBiophysicsAction)
layout.addWidget(self._helpTOCButton)
layout.addWidget(self._helpBiophysicsButton)
self._closeHelpButton = QToolButton()
self._closeHelpButton.setDefaultAction(self._closeHelpAction)
layout.addWidget(self._closeHelpButton)
def _jumpToHelpTOC(self):
self._helpMessageText.setSource(QtCore.QUrl(self._helpBaseURL))
def plotALot(
self,
gene_list, # list of genes to plot
savedir="",
title="images",
grid=(4, 8), # grid to plot for each figure
figsize=(16, 9),
dpi=300,
):
"""
plot a lot of intensity maps
from a list of genes
"""
genes_per_plot = grid[0] * grid[1]
num_plots, remainder = divmod(len(gene_list), (genes_per_plot))
# add an extra plot if
# number of genes is not perfectly divisible by number of plots
if remainder != 0:
num_plots += 1
for img_num in range(len(self.img_arrays)):
# set up index for number of genes already plotted
# ------------------------------------------------
reordered_idx = 0
for plot_num in range(num_plots):
# set up figure canvas
# --------------------
fig = Figure(figsize=figsize, dpi=dpi)
canvas = FigCanvas(fig)
fig.set_canvas(canvas)
for gridpos in range(genes_per_plot):
# check if we have reached end of gene list
# -----------------------------------------
if reordered_idx == len(gene_list) - 1:
break
# create temporary axes reference
# -------------------------------
ax = fig.add_subplot(grid[0], grid[1], gridpos + 1)
# plot the current gene
# ---------------------
array_idx = self.gene_index_dict[gene_list[reordered_idx]]
ax.imshow(self.img_arrays[img_num][array_idx, ...],
cmap="hot")
ax.set_title(gene_list[reordered_idx])
# increment gene index
# --------------------
reordered_idx += 1
fig.suptitle(title + f"\n{self.hdf5_file_list[img_num]}"
f"\n({plot_num + 1} of {num_plots})")
fig.tight_layout(rect=(0, 0, 1, .94))
# save the plot
# -------------
savename = (
f"image_{img_num + 1}_{title.replace(' ','_')}"
f"_{plot_num + 1}of{num_plots}_{self.time_str}.png")
if not os.path.exists(savedir):
os.mkdir(savedir)
fig.savefig(os.path.join(savedir, savename), dpi=dpi)
# close the canvas
# ----------------
canvas.close()
fig.clear()
from matplotlib.figure import Figure
from matplotlib.backends.backend_svg import new_figure_manager
def graph(fig):
t1 = [1, 2, 3, 4, 5]
ax = fig.add_subplot(1, 1, 1)
ax.plot(t1, t1, 'bo')
fig = Figure()
graph(fig)
manager = new_figure_manager(1, dpi=72)
manager.canvas.figure = fig
fig.set_canvas(manager.canvas)
fig.savefig("dist/a.svg")
def show_fit_at_position(mcmc_set, fit_value, position, fit_name):
"""Create the result page showing the fit quality at the given position.
Parameters
----------
mcmc_set : MCMCSet object
The set of MCMC chains
fit_value : float
The quality of fit at the given position.
position : numpy.array
Array of (log10-transformed) parameter values at the given position.
fit_name : string
A shorthand name for the fit position, e.g., "max_likelihood". Should
conform to rules of Python variable naming (no spaces, doesn't
start with a number, etc.).
Returns
-------
A result object containing the fit value and the link to the accompanying
HTML plot page, if any.
"""
# If the MCMC object does not have a fit_plotting_function defined
# (for example, if it is a base MCMC object), then don't create a
# plot for visualization.
if not hasattr(mcmc_set.chains[0], 'fit_plotting_function'):
return Result(fit_value, None)
# Prepare html for page showing plots at position
html_str = "<html><head><title>Simulation of %s " \
"with %s parameter values</title></head>\n" \
% (mcmc_set.name, fit_name)
html_str += "<body><p>Simulation of %s with %s " \
"parameter values</p>\n" % (mcmc_set.name, fit_name)
# Show the plot vs. the data at the position
fig = mcmc_set.chains[0].fit_plotting_function(position=position)
img_filename = '%s_%s_plot.png' % (mcmc_set.name, fit_name)
fig.savefig(img_filename)
html_str += '<p><img src="%s" /></p>' % img_filename
# Show the plot of all observables at the position
chain0 = mcmc_set.chains[0]
tspan = chain0.options.tspan
observables = chain0.options.model.observables
x = chain0.simulate(position=position, observables=True)
fig = Figure()
ax = fig.gca()
lines = []
for o in observables:
line = ax.plot(tspan, x[o.name])
lines += line
ax.set_title("Observables at %s" % fit_name)
fig.legend(lines, [o.name for o in observables], 'lower right')
canvas = FigureCanvasAgg(fig)
fig.set_canvas(canvas)
img_filename = '%s_%s_species.png' % (mcmc_set.name, fit_name)
fig.savefig(img_filename)
html_str += '<p><img src="%s" /></p>' % img_filename
# Print the parameter values for the position as a dict that can be
# used to override the initial values
html_str += '<pre>%s_params = {\n' % fit_name
for i, p in enumerate(chain0.options.estimate_params):
html_str += "\t'%s': %.17g,\n" % \
(p.name, 10 ** position[i])
html_str += '}</pre>'
html_str += '</body></html>'
# Create the html file
html_filename = '%s_%s_plot.html' % (mcmc_set.name, fit_name)
with open(html_filename, 'w') as f:
f.write(html_str)
return Result(fit_value, html_filename)
command=getit)
w.pack(side=tk.BOTTOM)
# .............................setting up matplotlib figure and plot................................
fig = Figure(figsize=(10, 5))
fig1 = Figure(figsize=(10, 1))
ax = fig.subplots()
ax1 = fig1.subplots()
canvas = FigureCanvasTkAgg(fig, root)
canvas1 = FigureCanvasTkAgg(fig1, root)
fig.set_canvas(canvas=canvas)
fig1.set_canvas(canvas=canvas1)
button1 = tk.Button(root, text="<-- LEFT", command=go_left)
button1.configure(width=10, activebackground="#bfbfbf", relief=tk.FLAT)
button1.pack(side=tk.LEFT)
button2 = tk.Button(root, text="RIGHT-->", command=go_right)
button2.configure(width=10, activebackground="#bfbfbf", relief=tk.FLAT)
button2.pack(side=tk.RIGHT)
# ...................................Hover .........................................
annot = ax.annotate("",
xy=(0, 0),
xytext=(20, 20),
def plot_net_set(pkl_glob,expname):
if type(pkl_glob) is str:
pklnames = glob.glob(pkl_glob)
else:
pklnames = pkl_glob
pklnames.sort()
nms = load_net_pkl(pklnames[0])
nres = len(set([nm.index for nm in nms]))
ntemps = len(pklnames)
chipfname = nms[0].chip.replace(' ','_')
exppdf = PdfPages('/home/data/plots/net_%s_%s.pdf' % (expname,chipfname))
fig = plt.figure()
ax = fig.add_subplot(111)
colors = plt.cm.spectral(np.linspace(0.1,0.9,ntemps+1))
respdfs = {}
resfigs = {}
resfigs2 = {}
resfigs3 = {}
nets = np.zeros((ntemps,nres))
temps = np.zeros((ntemps,))
spectra = defaultdict(list)
tidx = 0
for pklname in pklnames:
nms = load_net_pkl(pklname)
for idx in range(nres):
if not respdfs.has_key(idx):
respdfs[idx] = PdfPages('/home/data/plots/net_%s_%s_%02d.pdf' % (expname,chipfname,idx))
rset = [nm for nm in nms if nm.index == idx]
fig = Figure(figsize=(16,8))
K_per_Hz,dt,df,ukrs = plot_net_sweep(rset,fig=fig)
fig.suptitle('%s\n%02d - %f MHz' % (pklname,idx,rset[0].f0))
canvas = FigureCanvasAgg(fig)
fig.set_canvas(canvas)
try:
respdfs[idx].savefig(fig,bbox_inches='tight')
except:
raise
print "Error with index",idx,pklname
nm0 = rset[0]
temps[tidx] = nm0.ts_temp
nets[tidx,idx] = ukrs
if not resfigs.has_key(idx):
resfigs[idx] = Figure(figsize=(16,8))
resfigs[idx].add_subplot(111)
resfigs2[idx] = Figure(figsize=(16,8))
resfigs2[idx].add_subplot(111)
resfigs3[idx] = Figure(figsize=(16,8))
resfigs3[idx].add_subplot(111)
ax = resfigs[idx].axes[0]
if np.isfinite(K_per_Hz) and abs(K_per_Hz) > 0:
ax.semilogx(nm0.pca_fr,np.sqrt(nm0.pca_evals[1,:])*1e6*nm0.f0*abs(K_per_Hz)*1e6/np.sqrt(2),label=('%.3f K' % nm0.ts_temp),color=colors[tidx])
ax.set_ylim(0,100)
ax.grid(True)
spectra[idx].append((nm0.pca_fr,np.sqrt(nm0.pca_evals[1,:])*1e6*nm0.f0*abs(K_per_Hz)*1e6/np.sqrt(2)))
ax = resfigs2[idx].axes[0]
ax.plot(nms[idx].frm,20*np.log10(abs(nms[idx].s21m+nms[idx].s0)),color=plt.cm.spectral(nms[idx].ts_temp/10.0))
ax.plot(nms[idx].fr,20*np.log10(abs(nms[idx].s21)),'.',color=plt.cm.spectral(nms[idx].ts_temp/10.0))
ax = resfigs3[idx].axes[0]
ax.semilogx(nm0.pca_fr,np.sqrt(nm0.pca_evals[1,:])*1e6*nm0.f0,label=('%.3f K' % nm0.ts_temp),color=colors[tidx])
ax.set_ylim(0,0.5)
ax.grid(True)
tidx += 1
for idx,fig in resfigs.items():
ax = fig.axes[0]
ax.legend(loc='lower left', prop=dict(size='x-small'))
canvas = FigureCanvasAgg(fig)
fig.set_canvas(canvas)
respdfs[idx].savefig(fig,bbox_inches='tight')
canvas = FigureCanvasAgg(resfigs2[idx])
resfigs2[idx].set_canvas(canvas)
respdfs[idx].savefig(resfigs2[idx],bbox_inches='tight')
canvas = FigureCanvasAgg(resfigs3[idx])
resfigs3[idx].set_canvas(canvas)
respdfs[idx].savefig(resfigs3[idx],bbox_inches='tight')
respdfs[idx].close()
return temps,nets,spectra
