def get_contacts_file(pdbIN, selection_string, selection, dist_file):
import MDAnalysis
from MDAnalysis.analysis import contacts
u = MDAnalysis.Universe(pdbIN + "_COM.pdb")
#select protein molecule
protein = u.select_atoms(selection_string)
# resid square array
residArray = square_matrix_tuple(protein.resids, [('r1', 'i'),
('r2', 'i')])
# resname square array
resnameArray = square_matrix_tuple(convert3to1(protein.resnames),
[('r1', 'S10'), ('r2', 'S10')])
#
cutoff = get_custom_matrix(dist_file, resnameArray, len(protein.resnames))
# contacts routine
ca1 = contacts.Contacts(u,
selection=(selection_string, selection_string),
refgroup=(protein, protein),
radius=cutoff)
# initial contact list
initial_contacts_resid = residArray[ca1.initial_contacts]
# initial distance list
distance_contacts_resid = ca1.r0[0][ca1.initial_contacts]
# initial resname list
resname_contacts_resid = resnameArray[ca1.initial_contacts]
cutoff_array = cutoff[ca1.initial_contacts]
# write the native contacts found.
write_contact_file(initial_contacts_resid, distance_contacts_resid,
resname_contacts_resid, pdbIN, selection, cutoff_array)
def _run_Contacts(self, **kwargs):
acidic = self.universe.select_atoms(self.sel_acidic)
basic = self.universe.select_atoms(self.sel_basic)
return contacts.Contacts(self.universe,
selection=(self.sel_acidic, self.sel_basic),
refgroup=(acidic, basic),
radius=6.0,
**kwargs).run()
def _run_Contacts(self, universe, start=None, stop=None, step=None, **kwargs):
acidic = universe.select_atoms(self.sel_acidic)
basic = universe.select_atoms(self.sel_basic)
return contacts.Contacts(
universe,
select=(self.sel_acidic, self.sel_basic),
refgroup=(acidic, basic),
radius=6.0,
**kwargs).run(start=start, stop=stop, step=step)
def test_distance_box(self, pbc, expected):
u = mda.Universe(TPR, XTC)
sel_basic = "(resname ARG LYS)"
sel_acidic = "(resname ASP GLU)"
acidic = u.select_atoms(sel_acidic)
basic = u.select_atoms(sel_basic)
r = contacts.Contacts(u, select=(sel_acidic, sel_basic),
refgroup=(acidic, basic), radius=6.0, pbc=pbc)
r.run()
assert_array_almost_equal(r.timeseries[:, 1], expected)
def test_villin_unfolded(self):
# both folded
f = mda.Universe(contacts_villin_folded)
u = mda.Universe(contacts_villin_folded)
sel = "protein and not name H*"
grF = f.select_atoms(sel)
q = contacts.Contacts(u,
select=(sel, sel),
refgroup=(grF, grF),
method="soft_cut")
q.run()
results = soft_cut(f, u, sel, sel)
assert_almost_equal(q.timeseries[:, 1], results[:, 1])
sel_1 = "segid AP1"
sel_2 = "segid AP2"
selection_1 = u.select_atoms(sel_1)
selection_2 = u.select_atoms(sel_2)
#print selection_1
#print selection_2
#q1q2 = contacts.q1q2(u, selection=(sel_1, sel_2), radius=6)
#q1q2.run()
#ca1 = contacts.Contacts(u, selection=(sel_1, sel_2), refgroup=(selection_1, selection_2), radius=6.0)
ca1 = contacts.Contacts(u,
selection=(sel_1, sel_2),
refgroup=(selection_1, selection_2),
radius=6.0,
start=0,
stop=1001)
ca1.run()
#f, ax = plt.subplots(1, 2, figsize=plt.figaspect(0.5))
#ax[0].plot(q1q2.timeseries[:, 0], q1q2.timeseries[:, 1], label='q1')
#ax[0].plot(q1q2.timeseries[:, 0], q1q2.timeseries[:, 2], label='q2')
#ax[0].legend(loc='best')
#ax[1].plot(q1q2.timeseries[:, 1], q1q2.timeseries[:, 2], '.-')
average_contacts = numpy.mean(ca1.timeseries[:, 1])
print('average contacts = {}'.format(average_contacts))
f, ax = plt.subplots()
t_ref = mda.Universe('begin.pdb', top='begin.pdb')
group1 = t_ref.select_atoms('segid A and (name C* or name N* or name O* or name S*)')
num_walkers = 16
for en in range(num_walkers):
for it in range(81, 85):
dirname = 'iter.%06d/00.enhcMD/%03d/' % (it, en)
os.system('cp begin.pdb md-nosol.tpr trj.sh index_p.ndx %s' % dirname)
os.chdir(dirname)
os.system('sh trj.sh')
trjname = 'md_done.xtc'
u = mda.Universe("begin.pdb", trjname)
filename = 'Q_heavyatoms.cs'
wf = open(filename, 'w')
sel2 = 'segid B and (name C* or name N* or name O* or name S*)'
group2 = t_ref.select_atoms(sel2)
nc = contacts.Contacts(u, selection=("segid A and (name C* or name N* or name O* or name S*)", sel2),
refgroup=(group1, group2), method='soft_cut')
nc.run()
bound = nc.timeseries[:, 1]
for b in bound:
wf.write(str(b) + '\n')
wf.close()
os.chdir('/home/dongdong/SCR/pdz.run02')
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.font_manager as font_manager
import os
font_path = '/home/dongdong/tigress/calibribold.ttf'
font_prop = font_manager.FontProperties(fname=font_path, size=16)
leg_prop = font_manager.FontProperties(fname=font_path, size=10)
def native_contacts(gro_list, traj_list, num_proteins, N_resid):
c_pal = ['#225ea8', '#41b6c4', '#c7e9b4']
ax = plt.subplot(111)
ax.set(xlabel='Frame',
ylabel='% of Native Contacts',
title='Native Contacts')
ax.set_ylim([0, 100])
if len(gro_list) == 1:
compare = False
u = mda.Universe(gro_list[0], traj_list[0])
protein_length = len(u.select_atoms("protein and name CA"))
print u
print protein_length
#for frame in u.trajectory:
# print u.trajectory[frame].time
print "One universe loaded..."
# Initialise dicts, first for each protein, second for the residues you wish to calc the Native Conts for.
protein_dict = {}
protein_res_to_calc_dict = {}
regions_for_NC_analysis = {}
# Get protein information and store in dictionaries
for j in range(num_proteins):
print "j = ", j
if j == 0:
start = ((j * (protein_length / num_proteins)) + 1)
end = (j * (protein_length / num_proteins)) + N_resid
print "start and end = ", start, end
protein_dict["p" + str(j)] = u.select_atoms("resid " + str(1) +
":" + str(N_resid))
protein_res_to_calc_dict["p" + str(j) + "res"] = {}
protein_res_to_calc_dict["p" + str(j) +
"res"]["sel"] = u.select_atoms(
"(resid " + str(1) + ":" +
str(N_resid) +
") and (not name CA N O H*)")
print protein_res_to_calc_dict["p" + str(j) +
"res"]["sel"].resnames
print protein_res_to_calc_dict["p" + str(j) +
"res"]["sel"].resids
# print protein_res_to_calc_dict
# store the string used to select this part of the protein for future use
protein_res_to_calc_dict["p" + str(j) +
"res"]["sel_string"] = "resid " + str(
1) + ":" + str(N_resid)
j += 1
elif j >= 1:
# make sure you're in the right place for the next protein
# print "one protein length", protein_length / num_proteins
# print "num proteins", num_proteins
# print "n resid", N_resid
start = (j * (protein_length / num_proteins)) + 1
end = (j * (protein_length / num_proteins)) + N_resid
print "protein length = ", protein_length
print "num prots = ", num_proteins
print "start and end = ", start, end
protein_res_to_calc_dict["p" + str(j) + "res"] = {}
# populate dicts
protein_dict["p" +
str(j)] = u.select_atoms("resid " + str(start) +
":" + str(end))
protein_res_to_calc_dict["p" + str(j) +
"res"]["sel"] = u.select_atoms(
"(resid " + str(start) + ":" +
str(end) +
") and (not name CA N O H*)")
print protein_res_to_calc_dict["p" + str(j) +
"res"]["sel"].resnames
print protein_res_to_calc_dict["p" + str(j) +
"res"]["sel"].resids
# store the string used to select this part of the protein for future use
protein_res_to_calc_dict["p" + str(j) +
"res"]["sel_string"] = "resid " + str(
start) + ":" + str(end)
j += 1
print protein_dict
for k, key in enumerate(protein_dict):
print "current key = ", key
# A
sel0 = protein_res_to_calc_dict["p0res"][
"sel_string"] # + " and (not name CA N O H*)"
# sel0 = "(resid " + str(1) + ":" + str(N_resid) + ") and (not name CA N O H*)"
ref0 = protein_res_to_calc_dict["p0res"]["sel"]
# B
sel1 = protein_res_to_calc_dict["p1res"]["sel_string"]
ref1 = protein_res_to_calc_dict["p1res"]["sel"]
# C
sel2 = protein_res_to_calc_dict["p2res"]["sel_string"]
ref2 = protein_res_to_calc_dict["p2res"]["sel"]
# For first protein
if key == "p0":
comb_ref = ref1 + ref2
print ""
print "selections"
print ""
print "sel0 = ", sel0
print "sel1 = ", sel1
print "sel2 = ", sel2
print ""
print "references"
print ""
print "ref0 = ", len(ref0)
print "ref1 = ", len(ref1)
print "ref2 = ", len(ref2)
print ""
print "selection check"
print sel0 + " and not name CA N O H*"
print sel1 + " or " + sel2 + " and not name CA N O H*"
#"(resid 1:10) and (not name CA N O H*)"
#"(resid 124:134 or resid 247:257) and (not name CA N O H*)"
# A - BC
regions_for_NC_analysis["A_BC"] = contacts.Contacts(
u,
selection=(sel0 + " and not name CA N O H*", sel1 +
" or " + sel2 + " and not name CA N O H*"),
refgroup=(ref0, comb_ref),
radius=6.0)
regions_for_NC_analysis["A_BC"].run()
print np.mean(regions_for_NC_analysis["A_BC"].timeseries[:, 1])
plt.plot(
np.linspace(
0, 200,
len(regions_for_NC_analysis["A_BC"].timeseries[:, 0])),
(100 * regions_for_NC_analysis["A_BC"].timeseries[:, 1]),
alpha=0.5,
label='Chain A',
c=c_pal[k])
elif key == "p1":
comb_ref = ref0 + ref2
# B - AC
regions_for_NC_analysis["B_AC"] = contacts.Contacts(
u,
selection=(sel1 + " and not name CA N O H*", sel0 +
" or " + sel2 + " and not name CA N O H*"),
refgroup=(ref1, comb_ref),
radius=6.0)
regions_for_NC_analysis["B_AC"].run()
print np.mean(regions_for_NC_analysis["B_AC"].timeseries[:, 1])
plt.plot(
np.linspace(
0, 200,
len(regions_for_NC_analysis["B_AC"].timeseries[:, 0])),
(100 * regions_for_NC_analysis["B_AC"].timeseries[:, 1]),
alpha=0.5,
label='Chain B',
c=c_pal[k])
elif key == "p2":
comb_ref = ref0 + ref1
# C - AB
regions_for_NC_analysis["C_AB"] = contacts.Contacts(
u,
selection=(sel2 + " and not name CA N O H*", sel0 +
" or " + sel1 + " and not name CA N O H*"),
refgroup=(ref2, comb_ref),
radius=6.0)
regions_for_NC_analysis["C_AB"].run()
print np.mean(regions_for_NC_analysis["C_AB"].timeseries[:, 1])
print np.array(regions_for_NC_analysis["C_AB"].timeseries[:,
0])
plt.plot(
np.linspace(
0, 200,
len(regions_for_NC_analysis["C_AB"].timeseries[:, 0])),
(100 * regions_for_NC_analysis["C_AB"].timeseries[:, 1]),
alpha=0.5,
label='Chain C',
c=c_pal[k])
else:
continue
# for key in regions_for_NC_analysis:
avg = 100 * (np.mean([
regions_for_NC_analysis["A_BC"].timeseries[:, 1],
regions_for_NC_analysis["B_AC"].timeseries[:, 1],
regions_for_NC_analysis["C_AB"].timeseries[:, 1]
],
axis=0))
#print ({k: np.mean([v[:, 1]], axis=0) for k, v in regions_for_NC_analysis.items()})
print np.mean([
regions_for_NC_analysis[k].timeseries[:, 1]
for k, v in regions_for_NC_analysis.items()
],
axis=0)
plt.plot(avg, color='black', alpha=1, label='Avg')
plt.legend()
plt.savefig('NC_plot_' + str(num_proteins) + "prot_syst" + '.svg',
format='svg')
plt.show()
plt.clf()
###### COMPARE TWO SYSTEMS #######
elif len(gro_list) != 1:
compare = True
u_list = [
mda.Universe(gro_list[0], traj_list[0]),
mda.Universe(gro_list[1], traj_list[1])
]
print "Two universes loaded..."
# Initialise dicts, first for each protein, second for the residues you wish to calc the Native Conts for.
protein_dict = {}
protein_res_to_calc_dict = {}
regions_for_NC_analysis = {}
avg_dict = {}
# Get protein information and store in dictionaries, for each system
# Initialise dicts for each system present
for s, system in enumerate(gro_list):
protein_dict["s" + str(s)] = {}
protein_res_to_calc_dict["s" + str(s)] = {}
regions_for_NC_analysis["s" + str(s)] = {}
for s, system in enumerate(gro_list):
print s
if s > 0:
c_pal = ['#ae017e', '#f768a1', '#fcc5c0']
else:
c_pal = ['#225ea8', '#41b6c4', '#c7e9b4']
for j in range(num_proteins):
if j == 0:
#system, protein, region ----> dict structure
protein_dict["s" + str(s)][
"p" + str(j)] = u_list[s].select_atoms("resid " +
str(1) + ":" +
str(N_resid))
protein_res_to_calc_dict["s" + str(s)]["p" + str(j) +
"res"] = {}
protein_res_to_calc_dict["s" + str(s)][
"p" + str(j) + "res"]["sel"] = u_list[s].select_atoms(
"(resid " + str(1) + ":" + str(N_resid) +
") and (not name CA N O H*)")
# print protein_res_to_calc_dict["s" + str(s)]["p" + str(j) + "res"]["sel"].resnames
# print protein_res_to_calc_dict["s" + str(s)]["p" + str(j) + "res"]["sel"].resids
# print protein_res_to_calc_dict
# store the string used to select this part of the protein for future use
protein_res_to_calc_dict["s" + str(s)][
"p" + str(j) + "res"]["sel_string"] = "resid " + str(
1) + ":" + str(N_resid)
j += 1
elif j >= 1:
# make sure you're in the right place for the next protein, for the current system
protein_length = len(
u_list[s].select_atoms("protein and name CA"))
start = (j * (protein_length / num_proteins)) + 1
end = (j * (protein_length / num_proteins)) + N_resid
protein_res_to_calc_dict["s" + str(s)]["p" + str(j) +
"res"] = {}
# populate dicts
protein_dict["s" + str(s)][
"p" + str(j)] = u_list[s].select_atoms("resid " +
str(start) +
":" + str(end))
protein_res_to_calc_dict["s" + str(s)][
"p" + str(j) + "res"]["sel"] = u_list[s].select_atoms(
"(resid " + str(start) + ":" + str(end) +
") and (not name CA N O H*)")
# print protein_res_to_calc_dict["s" + str(s)]["p" + str(j) + "res"]["sel"].resnames
# print protein_res_to_calc_dict["s" + str(s)]["p" + str(j) + "res"]["sel"].resids
# store the string used to select this part of the protein for future use
protein_res_to_calc_dict["s" + str(s)][
"p" + str(j) + "res"]["sel_string"] = "resid " + str(
start) + ":" + str(end)
j += 1
for k, key in enumerate(protein_dict["s" + str(s)]):
print "current system, chain = ", s, key
# A
sel0 = protein_res_to_calc_dict["s" + str(s)]["p0res"][
"sel_string"] # + " and (not name CA N O H*)"
# sel0 = "(resid " + str(1) + ":" + str(N_resid) + ") and (not name CA N O H*)"
ref0 = protein_res_to_calc_dict["s" + str(s)]["p0res"]["sel"]
# B
sel1 = protein_res_to_calc_dict["s" +
str(s)]["p1res"]["sel_string"]
ref1 = protein_res_to_calc_dict["s" + str(s)]["p1res"]["sel"]
# C
sel2 = protein_res_to_calc_dict["s" +
str(s)]["p2res"]["sel_string"]
ref2 = protein_res_to_calc_dict["s" + str(s)]["p2res"]["sel"]
# For first protein
if key == "p0":
comb_ref = ref1 + ref2
# "(resid 1:10) and (not name CA N O H*)"
# "(resid 124:134 or resid 247:257) and (not name CA N O H*)"
# A - BC
regions_for_NC_analysis[
"s" + str(s)]["A_BC"] = contacts.Contacts(
u_list[s],
selection=(sel0 + " and not name CA N O H*",
sel1 + " or " + sel2 +
" and not name CA N O H*"),
refgroup=(ref0, comb_ref),
radius=6.0)
regions_for_NC_analysis["s" + str(s)]["A_BC"].run()
print np.mean(
regions_for_NC_analysis["s" +
str(s)]["A_BC"].timeseries[:,
1])
plt.plot(
regions_for_NC_analysis["s" +
str(s)]["A_BC"].timeseries[:,
0],
(100 * regions_for_NC_analysis["s" + str(s)]
["A_BC"].timeseries[:, 1]),
alpha=0.3,
label='Chain A (system ' + str(s) + ')',
c=c_pal[k])
elif key == "p1":
comb_ref = ref0 + ref2
# B - AC
regions_for_NC_analysis[
"s" + str(s)]["B_AC"] = contacts.Contacts(
u_list[s],
selection=(sel1 + " and not name CA N O H*",
sel0 + " or " + sel2 +
" and not name CA N O H*"),
refgroup=(ref1, comb_ref),
radius=6.0)
regions_for_NC_analysis["s" + str(s)]["B_AC"].run()
plt.plot(
regions_for_NC_analysis["s" +
str(s)]["B_AC"].timeseries[:,
0],
(100 * regions_for_NC_analysis["s" + str(s)]
["B_AC"].timeseries[:, 1]),
alpha=0.3,
label='Chain B (system ' + str(s) + ')',
c=c_pal[k])
elif key == "p2":
comb_ref = ref0 + ref1
# C - AB
regions_for_NC_analysis[
"s" + str(s)]["C_AB"] = contacts.Contacts(
u_list[s],
selection=(sel2 + " and not name CA N O H*",
sel0 + " or " + sel1 +
" and not name CA N O H*"),
refgroup=(ref2, comb_ref),
radius=6.0)
regions_for_NC_analysis["s" + str(s)]["C_AB"].run()
plt.plot(
regions_for_NC_analysis["s" +
str(s)]["C_AB"].timeseries[:,
0],
(100 * regions_for_NC_analysis["s" + str(s)]
["C_AB"].timeseries[:, 1]),
alpha=0.3,
label='Chain C (system ' + str(s) + ')',
c=c_pal[k])
else:
continue
time_data = np.linspace(0, 200, 2501) # need to generalise this
avg = np.mean([
regions_for_NC_analysis["s" + str(s)]["A_BC"].timeseries[:, 1],
regions_for_NC_analysis["s" + str(s)]["B_AC"].timeseries[:, 1],
regions_for_NC_analysis["s" + str(s)]["C_AB"].timeseries[:, 1]
],
axis=0)
avg_spl = 100 * avg
xnew = np.linspace(
np.min(time_data), np.max(time_data), 300
) # No. represents number of points to make between min and max
power_smooth_avg = spline(time_data, avg_spl, xnew)
print time_data
print avg
print power_smooth_avg
print ""
print time_data[0]
print avg[0]
print power_smooth_avg[0]
# plt.plot(xnew, power_smooth_avg, label='Avg (system ' + str(s) + ')', alpha=1, color='black')
#plt.plot(avg, color='black', alpha=1, label='Avg (system ' + str(s) + ')')
# need to add this method below for a more general calc of mean -- ???
#print np.mean([regions_for_NC_analysis[k].timeseries[:, 1] for k, v in regions_for_NC_analysis["s" + str(s)].items()], axis=0)
plt.legend()
plt.savefig('compare_plot_' + str(num_proteins) + "prot_syst" + '.svg',
format='svg')
plt.show()
plt.clf()
import matplotlib.pyplot as plt
import numpy
u = mda.Universe('/home/bdv1/VMD_SaveFolder/PRB-0-HIE_ProteinOnly.pdb', '/home/bdv1/Desktop/PRB-0-protein-025.dcd')
ref = mda.Universe('/home/bdv1/MDA_Scripts/PDB_000-9184.pdb')
hel_1 = "resnum 2:18"
hel_2 = "resnum 20:31"
hel_3 = "resnum 33:47"
helix_1 = ref.select_atoms(hel_1)
helix_2 = ref.select_atoms(hel_2)
helix_3 = ref.select_atoms(hel_3)
ca12 = contacts.Contacts(u, selection=(hel_1, hel_2), refgroup=(helix_1, helix_2), radius=2000, method=contacts.radius_cut_q, kwargs={"radius":15.0}, start=4200, stop=8200).run()
ca23 = contacts.Contacts(u, selection=(hel_2, hel_3), refgroup=(helix_2, helix_3), radius=2000, method=contacts.radius_cut_q, kwargs={"radius":15.0}, start=4200, stop=8200).run()
ca13 = contacts.Contacts(u, selection=(hel_1, hel_3), refgroup=(helix_1, helix_3), radius=2000, method=contacts.radius_cut_q, kwargs={"radius":15.0}, start=4200, stop=8200).run()
x12 = ca12.timeseries[:,0]
y12 = ca12.timeseries[:,1]
x23 = ca23.timeseries[:,0]
y23 = ca23.timeseries[:,1]
x13 = ca13.timeseries[:,0]
y13 = ca13.timeseries[:,1]
N = 50
cumsum, moving_aves12 = [0], []
#first, testing to see if the PDB file of default results in same
#ref = mda.Universe('/home/bdv1/MDA_Scripts/PDB_000-default.pdb')
#it does, atleast at radius 20
#ref = mda.Universe('/home/bdv1/MDA_Scripts/VMD_test_newdrop/PRB-0-protein_autopsf_formatted(good one?).pdb')
# wait why would this work I just made this I have to make it into the one
# frame thing again what the heck
hel_1 = "resnum 2:18"
hel_2 = "resnum 20:31"
hel_3 = "resnum 33:47"
helix_1 = ref.select_atoms(hel_1)
helix_2 = ref.select_atoms(hel_2)
helix_3 = ref.select_atoms(hel_3)
ca1 = contacts.Contacts(u, selection=(hel_1, hel_2), refgroup=(helix_1, helix_2), radius=2000, method=contacts.radius_cut_q, kwargs={"radius":15.0}, stop=9999).run()
print ca1.timeseries[:, 0]
print ca1.timeseries[:, 1]
f, ax = plt.subplots()
ax.plot(ca1.timeseries[:, 0], ca1.timeseries[:, 1])
#ax.set(xlabel='frame', ylable='fraction of native contacts', title='PRB-025 Native Contacts')
ax.set_ylim(0, 1.0)
f.show()
plt.pause(30)
options = parser.parse_args()
if options.plot_type == "single":
uni = load_uni(options.gro_file, options.xtc_file)
sel_basic = "(resname ARG LYS) and (name NH* NZ)"
sel_acidic = "(resname ASP GLU) and (name OE* OD*)"
acidic = uni.select_atoms(sel_acidic)
basic = uni.select_atoms(sel_basic)
ca = contacts.Contacts(uni,
selection=(sel_acidic, sel_basic),
refgroup=(acidic, basic),
radius=options.cut_off,
verbose=True)
ca.run()
np.save('contact_analysis_data.npy', ca.timeseries[:, 1])
plot_single(ca.timeseries[:, 1])
elif options.plot_type == "multiple":
plot_multiple(options.data_list)
else:
'/home/bdv1/Desktop/rpn11_ubq.dcd')
sec_1 = "resname RN11"
section_1 = u.select_atoms(sec_1)
print section_1
sel_1 = "name RN11"
sel_2 = "name UBQ"
selection_1 = u.select_atoms(sel_1)
selection_2 = u.select_atoms(sel_2)
print selection_1
print selection_2
ca1 = contacts.Contacts(u,
selection=(sel_1, sel_2),
refgroup=(selection_1, selection_2),
radius=6.0)
ca1.run()
average_contacts = numpy.mean(ca1.timeseries[:, 1])
print('average contacts = {}'.format(average_contacts))
f, ax = plt.subplots()
ax.plot(ca1.timeseries[:, 0], ca1.timeseries[:, 1])
ax.set(xlabel='frame',
ylabel='fraction of native contacts',
title='Native Contacts, average = {:.2f}'.format(average_contacts))
#save('outfile_mdatests')
plt.ion()
import numpy
# example trajectory (transition of AdK from closed to open)
u = mda.Universe(PSF,DCD)
# crude definition of salt bridges as contacts between NH/NZ in ARG/LYS and
# OE*/OD* in ASP/GLU. You might want to think a little bit harder about the
# problem before using this for real work.
sel_basic = "(resname ARG LYS) and (name NH* NZ)"
sel_acidic = "(resname ASP GLU) and (name OE* OD*)"
# reference groups (first frame of the trajectory, but you could also use a
# separate PDB, eg crystal structure)
acidic = u.select_atoms(sel_acidic)
basic = u.select_atoms(sel_basic)
# set up analysis of native contacts ("salt bridges"); salt bridges have a
# distance <6 A
ca1 = contacts.Contacts(u, selection=(sel_acidic, sel_basic),
refgroup=(acidic, basic), radius=6.0)
# iterate through trajectory and perform analysis of "native contacts" Q
ca1.run()
# print number of averave contacts
average_contacts = numpy.mean(ca1.timeseries[:, 1])
print('average contacts = {}'.format(average_contacts))
# plot time series q(t)
f, ax = plt.subplots()
ax.plot(ca1.timeseries[:, 0], ca1.timeseries[:, 1])
ax.set(xlabel='frame', ylabel='fraction of native contacts',
title='Native Contacts, average = {:.2f}'.format(average_contacts))
plt.ion()
f.show()
plt.pause(20)
def compute_average_contacts(self, cutoff=5, selection1="protein", selection2="protein"):
atoms_1, atoms_2 = self.u.select_atoms(selection1), universe.select_atoms(selection2)
ca = contacts.Contacts(self.u, selection=(selection1, selection2),
refgroup=(atoms_1, atoms_2), radius=self.cutoff)
ca.run()
return np.mean(ca.timeseries[:, 1])
