def plot_replica_grid_with_colors(dataset, xlabel, ylabel, title, annotations,
coloridxs, grid_dims, saveas, saveas_formats=["png","pdf"], display=False, y_ticks=None):
""" Plot replica observables with their replica average NOT DONE"""
cwd = os.getcwd()
parent_dirs = dataset.parent_dirs
sub_dirs = dataset.sub_dirs
n_dirs = len(parent_dirs)
all_interp_points, all_rep_avg_data, all_min_max = get_replica_average(dataset)
fig, axes = plt.subplots(grid_dims[0], grid_dims[1], sharex=True, sharey=True)
counter = 0
for i in range(n_dirs):
Plot individual replicas
rep_bins, rep_data = get_replicas(dataset, i)
ax = axes[counter / grid_dims[1], counter % grid_dims[1]]
for rep_idx in range(len(rep_bins)):
ax.plot(rep_bins[rep_idx], rep_data[rep_idx], color=cubecmap(coloridxs[i]), alpha=0.3)
# Plot bold replica average
ax.plot(all_interp_points[i], all_rep_avg_data[i], lw=3, color=cubecmap(coloridxs[i]))
counter += 1
if y_ticks is not None:
ax.set_yticks(y_ticks)
ax.set_ylim(y_ticks[0],y_ticks[-1])
ax.annotate("%s" % annotations[i], xy=(0.5, 0.5), xytext=dataset.xytext,
xycoords="axes fraction", textcoords="axes fraction")
def plot_Fvsx_variance_gridplot(myroot,
parent_dirs,
sub_dirs,
variance,
Fprofiles,
Fmid_bins,
coloridx,
name,
coordname,
display=True,
nrows=3,
ncols=4):
"""Gridplot free energy profiles with average profile in bold """
if not display:
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
from plotter.cube_cmap import cubecmap
from scipy.interpolate import interp1d
fig1, axes = plt.subplots(nrows, ncols, sharex=True, sharey=True)
counter = 0
Finterp_all = []
for i in range(len(parent_dirs)):
Finterp_rep = []
xall = []
i_idx = counter / 4
j_idx = counter % 4
ax = axes[i_idx, j_idx]
for j in range(len(sub_dirs)):
Fvsx = Fprofiles[i][j]
mid_bin = Fmid_bins[i][j]
ax.plot(mid_bin, Fvsx, color=cubecmap(coloridx[i]), alpha=0.2)
Finterp = interp1d(mid_bin, Fvsx, kind="cubic")
Finterp_rep.append(Finterp)
xall.append(mid_bin)
Finterp_all.append(Finterp_rep)
ax.text(mid_bin.max() * 0.3, 3.2, "$b^2 = %s$" % variance[i])
qmax = min([max(xall[x]) for x in range(len(xall))])
qmin = max([min(xall[x]) for x in range(len(xall))])
q = np.linspace(qmin, qmax, 100)
Favg = np.mean(np.array(
[Finterp_rep[x](q) for x in range(len(Finterp_rep))]),
axis=0)
#ax.plot(q,Favg,color="#5DA5DA")
ax.plot(q, Favg, color=cubecmap(coloridx[i]), lw=3)
ax.set_ylim(0, 4)
counter += 1
axes[1, 0].set_ylabel("Free energy F(Q) (k$_B$T)")
axes[2, 1].set_xlabel("Folding Q")
fig1.suptitle("Free energy curves %s" % name, fontsize=18)
fig1.subplots_adjust(hspace=0, wspace=0)
if not os.path.exists("plots"):
os.mkdir("plots")
fig1.savefig("plots/all_b2_profiles_%s.png" % coordname)
def plot_contact_fluctuations_vs_Q(coord_label, native_pairs, nonnative_pairs,
Qbins, Qi_vs_Q, dQi2_vs_Q, A_vs_Q,
Amax_vs_Q, dA2_vs_Q, Ai_vs_Q, dAi2_vs_Q,
no_display):
n_nat = len(native_pairs)
nat_loops = (native_pairs[:, 1] - native_pairs[:, 0]).astype(float)
nat_coloring = [
(nat_loops[i] - min(nat_loops)) / (max(nat_loops) - min(nat_loops))
for i in range(n_nat)
]
n_nnat = len(nonnative_pairs)
nnat_loops = (nonnative_pairs[:, 1] - nonnative_pairs[:, 0]).astype(float)
nnat_coloring = [
(nnat_loops[i] - min(nnat_loops)) / (max(nnat_loops) - min(nnat_loops))
for i in range(n_nnat)
]
plt.figure()
for i in range(n_nat):
plt.plot(Qbins, Qi_vs_Q[:, i], color=cubecmap(nat_coloring[i]))
label_and_save(coord_label, "$\langle Q_i \\rangle$",
"Native contact formation", "Qivscoord")
plt.figure()
for i in range(n_nat):
plt.plot(Qbins, dQi2_vs_Q[:, i], color=cubecmap(nat_coloring[i]))
label_and_save(coord_label, "$\langle Q_i^2 \\rangle$",
"Native contact fluctuations", "dQi2vscoord")
plt.figure()
plt.plot(Qbins, A_vs_Q)
label_and_save(coord_label, "$\langle A \\rangle$",
"Average non-native contacts", "Avscoord")
plt.figure()
plt.plot(Qbins, Amax_vs_Q)
label_and_save(coord_label, "max$\left( A \\right)$",
"Max non-native contacts", "Amaxvscoord")
plt.figure()
plt.plot(Qbins, dA2_vs_Q)
label_and_save(coord_label, "$\langle\delta A^2 \\rangle$",
"Non-native contact fluctuations", "dA2vscoord")
plt.figure()
for i in range(n_nnat):
plt.plot(Qbins, Ai_vs_Q[:, i], color=cubecmap(nnat_coloring[i]))
label_and_save(coord_label, "$\langle A_i \\rangle$",
"Non-native contacts", "Aivscoord")
plt.figure()
for i in range(n_nnat):
plt.plot(Qbins, dAi2_vs_Q[:, i], color=cubecmap(nnat_coloring[i]))
label_and_save(coord_label, "$\langle\delta A_i^2 \\rangle$",
"Non-native contact fluctuations", "dAi2vscoord")
if not no_display:
plt.show()
def compute_free_energy_profiles_vs_T(coordinate,coordmin,coordmax,dcoord,tempsfile):
"""Compute potential of mean force along a coordinate as a function of temperature"""
bin_edges = np.arange(coordmin,coordmax + dcoord,dcoord)
bin_centers = 0.5*(bin_edges[1:] + bin_edges[:-1])
dirs = [ x.rstrip("\n") for x in open(tempsfile,"r").readlines() ]
unique_Tlist, sorted_dirs = get_unique_Tlist(dirs)
print "Loading u_kn"
wantT, sub_indices, E, u_kn, N_k = get_ukn(unique_Tlist,sorted_dirs)
beta = np.array([ 1./(kb*x) for x in wantT ])
print "solving mbar"
mbar = pymbar.MBAR(u_kn,N_k)
# Compute bin expectations at all temperatures. Free energy profile.
print "computing expectations"
A_indicators = get_binned_observables(bin_edges,coordinate,sorted_dirs,sub_indices)
coordname = coordinate.split(".")[0]
if not os.path.exists("pymbar_%s" % coordname):
os.mkdir("pymbar_%s" % coordname)
os.chdir("pymbar_%s" % coordname)
Tndxs = np.argsort(wantT)
sortT = wantT[Tndxs]
np.savetxt("outputT",wantT[Tndxs])
np.savetxt("bin_edges",bin_edges)
np.savetxt("bin_centers",bin_centers)
plt.figure()
# Compute pmf at each temperature.
for i in range(len(wantT)):
Tstr = "%.2f" % wantT[Tndxs[i]]
#x = (max(sortT) - sortT[i])/(max(sortT) - min(sortT)) # Reverse color ordering
x = (sortT[i] - min(sortT))/(max(sortT) - min(sortT)) # Color from blue to red
A_ind_avg, dA_ind_avg, d2A_ind_avg = mbar.computeMultipleExpectations(A_indicators,u_kn[Tndxs[i],:])
pmf = -np.log(A_ind_avg)
min_pmf = min(pmf)
pmf -= min_pmf
pmf_err_lower = -np.log(A_ind_avg - dA_ind_avg) - min_pmf
pmf_err_upper = -np.log(A_ind_avg + dA_ind_avg) - min_pmf
np.savetxt("free_%s" % Tstr, np.array([pmf,pmf_err_lower,pmf_err_upper]).T)
plt.plot(bin_centers,pmf,lw=2,label=Tstr,color=cubecmap(x))
plt.xlabel("%s" % coordname,fontsize=18)
plt.ylabel("F(%s)" % coordname,fontsize=18)
plt.savefig("Fvs%s_all.png" % coordname)
plt.savefig("Fvs%s_all.pdf" % coordname)
plt.savefig("Fvs%s_all.eps" % coordname)
os.chdir("..")
def plot_Fvsx_variance_gridplot(myroot,parent_dirs,sub_dirs,variance,Fprofiles,Fmid_bins,coloridx,name,coordname,display=True,nrows=3,ncols=4):
"""Gridplot free energy profiles with average profile in bold """
if not display:
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
from plotter.cube_cmap import cubecmap
from scipy.interpolate import interp1d
fig1,axes = plt.subplots(nrows,ncols,sharex=True,sharey=True)
counter = 0
Finterp_all = []
for i in range(len(parent_dirs)):
Finterp_rep = []
xall = []
i_idx = counter / 4
j_idx = counter % 4
ax = axes[i_idx,j_idx]
for j in range(len(sub_dirs)):
Fvsx = Fprofiles[i][j]
mid_bin = Fmid_bins[i][j]
ax.plot(mid_bin,Fvsx,color=cubecmap(coloridx[i]),alpha=0.2)
Finterp = interp1d(mid_bin,Fvsx,kind="cubic")
Finterp_rep.append(Finterp)
xall.append(mid_bin)
Finterp_all.append(Finterp_rep)
ax.text(mid_bin.max()*0.3,3.2,"$b^2 = %s$" % variance[i])
qmax = min([ max(xall[x]) for x in range(len(xall)) ])
qmin = max([ min(xall[x]) for x in range(len(xall)) ])
q = np.linspace(qmin,qmax,100)
Favg = np.mean(np.array([ Finterp_rep[x](q) for x in range(len(Finterp_rep)) ]),axis=0)
#ax.plot(q,Favg,color="#5DA5DA")
ax.plot(q,Favg,color=cubecmap(coloridx[i]),lw=3)
ax.set_ylim(0,4)
counter += 1
axes[1,0].set_ylabel("Free energy F(Q) (k$_B$T)")
axes[2,1].set_xlabel("Folding Q")
fig1.suptitle("Free energy curves %s" % name,fontsize=18)
fig1.subplots_adjust(hspace=0,wspace=0)
if not os.path.exists("plots"):
os.mkdir("plots")
fig1.savefig("plots/all_b2_profiles_%s.png" % coordname)
def plot_protein_grid(names, datasets, xlabel, ylabel, title, coloridxs,
saveas, save_formats=["png","pdf"], display=False, x_ticks=None, y_ticks=None, aspect_equal=None):
"""Plot all proteins on one grid"""
fig, axes = plt.subplots(1, len(names), sharey=True, figsize=(13,4.))
cwd = os.getcwd()
state_markers = ["o","s",">"]
for n in range(len(names)):
dataset = datasets[n]
coloridx = coloridxs[n]
name = names[n]
os.chdir(name)
all_interp_points, all_rep_avg_data, all_min_max = get_replica_average(dataset)
os.chdir("..")
ax = axes[n]
# Loop over variances
for i in range(len(all_rep_avg_data)):
avg_data = all_rep_avg_data[i]
interp_points = all_interp_points[i]
ax.plot(interp_points, avg_data, color=cubecmap(coloridx[i]))
# Indicate location of minima, maxima
for s in range(len(all_min_max[i])):
temp = (interp_points - all_min_max[i][s])**2
state = np.where(temp == temp.min())[0]
ax.plot(interp_points[state], avg_data[state],
marker=state_markers[s], ms=8, color=cubecmap(coloridx[i]))
if hasattr(dataset,"ylim"):
ax.set_ylim(*dataset.ylim)
ax.annotate(name, xy=(0.5, 0.5), xytext=(0.05,0.92), fontsize=20,
xycoords="axes fraction", textcoords="axes fraction")
if aspect_equal:
ax.set_aspect('equal', 'datalim')
if y_ticks is not None:
ax.set_yticks(y_ticks)
ax.set_ylim(y_ticks[0],y_ticks[-1])
if x_ticks is not None:
ax.set_xticks(x_ticks)
ax.set_xlim(x_ticks[0],x_ticks[-1])
# Rotate ticklabels.
for j in range(len(axes)):
plt.setp(axes[j].xaxis.get_majorticklabels(), rotation=270)
# common xlabel/ylabel and title
big_ax = fig.add_subplot(111)
big_ax.grid(False)
big_ax.set_axis_bgcolor('none')
big_ax.tick_params(labelcolor='none', top='off', bottom='off', left='off', right='off')
#big_ax.set_ylabel(ylabel)
big_ax.text(-.085, 0.9, ylabel, rotation="vertical", fontsize=16, transform=big_ax.transAxes)
big_ax.set_xlabel(xlabel)
fig.suptitle(title,fontsize=20)
fig.subplots_adjust(hspace=0,wspace=0)
if not os.path.exists("plots"):
os.mkdir("plots")
os.chdir("plots")
# save figures
for format in save_formats:
fig.savefig("%s.%s" % (saveas,format), bbox_inches="tight")
if display:
plt.show()
os.chdir("..")
def plot_replica_average(dataset, xlabel, ylabel, title, annotations, coloridx, display=False):
""" Plot replica averaged observable"""
cwd = os.getcwd()
ninterp = 500
parent_dirs = dataset.parent_dirs
sub_dirs = dataset.sub_dirs
sqr_num = int(np.ceil(np.sqrt(float(len(parent_dirs)))))
fig1, axes = plt.subplots(sqr_num, sqr_num, sharex=True, sharey=True)
counter = 0
# Plot replica averaged quantity
all_interp_points, all_rep_avg_data, all_min_max = get_replica_average(dataset)
# Plot replica averaged curves in a grid.
for i in range(len(parent_dirs)):
interp_points = all_interp_points[i]
rep_avg_data = all_rep_avg_data[i]
ax = axes[counter / sqr_num, counter % sqr_num]
if hasattr(dataset, "plot_rep_avg"):
dataset.plot_rep_avg(ax, interp_points, rep_avg_data)
else:
ax.plot(interp_points, rep_avg_data, color=cubecmap(coloridx[i]))
if hasattr(dataset,"ylim"):
ax.set_ylim(*dataset.ylim)
ax.annotate("%s" % annotations[i], xy=(0.5, 0.5), xytext=dataset.xytext,
xycoords="axes fraction", textcoords="axes fraction")
counter += 1
# Plot average position of basins.
counter = 0
for i in range(len(parent_dirs)):
y0,y1 = ax.get_ylim()
ax = axes[counter / sqr_num, counter % sqr_num]
ax.fill_between(np.array([all_min_max[i][0] - 5, all_min_max[i][0] + 5]),y0,y1,alpha=0.5,color='#5DA5DA')
ax.fill_between(np.array([all_min_max[i][1] - 5, all_min_max[i][1] + 5]),y0,y1,alpha=0.5,color='#5DA5DA')
ax.fill_between(np.array([all_min_max[i][1] - 5, all_min_max[i][2] + 5]),y0,y1,alpha=0.5,color='#5DA5DA')
counter += 1
# Rotate ticklabels.
for j in range(axes.shape[1]):
plt.setp(axes[-1,j].xaxis.get_majorticklabels(), rotation=270)
# common xlabel/ylabel and title
big_ax = fig1.add_subplot(111)
big_ax.grid(False)
big_ax.set_axis_bgcolor('none')
big_ax.tick_params(labelcolor='none', top='off', bottom='off', left='off', right='off')
big_ax.set_ylabel(ylabel)
big_ax.set_xlabel(xlabel)
big_ax.set_title(title)
fig1.subplots_adjust(hspace=0,wspace=0)
# plot together on one axis as well.
if dataset.dimension == 1:
fig2,ax2 = plt.subplots(1,1)
for i in range(len(parent_dirs)):
avg_data = all_rep_avg_data[i]
interp_points = all_interp_points[i]
ax2.plot(interp_points, avg_data, color=cubecmap(coloridx[i]),label=annotations[i])
tempU = (interp_points - all_min_max[i][0])**2
U = np.where(tempU == tempU.min())[0]
ax2.plot(interp_points[U], avg_data[U], marker='o', ms=8, color=cubecmap(coloridx[i]))
tempTS = (interp_points - all_min_max[i][1])**2
TS = np.where(tempTS == tempTS.min())[0]
ax2.plot(interp_points[TS], avg_data[TS], marker='s', ms=8, color=cubecmap(coloridx[i]))
tempN = (interp_points - all_min_max[i][2])**2
N = np.where(tempN == tempN.min())[0]
ax2.plot(interp_points[N], avg_data[N], marker='>', ms=8, color=cubecmap(coloridx[i]))
if hasattr(dataset,"ylim"):
ax2.set_ylim(*dataset.ylim)
box = ax2.get_position()
ax2.set_position([box.x0, box.y0, box.width*0.8, box.height])
ax2.legend(loc='center left', bbox_to_anchor=(1, 0.5))
ax2.set_ylabel(ylabel)
ax2.set_xlabel(xlabel)
ax2.set_title(title)
# save figure
os.chdir(cwd)
if not os.path.exists("plots"):
os.mkdir("plots")
os.chdir("plots")
for format in dataset.save_formats:
fig1.savefig("%s.%s" % (dataset.saveas,format),bbox_inches="tight")
if dataset.dimension == 1:
fig2.savefig("one_%s.%s" % (dataset.saveas,format),bbox_inches="tight")
if display:
plt.show()
plt.close(fig1)
