def run():
input_dir = "../../../../Data/FECs180307/"
out_dir = "./"
q_offset_nm = 100
q_interp, energy_list_arr, _ = FigureUtil.\
_read_energy_list_and_q_interp(input_dir, q_offset=q_offset_nm,
min_fecs=9)
# read in some example data
base_dir_BR = input_dir + "BR+Retinal/"
names_BR = ["/BR+Retinal/3000nms/170503FEC/landscape_"]
PEG600 = FigureUtil._read_samples(base_dir_BR,names_BR)[0]
# read in the FECs
fecs = FigureUtil._snapsnot(PEG600.base_dir,
step=Pipeline.Step.REDUCED).fec_list
args_mean = (energy_list_arr, q_interp)
mean_A = mean_A_jarzynski(*args_mean)
mean_G = mean_G_iwt(*args_mean)
mean_F_from_dot = mean_A_dot_iwt(*args_mean)[0]
ex = fecs[0]
q = q_interp * 1e-9
# xxx offset q and z... probably a little off!
z = ex.ZFunc(ex) + q[0]
k = ex.SpringConstant
beta = ex.Beta
A = mean_A[0]
G = mean_G[0]
n_iters = 5000
force =True
kw_lr = dict(G0=G, A=A, q=q, z=z, k=k, beta=beta,n_iters=n_iters)
lr = CheckpointUtilities.getCheckpoint("./lr_deconv.pkl",
_deconvoled_lr,force,**kw_lr)
diff_kT = np.array(lr.mean_diffs) * beta
min_idx = np.argmin(diff_kT)
idx_search = np.logspace(start=3,stop=np.floor(np.log2(min_idx)),
endpoint=True,num=10,base=2)
idx_to_use = [int(i) for i in idx_search]
# fit a spline to the converged G to get the mean restoring force
fig = PlotUtilities.figure((4,6))
xlim = [min(q_interp)-5, max(q_interp)]
fmt_kw = dict(xlim=xlim,ylim=[None,None])
ax1 = plt.subplot(3,1,1)
plt.plot(diff_kT)
plt.axvline(min_idx)
FigureUtil._plot_fmt(ax1,is_bottom=True,xlabel="iter #",
ylabel="diff G (kT)",xlim=[None,None],ylim=[None,None])
ax2 = plt.subplot(3,1,2)
plt.plot(q_interp,lr._G0_initial_lr.G0_kT,color='b',linewidth=3)
plt.plot(q_interp,lr.G0_kT,color='r',linewidth=3)
FigureUtil._plot_fmt(ax2,is_bottom=False,ylabel="G (kT)",**fmt_kw)
ax1 = plt.subplot(3,1,3)
FigureUtil._plot_fec_list(fecs, xlim, ylim=[None,None])
for i in idx_to_use:
_plot_f_at_iter_idx(lr, i)
_plot_f_at_iter_idx(lr, 0,label="F from G0",linewidth=4)
plt.plot(q_interp,mean_F_from_dot*1e12,label="F from A_z_dot",linewidth=2)
# also plot the force we expect from the original A_z_dot
FigureUtil._plot_fmt(ax1,is_bottom=True,xlim=xlim,ylim=[None,None])
PlotUtilities.legend()
PlotUtilities.savefig(fig,"FigureS_A_z.png")
pass
def _G0_plot(plot_dir, data_sliced, landscape, fmt):
# XXX why is this necessary?? screwing up absolute values
previous_JCP = FigureUtil.read_non_peg_landscape(base="../../FigData/")
offset_s = np.mean([d.Separation[0] for d in data_sliced])
G_hao = landscape.G0_kcal_per_mol
idx_zero = np.where(landscape.q_nm <= 100)
G_hao = G_hao - landscape.G0_kcal_per_mol[0]
G_JCP = previous_JCP.G0_kcal_per_mol - previous_JCP.G0_kcal_per_mol[0] + 50
offset_jcp_nm = min(previous_JCP.q_nm)
landscape_offset_nm = min(landscape.q_nm)
q_JCP_nm = previous_JCP.q_nm - offset_jcp_nm + 5
q_Hao_nm = landscape.q_nm - landscape_offset_nm
fig = FigureUtil._fig_single(y=6)
xlim, ylim = FigureUtil._limits(data_sliced)
ax1 = plt.subplot(2, 1, 1)
FigureUtil._plot_fec_list(data_sliced, **fmt)
FigureUtil._plot_fmt(ax1, **fmt)
ax2 = plt.subplot(2, 1, 2)
plt.plot(q_Hao_nm, G_hao, label="Aligned, IWT")
plt.plot(q_JCP_nm, G_JCP, 'r--', label="JCP landscape")
FigureUtil._plot_fmt(ax2,
ylabel="G (kcal/mol)",
is_bottom=True,
xlim=xlim,
ylim=[None, None])
PlotUtilities.legend(ax=ax2, handlelength=2)
ax2.set_xlim(fmt['xlim'])
PlotUtilities.savefig(fig, plot_dir + "FigureSX_LandscapeComparison.png")
def _fec_demo_plot(energy_list, out_dir):
fecs = []
energies = []
N = len(energy_list)
for e in energy_list:
data = RetinalUtil.read_fecs(e)
fecs.append(data)
energies.append(e)
n_cols = N
fig = PlotUtilities.figure((n_cols * 1, 6))
FigureUtil.data_plot(fecs, energies, xlim=[-20, 100])
PlotUtilities.savefig(fig,
out_dir + "energies.png",
subplots_adjust=dict(hspace=0.02, wspace=0.04))
def run():
"""
<Description>
Args:
param1: This is the first param.
Returns:
This is a description of what is returned.
"""
input_dir = "../../../Data/FECs180307/"
out_dir = "./"
force = True
q_interp, energy_list_arr, q_offset_nm,n_fecs = \
CheckpointUtilities.getCheckpoint("./cache.pkl",read_data,
force,input_dir)
G_no_peg = FigureUtil.read_non_peg_landscape()
#_giant_debugging_plot(out_dir, energy_list_arr)
base = out_dir + "FigureS6_LandscapeComparison"
kw_name_arr = [
[dict(add_annotations=True), base],
[dict(add_annotations=False), base + "_0"],
[dict(add_annotations=False, limit_plot=1), base + "_1"],
]
for kw, name in kw_name_arr:
fig = PlotUtilities.figure(figsize=(3, 3))
make_comparison_plot(q_interp, energy_list_arr, G_no_peg, **kw)
base = name
PlotUtilities.save_twice(fig, base + ".jpeg", base + ".svg")
def _heatmap_alignment(gs, alignment, col_idx):
xlim, ylim = FigureUtil._limits(alignment._all_fecs)
max_x = xlim[1]
bin_step_nm = 1
bin_step_pN = 5
bins_x = np.arange(xlim[0], xlim[1] + bin_step_nm, step=bin_step_nm)
bins_y = np.arange(ylim[0], ylim[1] + bin_step_pN, step=bin_step_pN)
common_kw = dict(separation_max=max_x,
use_colorbar=False,
title="",
bins=(bins_x, bins_y))
ax1 = plt.subplot(gs[0, col_idx])
FEC_Plot.heat_map_fec(alignment.zeroed.fec_list, **common_kw)
FigureUtil._plot_fmt(ax1, xlim, ylim, color=True)
ax2 = plt.subplot(gs[1, col_idx])
FEC_Plot.heat_map_fec(alignment.polished.fec_list, **common_kw)
FigureUtil._plot_fmt(ax2, xlim, ylim, color=True)
title_kw = dict(color='b', y=0.95, loc='left', fontsize=6)
downarrow = "$\Downarrow$"
title_sub = downarrow + " Subtract $X_{\mathbf{PEG3400}}(F)$ + " + \
"$L_{\mathbf{0,C-term}}$"
PlotUtilities.title(title_sub, **title_kw)
PlotUtilities.no_x_label(ax=ax2)
ax3 = plt.subplot(gs[2, col_idx])
FEC_Plot.heat_map_fec(alignment.blacklisted.fec_list, **common_kw)
FigureUtil._plot_fmt(ax3, xlim, ylim, is_bottom=True, color=True)
PlotUtilities.title(downarrow + " Remove poorly-fit FECs", **title_kw)
return [ax1, ax2, ax3]
def _giant_debugging_plot(out_dir, energy_list_arr):
fig = PlotUtilities.figure((8, 12))
gs = gridspec.GridSpec(nrows=2, ncols=1, hspace=0.15)
n_cols = max([len(list_v) for list_v in energy_list_arr])
for i, energy_list in enumerate(energy_list_arr):
fecs = []
energies = []
for e in energy_list:
data = RetinalUtil.read_fecs(e)
fecs.append(data)
energies.append(e)
gs_tmp = gridspec.GridSpecFromSubplotSpec(nrows=3,
ncols=n_cols,
subplot_spec=gs[i])
FigureUtil.data_plot(fecs, energies, gs1=gs_tmp, xlim=[-20, 100])
PlotUtilities.savefig(fig,
out_dir + "FigureS_Mega_Debug.png",
subplots_adjust=dict(hspace=0.02, wspace=0.04))
def _plot_comparison(plot_dir, heatmap_jcp, iwt_obj, data_sliced_plot):
fmt = dict(xlim=[-20, 55], ylim=[-20, 150])
_G0_plot(plot_dir, data_sliced_plot, iwt_obj, fmt=fmt)
fig = FigureUtil._fig_single(y=6)
ax1 = plt.subplot(2, 1, 1)
extent = heatmap_jcp._extent_nm_and_pN(offset_x_nm=0)
plt.imshow(heatmap_jcp.heatmap,
origin='lower',
aspect='auto',
extent=extent,
cmap=plt.cm.afmhot)
FigureUtil._plot_fmt(is_bottom=False, ax=ax1, **fmt)
PlotUtilities.title("Top: JCP.\n Bottom: New data, - PEG3400")
ax2 = plt.subplot(2, 1, 2)
FEC_Plot.heat_map_fec(data_sliced_plot,
use_colorbar=False,
num_bins=(150, 75),
separation_max=fmt['xlim'][1])
FigureUtil._plot_fmt(is_bottom=True, ax=ax2, **fmt)
out_name = plot_dir + "FigureSX_jcp_fec_comparison.png"
PlotUtilities.savefig(fig, out_name, tight=True)
def _make_work_plot(fec_list,x_arr,works_kcal,gs,col,color,title):
# get the interpolated work
x_interp, mean_W, std_W = _mean_work(x_arr, works_kcal)
# use Davids function
shift_david_nm_plot = 10
L0_david = 11e-9
max_david = L0_david * 0.95
x_david = np.linspace(0,max_david,num=100)
style_david = dict(color='b',linestyle='--',label="David")
legend_kw = dict(handlelength=1.5,handletextpad=0.3,fontsize=6)
david_F = _f_david(kbT=4.1e-21, L0=L0_david, Lp=0.4e-9, x=x_david)
david_W = _single_work(x=x_david,f=david_F)
x_david_plot = x_david * 1e9 - shift_david_nm_plot
W_david_plot = david_W * kcal_per_mol_per_J()
f_david_plot = david_F * 1e12
is_left = (col == 0)
fmt_kw = dict(is_left=is_left)
label_work = "$W$ (kcal/mol)"
# interpolate each work onto a grid
xlim, ylim, ylim_work = xlim_ylim()
fudge_work = max(std_W)
ax1 = plt.subplot(gs[0,col])
FigureUtil._plot_fec_list(fec_list,xlim,ylim)
plt.plot(x_david_plot,f_david_plot,**style_david)
if is_left:
PlotUtilities.legend(**legend_kw)
FigureUtil._plot_fmt(ax1, xlim, ylim,**fmt_kw)
PlotUtilities.title(title,color=color)
ax2 = plt.subplot(gs[1,col])
for x,w in zip(x_arr,works_kcal):
plt.plot(x * 1e9,w,linewidth=0.75)
FigureUtil._plot_fmt(ax2, xlim, ylim_work,ylabel=label_work,**fmt_kw)
ax3 = plt.subplot(gs[2,col])
_plot_mean_works(x_interp, mean_W, std_W, color, title)
style_lower_david = dict(**style_david)
if (not is_left):
style_lower_david['label'] = None
plt.plot(x_david_plot,W_david_plot,'b--',zorder=5,**style_lower_david)
PlotUtilities.legend(**legend_kw)
FigureUtil._plot_fmt(ax3, xlim, ylim_work,is_bottom=True,
ylabel=label_work,**fmt_kw)
def run():
"""
<Description>
Args:
param1: This is the first param.
Returns:
This is a description of what is returned.
"""
base_dir = "../../../../Data/FECs180307/"
read_f = FigureUtil.read_sample_landscapes
gallery = CheckpointUtilities.getCheckpoint("./caches.pkl",
read_f,False,base_dir)
lab_plot = [ ["BR-PEG3400",gallery.PEG3400],
["BO-PEG3400",gallery.BO_PEG3400] ]
fig = PlotUtilities.figure(figsize=(4,6))
gs = gridspec.GridSpec(ncols=1,nrows=2,height_ratios=[3,1])
gs_pipeline= gridspec.GridSpecFromSubplotSpec(ncols=2,nrows=3,hspace=0.03,
subplot_spec=gs[0,:])
colors = ['r','rebeccapurple']
xlim,_,ylm_W = xlim_ylim()
mean_works_info = []
for i,(label,to_use) in enumerate(lab_plot):
pipeline = FigureUtil._alignment_pipeline(to_use)
fecs = pipeline.blacklisted.fec_list
# calculate all the works
x_arr = [f.Separation for f in fecs]
f_arr = [f.Force for f in fecs]
works = _calculate_work(x_arr,f_arr)
works_kcal = np.array(works) * kcal_per_mol_per_J()
c = colors[i]
_make_work_plot(fecs, x_arr, works_kcal,gs_pipeline,col=i,color=c,
title=label)
x_interp, mean_W, std_W= _mean_work(x_arr,works_kcal)
plt.subplot(gs[-1, :])
_plot_mean_works(x_interp, mean_W, std_W, color=c, title=label)
plt.xlim(xlim)
plt.ylim(ylm_W)
PlotUtilities.lazyLabel("Extension (nm)" , "$W$ (kcal/mol)","",
useLegend=False)
PlotUtilities.savefig(fig, "FigureS_Work.png".format(label))
def _make_plots(galleries_labels):
alignments = [
FigureUtil._alignment_pipeline(gallery_tmp[0])
for gallery_tmp in galleries_labels
]
for i, (_, label) in enumerate(galleries_labels):
# make the standard aligning plot
alignment = alignments[i]
_make_algned_plot(alignment, label)
# plot the final curves on the same plot
xlim, ylim = FigureUtil._limits(alignment._all_fecs)
colors = ['rebeccapurple', 'g']
fig = PlotUtilities.figure((5, 3))
gs = gridspec.GridSpec(2, 2)
# reverse everything, so PEG600 is on top
galleries_labels = galleries_labels[::-1]
alignments = alignments[::-1]
for i, (_, l) in enumerate(galleries_labels):
ax = plt.subplot(gs[i, 0])
a = alignments[i]
FigureUtil._plot_fec_list(a.blacklisted.fec_list,
xlim,
ylim,
label=l,
color=colors[i])
if (i == 0):
PlotUtilities.no_x_label(ax)
PlotUtilities.xlabel("", ax=ax)
# plot them both on the last column
plt.subplot(gs[:, 1])
kw = [dict(), dict(linewidth=0.6)]
for i, (_, l) in enumerate(galleries_labels):
a = alignments[i]
FigureUtil._plot_fec_list(a.blacklisted.fec_list,
xlim,
ylim,
label=l,
color=colors[i],
**kw[i])
PlotUtilities.savefig(fig, "FigureS_3400vs600.png")
def _ensemble_alignment(gs, alignment, col_idx):
xlim, ylim = FigureUtil._limits(alignment._all_fecs)
common_kw = dict(xlim=xlim, ylim=ylim)
kw_fmt = dict(color=False, is_left=(col_idx == 0), **common_kw)
ax1 = plt.subplot(gs[0, col_idx])
FigureUtil._plot_fec_list(alignment.zeroed.fec_list, **common_kw)
FigureUtil._plot_fmt(ax1, **kw_fmt)
ax2 = plt.subplot(gs[1, col_idx])
FigureUtil._plot_fec_list(alignment.polished.fec_list, **common_kw)
FigureUtil._plot_fmt(ax2, **kw_fmt)
PlotUtilities.no_x_label(ax=ax2)
ax3 = plt.subplot(gs[2, col_idx])
FigureUtil._plot_fec_list(alignment.blacklisted.fec_list, **common_kw)
FigureUtil._plot_fmt(ax3, is_bottom=True, **kw_fmt)
def make_retinal_subplot(gs,
energy_list_arr,
shifts,
skip_arrow=True,
limit_plot=None):
q_interp_nm = energy_list_arr[0].q_nm
means = [e.G0_kcal_per_mol for e in energy_list_arr]
# fit a second order polynomial and subtract from each point
q_fit_nm_relative = 7
max_fit_idx = \
np.argmin(np.abs((q_interp_nm - q_interp_nm[0]) - q_fit_nm_relative))
fits = []
fit_pred_arr = []
for m in means:
fit = np.polyfit(x=q_interp_nm[:max_fit_idx], y=m[:max_fit_idx], deg=2)
fits.append(fit)
fit_pred = np.polyval(fit, x=q_interp_nm)
fit_pred_arr.append(fit_pred)
stdevs = [e.G_err_kcal for e in energy_list_arr]
ax1 = plt.subplot(gs[0])
common_error = dict(capsize=0)
style_dicts = [
dict(color=FigureUtil.color_BR(), label=r"with retinal"),
dict(color=FigureUtil.color_BO(), label=r"w/o retinal")
]
markers = ['v', 'x']
deltas, deltas_std = [], []
delta_styles = [
dict(color=style_dicts[i]['color'],
markersize=5,
linestyle='None',
marker=markers[i],
**common_error) for i in range(len(energy_list_arr))
]
xlim = [None, 27]
ylim = [-25, 450]
q_arr = []
round_energy = -1
max_q_nm = max(q_interp_nm)
# add the 'shifted' energies
for i, (mean,
stdev) in enumerate(zip(means[:limit_plot], stdevs[:limit_plot])):
tmp_style = style_dicts[i]
style_fit = dict(**tmp_style)
style_fit['linestyle'] = '--'
style_fit['label'] = None
corrected = mean - fit_pred_arr[i]
plt.plot(q_interp_nm, mean, **tmp_style)
plt.fill_between(x=q_interp_nm,
y1=mean - stdev,
y2=mean + stdev,
color=tmp_style['color'],
linewidth=0,
alpha=0.3)
energy_error = np.mean(stdev)
max_idx = -1
q_at_max_energy = q_interp_nm[max_idx]
max_energy_mean = corrected[max_idx]
# for the error, use the mean error over all interpolation
max_energy_std = energy_error
deltas.append(max_energy_mean)
deltas_std.append(max_energy_std)
q_arr.append(q_at_max_energy)
plt.xlim(xlim)
plt.ylim(ylim)
PlotUtilities.lazyLabel("Extension (nm)", "$\mathbf{\Delta}G$ (kcal/mol)",
"")
leg = PlotUtilities.legend(loc='lower right')
colors_leg = [s['color'] for s in style_dicts]
PlotUtilities.color_legend_items(leg, colors=colors_leg[:limit_plot])
return ax1, means, stdevs
def make_comparison_plot(q_interp,
energy_list_arr,
G_no_peg,
add_annotations,
limit_plot=None):
landscpes_with_error = \
FigureUtil._get_error_landscapes(q_interp, energy_list_arr)
# get the extension grid we wnt...
ext_grid = np.linspace(0, 25, num=100)
# read in Hao's energy landscape
fec_system = WLC._make_plot_inf(ext_grid, WLC.read_haos_data)
shifts = [fec_system.W_at_f(f) for f in [249, 149]]
gs = gridspec.GridSpec(nrows=1, ncols=1)
ax1, means, stdevs = \
make_retinal_subplot(gs,landscpes_with_error,shifts,
limit_plot=limit_plot)
# get the with-retinal max
ax1 = plt.subplot(gs[0])
# get the max of the last point (the retinal energy landscape is greater)
offsets = [l.G0_kcal_per_mol[-1] for l in landscpes_with_error]
q_no_PEG_start = max(q_interp)
q_nm_no_PEG = G_no_peg.q_nm + q_no_PEG_start
G_err_kcal_no_PEG = G_no_peg.G_err_kcal
for i, G_offset in enumerate(offsets[:limit_plot]):
G_kcal = G_no_peg.G0_kcal_per_mol + G_offset
mean_err = np.mean(G_err_kcal_no_PEG)
idx_errorbar = q_nm_no_PEG.size // 2
common_style = dict(color='grey', linewidth=1.5)
ax1.plot(q_nm_no_PEG, G_kcal, linestyle='--', **common_style)
if (i != 0):
continue
ax1.errorbar(q_nm_no_PEG[idx_errorbar],
G_kcal[idx_errorbar],
yerr=mean_err,
marker=None,
markersize=0,
capsize=3,
**common_style)
axes = [ax1]
ylim = [None,
np.max(offsets) + max(G_no_peg.G0_kcal_per_mol) + \
G_err_kcal_no_PEG[-1]*4]
for a in axes:
a.set_ylim(ylim)
a.set_xlim([None, max(q_nm_no_PEG)])
# add in the scale bar
ax = axes[0]
xlim = ax.get_xlim()
ylim = ax.get_ylim()
y_range = (ylim[1] - ylim[0])
range_scale_kcal = np.round(y_range / 3, -2)
x_range_scalebar_nm = 20
min_offset, _, rel_delta = Scalebar. \
offsets_zero_tick(limits=ylim,range_scalebar=range_scale_kcal)
min_offset_x, _, rel_delta_x= Scalebar. \
offsets_zero_tick(limits=xlim,range_scalebar=x_range_scalebar_nm)
offset_x = 0.25
offset_y = min_offset + 1 * rel_delta
common_kw = dict(add_minor=True)
scalebar_kw = dict(offset_x=offset_x,
offset_y=offset_y,
ax=ax,
x_on_top=True,
y_on_right=False,
x_kwargs=dict(width=x_range_scalebar_nm,
unit="nm",
**common_kw),
y_kwargs=dict(height=range_scale_kcal,
unit="kcal/mol",
**common_kw))
PlotUtilities.no_x_label(ax=ax)
PlotUtilities.no_y_label(ax=ax)
Scalebar.crossed_x_and_y_relative(**scalebar_kw)
# add the helical boxes
offset_boxes_nm = -25
FigureUtil.add_helical_boxes(ax=ax1,
ymax_box=0.97,
box_height=0.07,
constant_offset=offset_boxes_nm,
clip_on=True)
delta_delta_G_total = np.abs(np.diff(offsets))[0]
delta_delta_G_linker = np.abs(np.diff(shifts))[0]
if add_annotations:
str_text = " $\mathbf{\Delta\Delta}G_{\mathbf{Total}}$"
min_o = min(offsets)
xy = q_no_PEG_start, min_o
xy_end = q_no_PEG_start, min_o + delta_delta_G_total
labelled_arrow(ax1, str_text, xy, xy_end)
str_dd = " $\mathbf{\Delta\Delta}G_{\mathbf{Linker}}$"
xlim = plt.xlim()
x_range = (xlim[1] - xlim[0])
x0 = np.mean(xlim) + x_range * 0.05
y0 = min_o
y1 = min_o + delta_delta_G_linker
xy2 = x0, y0
xy_end2 = x0, y1
labelled_arrow(ax1,
str_dd,
xy2,
xy_end2,
color_arrow='r',
y_text_fudge=0.0)
# # save out the data
preamble = "FigureS6"
X = np.array([delta_delta_G_total, delta_delta_G_linker]).reshape((1, -1))
np.savetxt(fname=preamble + "_ddG.csv",
X=X,
fmt=["%.1f", "%.1f"],
delimiter=",",
header="ddG_total (kcal/mol), ddG_linker (kcal/mol)")
# save out the landscapes
x_y_yerr_name = [[q_interp, landscpes_with_error[0], preamble + "_BR"],
[q_interp, landscpes_with_error[1], preamble + "_BO"]]
for x, l, name in x_y_yerr_name:
y = l.G0_kcal_per_mol
yerr = l.G_err_kcal
Record.save_csv(
dict(x=x,
y=[y, yerr],
save_name=name,
x_name="q",
x_units="nm",
y_name=["Energy", "Energy Error"],
y_units="kcal/mol"))
# save out the remainder of the BO
G_kcal_PEG_tmp = G_no_peg.G0_kcal_per_mol + max(offsets)
Record.save_csv(
dict(x=q_nm_no_PEG,
y=[G_kcal_PEG_tmp, G_err_kcal_no_PEG],
save_name=preamble + "_JCP_no_PEG",
x_name="q",
x_units="nm",
y_name=["Energy", "Energy Error"],
y_units="kcal/mol"))