def hydrogen_bonds(traj):
print( '.... computing hbonds (can take few minutes) ....')
list_peptide_hbonds=[]
hbonds = mdtraj.baker_hubbard(traj, freq =0.4)
for hbond in hbonds:
#if ( hbond[0] in traj.topology.select( 'chainid %s to %s' % (3,5) ) and hbond[2] not in traj.topology.select( 'chainid %s to %s' % (3,5)) ) :
if ( hbond[0] in traj.topology.select( 'chainid %s ' % (3) ) and hbond[2] not in traj.topology.select( 'chainid %s' % (3)) ) :
list_peptide_hbonds.append( hbond[[0,2]] )
print(' hbond : %s -- %s' % (traj.topology.atom(hbond[0]), traj.topology.atom(hbond[2])))
print( 'hbond : %s -- %s' % (hbond[0], hbond[2]))
#elif ( hbond[0] not in traj.topology.select( 'chainid %s to %s' % (3,5) ) and hbond[2] in traj.topology.select( 'chainid %s to %s' % (3,5)) ) :
elif ( hbond[0] not in traj.topology.select( 'chainid %s ' % (3) ) and hbond[2] in traj.topology.select( 'chainid %s ' % (3)) ) :
list_peptide_hbonds.append( hbond[[0,2]] )
print(' hbond : %s -- %s' % (traj.topology.atom(hbond[0]), traj.topology.atom(hbond[2])))
print('hbond : %s -- %s' % (hbond[0], hbond[2]))
'''
da_distances = mdtraj.compute_distances(traj, np.array(list_peptide_hbonds), periodic=False)
color = cycle(['r', 'b', 'gold'])
print(len(np.array(list_peptide_hbonds)))
for i in range(len(np.array(list_peptide_hbonds))):
plt.hist(da_distances[:, i], color=next(color), label=label(hbonds[i]), alpha=0.5)
plt.legend()
plt.ylabel('Freq');
plt.xlabel('Donor-acceptor distance [nm]')
plt.savefig('hbonds.png', bbox_inches='tight')
'''
return np.array(list_peptide_hbonds)
def main(argv):
inputfile = ''
outputfile = ''
try:
opts, args = getopt.getopt(argv, "hi:o:", ["ifile=", "ofile="])
except getopt.GetoptError("usage:"):
print('hh_newtorks.py -i <inputfile> -o <outputfile>')
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
print('hh_newtorks.py -i <inputfile> -o <outputfile>')
sys.exit()
elif opt in ("-i", "--ifile"):
inputfile = arg
elif opt in ("-o", "--ofile"):
outputfile = arg
# 1. Protonate molecule
_ = protonate_mol(inputfile)
inputfile_protonated = f"{inputfile[:-4]}-chainA_protonated.pdb"
t = md.load(inputfile_protonated)
hbonds = md.baker_hubbard(t, sidechain_only=True)
graph = make_graph_hh(hbonds, t)
comp, _ = label_components(graph)
if comp.a.any():
write_networks(graph, comp, inputfile_protonated, outputfile)
postprocess_session(inputfile_protonated, outputfile)
logger.info("Saving VMD sessions")
else:
logger.warning("No Hydrogen Bonds found")
def test_baker_hubbard_2():
t = md.load(get_fn('1vii_sustiva_water.pdb'))
triplets = md.baker_hubbard(t)
N = 1000
rows = triplets[:, 0] * N*N + triplets[:, 1] * N + triplets[:, 2]
# ensure that there aren't any repeat rows
eq(len(np.unique(rows)), len(rows))
def screening_Hbond(mol2_fnm='input.mol2', scan_fnm='scan.xyz'):
traj = md.load(scan_fnm, top=mol2_fnm)
hbonds = md.baker_hubbard(traj)
if len(hbonds) == 0:
return True, hbonds
else:
return False, hbonds
def hydrogen_bonds(traj):
print( '.... computing hbonds (can take few minutes) ....')
trajwtwater=traj.atom_slice( traj.topology.select('protein'))
# hbonds = mdtraj.baker_hubbard(traj, freq =0.4)
hbonds = mdtraj.baker_hubbard(trajwtwater, freq =0.4)
return hbonds
def apply_h_bond_filter(smiles: str) -> Tuple[str, bool, bool]:
try:
molecule = smiles_to_molecule(smiles)
molecule.generate_conformers(n_conformers=800, rms_cutoff=0.1 * unit.angstrom)
if len(molecule.conformers) == 0:
return smiles, False, True
conformers = numpy.array(
[
conformer.value_in_unit(unit.nanometers).tolist()
for conformer in molecule.conformers
]
)
topology = molecule.to_topology()._to_mdtraj()
trajectory = mdtraj.Trajectory(conformers * unit.nanometers, topology)
h_bonds = mdtraj.baker_hubbard(trajectory, freq=0.0, periodic=False)
return smiles, len(h_bonds) == 0, False
except:
return smiles, False, True
def test_hbond_structure(pdb_id):
file_name = join(data_dir("structure"), pdb_id + ".mmtf")
array = load_structure(file_name)
# Only consider amino acids for consistency
# with bonded hydrogen detection in MDTraj
array = array[..., struc.filter_amino_acids(array)]
if isinstance(array, struc.AtomArrayStack):
# For consistency with MDTraj 'S' cannot be acceptor element
# https://github.com/mdtraj/mdtraj/blob/master/mdtraj/geometry/hbond.py#L365
triplets, mask = struc.hbond(array, acceptor_elements=("O", "N"))
else:
triplets = struc.hbond(array, acceptor_elements=("O", "N"))
# Save to new pdb file for consistent treatment of inscode/altloc
# im MDTraj
temp = NamedTemporaryFile("w+", suffix=".pdb")
save_structure(temp.name, array)
# Compare with MDTraj
import mdtraj
traj = mdtraj.load(temp.name)
temp.close()
triplets_ref = mdtraj.baker_hubbard(traj, freq=0, periodic=False)
# Both packages may use different order
# -> use set for comparison
triplets_set = set([tuple(tri) for tri in triplets])
triplets_ref_set = set([tuple(tri) for tri in triplets_ref])
assert triplets_set == triplets_ref_set
def compute_hbonds(self,
plot=True,
color=itertools.cycle(["r", "b", "gold", "g"]),
hbonds_to_plot=[14, 15, 16, 17]):
"""
"""
hbonds = md.baker_hubbard(self.traj, periodic=False)
label = lambda hbond: "%s -- %s" % (self.traj.topology.atom(hbond[0]),
self.traj.topology.atom(hbond[2]))
dist = md.compute_distances(self.traj,
hbonds[:, [0, 2]],
periodic=False)
for hbond in hbonds:
print(label(hbond))
if plot:
for i in hbonds_to_plot:
plt.hist(dist[:, i],
color=next(color),
label=label(hbonds[i]),
alpha=0.5)
plt.legend()
plt.ylabel("Freq", labelpad=20)
plt.xlabel("donor-receptor distance [nm]", labelpad=20)
plt.show()
def hhbond_plot(chimera: Chimera = None, filename: str = None):
"""
Computes a hhbond plot of a chimera object or a file. One of the two inputs
must be provided.
:param chimera: the chimera from where to compute the hydrogen bond plot
:param filename: a path where to find the pdb file.
:return: A contact map with hydrogen bond as metric
"""
if chimera and filename:
raise ValueError("Only a Chimera object or the path to a pdb file must be specified")
if not chimera and not filename:
raise ValueError("At least a Chimera object or the path to a pdb file must be specified")
if chimera:
filename = "/tmp/structure.pdb"
chimera.write(filename)
mol = md.load_pdb(filename)
hbonds = md.baker_hubbard(mol, periodic=False)
for hbond in hbonds:
a = mol.topology.atom(hbond[0])
residue1 = re.findall("\d+", str(a))[0]
resid1 = int(residue1)
b = mol.topology.atom(hbond[2])
residue2 = re.findall("\d+", str(b))[0]
resid2 = int(residue2)
plt.plot(resid1, resid2, 'b.')
plt.show()
def fit(self, traj_list, y=None):
all_trajs = join(traj_list)
indices = baker_hubbard(all_trajs,
freq=self.freq,
exclude_water=self.exclude_water,
periodic=self.periodic,
sidechain_only=self.sidechain_only)
self.indices = indices[:, 1:]
def check_Hbond(scan_fnm, top_fnm=None):
"""
Check if the torsion scan contains conformers with internal hydrogen bonds
"""
traj = md.load(scan_fnm, top=top_fnm)
hbonds = md.baker_hubbard(traj)
if len(hbonds) == 0:
return True
else:
return False
def findHbonds(traj, boundIndices, results, frameIndex, resultsFrame):
print("Computing Hydrogen Bond at Index: " + str(frameIndex))
tic = time.clock()
hbonds = md.baker_hubbard(traj,
freq=0.55,
exclude_water=True,
periodic=False)
for hbond in hbonds:
if (hbond[0] in boundIndices) and (hbond[2] in boundIndices):
results[tuple(hbond)] += 1
resultsFrame[tuple(hbond)].append(frameIndex)
toc = time.clock()
print("Finished computing for ", str(frameIndex), " in time: ",
str(toc - tic))
def calculate_hbond_occurences(traj):
topology = traj.topology
get_label = lambda hbond: '%s -- %s' % (topology.atom(hbond[0]),
topology.atom(hbond[2]))
# occurences = {get_label(i) : 0 for i in md.baker_hubbard(traj, freq = 0, periodic=False)}
occurences = defaultdict(int)
for i in traj:
for j in md.baker_hubbard(i, periodic=True):
occurences[get_label(j)] += 1
# yield occurences
labels = [str(i) for i in topology.residues]
return {
"occurences": dict(occurences),
"labels": labels,
"num_frames": len(traj)
}
def hydrogenbond(pdbfile):
"""
Calculate number of hydrogen bonds [1,2] and hydrogen bond energy [3]
using three methods as implemented in MDtraj [4] for a single PDB file.
[1] E. N. Baker and R. E. Hubbard, "Hydrogen bonding in globular proteins",
Progress in Biophysics and Molecular Biology, vol. 44, no. 2,
pp. 97-179, 1984.
[2] P. Wernet et al., "The Structure of the First Coordination Shell in
Liquid Water", Science, vol. 304, no. 5673, pp. 995-999, 2004.
[3] W. Kabsch and C. Sander, "Dictionary of protein secondary structure:
Pattern recognition of hydrogen-bonded and geometrical features",
Biopolymers, vol. 22, no. 12, pp. 2577"2637, 1983.
[4] R. T. McGibbon et al., "MDTraj: A Modern Open Library for the
Analysis of Molecular Dynamics Trajectories", Biophysical Journal,
vol. 109, no. 8, pp. 1528-1532, 2015.
"""
pdb = mdtraj.load(pdbfile)
desc = dict()
desc['HB_BH'] = float(mdtraj.baker_hubbard(pdb).shape[0])
desc['HB_WN'] = float(mdtraj.wernet_nilsson(pdb)[0].shape[0])
desc['HB_KS'] = float(mdtraj.kabsch_sander(pdb)[0].sum())
return desc
def get_h_bonds(pdb_dir):
'''get bond list of H-Bonds
'''
bond_list = []
atom_list = get_pdb_atom_list(pdb_dir)
topo = mdtraj.load_pdb(pdb_dir)
# hbon_list = [ [ donor_indice, H_indice, acceptor_indice ] ], indice = pdbindice-1
hbon_list = mdtraj.baker_hubbard(topo,
freq=0,
exclude_water=False,
periodic=False,
sidechain_only=False)
for hbon in hbon_list:
H_indice = hbon[1]
acceptor_indice = hbon[2]
at_h = 'None'
at_acc = 'None'
for at_indice, at_name in atom_list:
if H_indice == (int(at_indice) - 1):
at_h = at_name
if acceptor_indice == (int(at_indice) - 1):
at_acc = at_name
bond = at_h + '=' + at_acc
bond_list.append(bond)
print('Processing: ' + pdb_dir + '\tDetected H bonds: ' +
str(len(bond_list)))
return bond_list
def _filter_function(self, result: "_BaseResult", record: RecordBase,
molecule: Molecule) -> bool:
import mdtraj
conformers = numpy.array([
conformer.value_in_unit(unit.nanometers).tolist()
for conformer in molecule.conformers
])
mdtraj_topology = mdtraj.Topology.from_openmm(
molecule.to_topology().to_openmm())
mdtraj_trajectory = mdtraj.Trajectory(conformers * unit.nanometers,
mdtraj_topology)
if self.method == "baker-hubbard":
h_bonds = mdtraj.baker_hubbard(mdtraj_trajectory,
freq=0.0,
periodic=False)
else:
raise NotImplementedError()
return len(h_bonds) == 0
# coding: utf-8
# In[3]:
get_ipython().magic(u'matplotlib inline')
from __future__ import print_function
import numpy as np
import mdtraj as md
t = md.load_frame('.\\trajectory-1.xtc', 9999, top='.\\fs-peptide.pdb')
print(t)
# In[7]:
hbonds = md.baker_hubbard(t, periodic=False)
label = lambda hbond: '%s -- %s' % (t.topology.atom(hbond[0]),
t.topology.atom(hbond[2]))
for hbond in hbonds:
print(label(hbond))
hbond_score = len(hbonds)
print('\n\nH-Bond score:', hbond_score)
# calculate heavy atom to atom contacts
# basically a number that looks like Nij/root(ninj)
# In[8]:
da_distances = md.compute_distances(t, hbonds[:, [0, 2]], periodic=False)
# In[14]:
import itertools
def Hbonds(grofile, trajfile, frame_iterator, freq=0.1):
"""
NOTE: For atomistic simulations
Calculates baker-hubbard hydrogen bond for frame_iterator
Returns the hbonds distances found in frame_iterator using two criteria:
- Average distances of hbonds cummulatively found in all the frames in frame_iterator
- hbonds cummulatively calculated using mdtraj for a particular frequency (freq) avlue
(See mdtraj documentation for more info)
Hbond criteria: DHA angle > 2*np.pi/3 and H-A separation < 2.5 A
"""
traj = mdtraj.load(trajfile, top=grofile)
positions = traj.xyz
hbonds_all = np.empty((0, 3))
framewise_hbonds = []
for f in frame_iterator:
hbonds = mdtraj.baker_hubbard(traj[f])
# FILTER Hbonds that are only between NH and C=O
hbonds_ = []
for b in hbonds:
if traj.top.atom(b[0]).name == 'N' and traj.top.atom(
b[2]).name == 'O':
hbonds_ += [b]
hbonds = np.array(hbonds_)
if len(hbonds) == 0:
hbonds = hbonds.reshape((0, 3))
framewise_hbonds += [hbonds]
hbonds_all = np.append(hbonds_all, hbonds, axis=0).astype(int)
hbonds_all = np.unique(hbonds_all, axis=0)
num_hbonds_all = len(hbonds_all)
r_DH = []
r_DA = []
r_AH = []
r_DH_all = []
r_DA_all = []
r_AH_all = []
theta = []
num_hbonds = 0
for i, f in enumerate(frame_iterator):
Lx, Ly, Lz = traj.unitcell_lengths[f]
hbonds = framewise_hbonds[i]
if len(hbonds) == 0:
continue
num_hbonds += len(hbonds)
posH = positions[f, hbonds[:, 1]]
posD = utils.unwrap_points(positions[f, hbonds[:, 0]], posH, Lx, Ly,
Lz)
posA = utils.unwrap_points(positions[f, hbonds[:, 2]], posH, Lx, Ly,
Lz)
r_AH_ = np.linalg.norm(posA - posH, axis=-1)
r_DA_ = np.linalg.norm(posD - posA, axis=-1)
r_DH_ = np.linalg.norm(posD - posH, axis=-1)
r_DH += list(r_DH_)
r_AH += list(r_AH_)
r_DA += list(r_DA_)
posH = positions[f, hbonds_all[:, 1]]
posD = utils.unwrap_points(positions[f, hbonds_all[:, 0]], posH, Lx,
Ly, Lz)
posA = utils.unwrap_points(positions[f, hbonds_all[:, 2]], posH, Lx,
Ly, Lz)
r_AH_all_ = np.linalg.norm(posA - posH, axis=-1)
r_DA_all_ = np.linalg.norm(posD - posA, axis=-1)
r_DH_all_ = np.linalg.norm(posD - posH, axis=-1)
r_DH_all += list(r_DH_all_)
r_AH_all += list(r_AH_all_)
r_DA_all += list(r_DA_all_)
v1 = posA - posH
v2 = posD - posH
theta_ = [
abs(quaternion.angle_v1tov2(v1[i], v2[i]))
for i in range(v1.shape[0])
]
theta += [theta_]
num_hbonds_perframe = num_hbonds / len(frame_iterator)
return (np.mean(r_DH), np.std(r_DH), np.mean(r_AH), np.std(r_AH),
np.mean(r_DA), np.std(r_DA),
num_hbonds_perframe, np.mean(r_DH_all), np.std(r_DH_all),
np.mean(r_AH_all), np.std(r_AH_all), np.mean(r_DA_all),
np.std(r_DA_all), num_hbonds_all)
"""
Chord Diagram
=============
"""
from msmbuilder.example_datasets import FsPeptide
import numpy as np
import mdtraj as md
import msmexplorer as msme
from msmexplorer.utils import make_colormap
# # Load Fs Peptide Data
trajs = FsPeptide().get().trajectories
# Compute Hydrogen Bonding Residue Pairs
baker_hubbard = md.baker_hubbard(trajs[0])
top = trajs[0].topology
pairs = [(top.atom(di).residue.index, top.atom(ai).residue.index)
for di, _, ai in baker_hubbard]
# Create Hydrogen Bonding Network
hbonds = np.zeros((top.n_residues, top.n_residues))
hbonds[list(zip(*pairs))] = 1.
# Make a Colormap
cmap = make_colormap(['rawdenim', 'lightgray', 'pomegranate'])
# Plot Chord Diagram
msme.plot_chord(hbonds, cmap=cmap)
def do_hbonds(trajectory,
topology=None,
verbose=True,
distance_cutoff=0.35,
angle_cutoff=120,
start_time=-np.inf,
end_time=np.inf,
skip=1,
chunk_size=100,
periodic=True,
exclude_waters=False,
sidechain_only=False,
dt=None):
if chunk_size % skip:
raise ValueError(
'do_hbonds: chunk_size must be an integer multiple of step')
if topology is None:
base, _ = os.path.splitext(trajectory)
topology = base + '.pdb'
hbonds = []
for i, trj in enumerate(
md.iterload(trajectory, top=topology, chunk=chunk_size)):
if dt:
first_time = i * len(trj) * dt
last_time = ((i + 1) * len(trj) - 1) * dt
if first_time >= end_time or last_time <= start_time:
continue
_time = np.linspace(first_time, last_time + dt, len(trj) + 1)
indices = np.argwhere((_time >= start_time) & (_time <= end_time))
else:
if trj.time[0] >= end_time or trj.time[-1] <= start_time:
continue
indices = np.argwhere((trj.time >= start_time)
& (trj.time <= end_time))
keep = list(range(0, chunk_size, skip))
ok_indices = [index[0] for index in indices if index in keep]
skip_range = range(min(ok_indices), max(ok_indices) + skip, skip)
trj_ok = trj[skip_range]
for j in range(len(trj_ok)):
frame = trj_ok[j]
time = frame.time[0]
if dt:
time = j * dt + i * len(trj) * dt
if verbose:
print(f'HBONDS - Processing time: {time}', end='\r')
the_hbonds = md.baker_hubbard(frame,
periodic=periodic,
distance_cutoff=distance_cutoff,
angle_cutoff=angle_cutoff,
exclude_water=exclude_waters,
sidechain_only=sidechain_only,
freq=0)
hbonds.append((time, the_hbonds))
if verbose:
print()
print('Done.')
return hbonds
def test_baker_hubbard_1():
# no hydrogens in this file -> no hydrogen bonds
t = md.load(get_fn('1bpi.pdb'))
eq(np.zeros((0, 3), dtype=int), md.baker_hubbard(t))
def draw_snapshot(grofile, trajfile, topfile, itpfiles, molnames,
molattributes=[], hbondattributes=[], slice_slab=[],
draw_box=False, frame=-1, filename='snapshot.png', preview=True,
view=[['axono']], primitive='cylinder', lights=''):
"""
For gromacs atomistic simulations.
Draw snapshots with hbonds shown
molattributes = [ [particle_id_start, particle_id_end, hexcolor, radius, outline_width], [particle_id_start, particle_id_end, hexcolor, radius, outline_width],... ]
particle ids not covered in the colors list are not draw
hbondattributes = [hexcolor, radius, outline_width]
slice_slab = ['eig',i,j, thickness (nm)] | []
from center cut the slice along vi and slicing in vj direction using thickness
preview: fresnel preview or pathtrace
view: ['axono','name'] axonometric view
['axis', i, j, name] - looking from axis i, axis j points upwards
['eig', i,j, name] - looking from vi to system center, vj is upward direction
vi -> {0,1,2} are gyration vectors ids, 0 and 2 correspond to largest and smallest eigenvale
[] - diagonal - axonometric view
snapshots are saved for each view in the list
name is the optional name appended before filename for each view snapshot
primitive: sphere | cylinder
lights: fresnel lights - lightbox, cloudy, rembrandt
Notes: no water drawn | only backbone atoms are drawn
"""
#-------------------------------------- default parameters ---------------------------------
# radius_dir = dict(H=0, C=0.15, N=0.12, S=0.15, O=0.15) # for sphere primitive
# radius_cylinder = 0.03
# outline_width_cylinder = 0.00
# outline_width_sphere = 0.01
# radius_cylinder_hbond = 0.015
# outline_width_cylinder_hbonds = 0.005
radius = 0.1
outline_width = 0.01
# color_C16 = to_rgb('#0D2D6C') #542e71
# color_12C = to_rgb('#0D2D6C')
# color_pep = to_rgb('#00FF00')
# color_pep2 = to_rgb('#00FF00')
# color_BMP = to_rgb('#e41a1c')
#------------------------------------ Read system attributes -----------------------------
traj = mdtraj.load(trajfile, top=grofile)
Lx, Ly, Lz = traj.unitcell_lengths[frame]
atoms = np.array([r for r in traj.top.atoms])
num_atomss = []
nmols = []
positionss = []
atomss = []
start = 0
for i,molname in enumerate(molnames):
num_atomss += [utils.get_num_atoms_fromGRO(itpfiles[i].replace('.itp','')+'.gro')]
nmols += [utils.get_num_molecules_fromtop(topfile, molname)]
positionss += [ traj.xyz[frame,start:start+num_atomss[i]*nmols[i]] ]
atomss += [ atoms[start:start+num_atomss[i]*nmols[i]] ]
start += num_atomss[i]*nmols[i]
# c: green, blue, red
c = [to_rgb('#00FF00'), to_rgb('#2978b5'), to_rgb('#fb3640')]
# if molattributes == []:
# for i,molname in enumerate(molnames):
# molattributes += [ [ [0,num_atomss[i]*nmols[i], c[i], radius, outline_width] ] ]
if molattributes != []:
for i,molattribute in enumerate(molattributes):
for j,m in enumerate(molattribute):
molattributes[i][j][2] = to_rgb(m[2])
# Read bonds per molecule type
bondss = get_bonds_fromtopfile(topfile, molnames)
backbone_bondss = []
alkyl_bondss = []
bb_and_alkyl_bondss = []
start = 0
for i,molname in enumerate(molnames):
# Collect backbone bonds i.e., only between C,N,CA (not C16)
bonds_=[]
for b in bondss[i]:
resname0 = atomss[i][b[0]].residue.name
resname1 = atomss[i][b[1]].residue.name
atomname0 = atomss[i][b[0]].name
atomname1 = atomss[i][b[1]].name
if resname0 in ['C16','12C', 'HOH'] or resname1 in ['C16','12C', 'HOH']:
continue
if atomname0 in ['C','N','CA'] and atomname1 in ['C','N','CA']:
bonds_ += [ [b[0], b[1]] ]
backbone_bondss += [np.array(bonds_)]
# Collect alkyl bonds i.e., bonds between C-C
bonds_=[]
for b in bondss[i]:
resname0 = atomss[i][b[0]].residue.name
resname1 = atomss[i][b[1]].residue.name
atomname0 = atomss[i][b[0]].name
atomname1 = atomss[i][b[1]].name
if resname0 in ['C16','12C'] and resname1 in ['C16','12C']:
if atomname0[0] == 'C' and atomname1[0] == 'C':
bonds_ += [ [b[0], b[1]] ]
alkyl_bondss += [np.array(bonds_)]
# collect both backbone and alkyl bonds that can be draw
bb_and_alkyl_bondss += [ np.append(backbone_bondss[i], alkyl_bondss[i], axis=0) ]
# Backbone positions
backbone_positionss=[]
for i,bb in enumerate(backbone_bondss):
backbone_positions = np.empty((0,3))
for j in range(nmols[i]):
args = np.sort(list(set((bb + j * num_atomss[i]).reshape(-1))))
backbone_positions = np.append(backbone_positions, positionss[i][args], axis=0)
backbone_positionss += [backbone_positions]
#------------------------------------ gyration eigenvectors ------------------------
points = np.empty((0,3))
for p in backbone_positionss:
points = np.append(points, p, axis=0)
center = np.mean(points, axis=0)
# Calculate gyration eigenvectors using only backbone atoms
# Gij = 1/N SUM_n:1_N [ rn_i * rn_j ]
points -= center
G = np.zeros((3,3))
for i,j in itertools.product(range(3),range(3)):
G[i,j] = np.mean(points[:,i]*points[:,j])
w,v = scipy.linalg.eig(G)
args = np.argsort(w)[::-1]
eigvec = v[:,args]
#------------------------------------ slice or not ------------------------
if slice_slab != []:
if slice_slab[0]=='eig':
vi = eigvec[:,slice_slab[1]]
vj = eigvec[:,slice_slab[2]]
thickness = slice_slab[3]
slice_filtrs = []
for pos in positionss:
t = (pos-center).dot(vj.reshape(-1,1)).reshape(-1)
slice_filtrs += [ (t <= thickness/2) * (t >= -thickness/2) ]
#------------------------------------ draw fresnel scene --------------------------------------------------
# Start scene
scene = fresnel.Scene()
# Primitive
if primitive == 'cylinder':
for k,molattribute in enumerate(molattributes):
for id1, id2, color_, radius, outline_width in molattribute:
filtr = (bb_and_alkyl_bondss[k][:,0]>=id1) * \
(bb_and_alkyl_bondss[k][:,0]<=id2) * \
(bb_and_alkyl_bondss[k][:,1]>=id1) * \
(bb_and_alkyl_bondss[k][:,1]<=id2)
bb_ = bb_and_alkyl_bondss[k][filtr]
bb = []
for m in range(nmols[k]):
bb += list( bb_ + m * num_atomss[k] )
bb = np.array(bb).astype(int)
if slice_slab != []:
filtr = slice_filtrs[k][bb[:,0]] * \
slice_filtrs[k][bb[:,1]]
bb = bb[filtr]
points1 = positionss[k][bb[:,0]]
points2 = utils.unwrap_points(positionss[k][bb[:,1]], points1, Lx, Ly, Lz)
geometry = fresnel.geometry.Cylinder(scene, N = len(points1))
geometry.radius[:] = radius
geometry.outline_width = outline_width
geometry.points[:] = list(zip(points1, points2))
geometry.color[:] = color_
geometry.material = fresnel.material.Material(
roughness=0.5,
primitive_color_mix=1)
elif primitive == 'sphere':
for k,molattribute in enumerate(molattributes):
for id1, id2, color_, radius, outline_width in molattribute:
args_ = np.array(list(set(bb_and_alkyl_bondss[k].reshape(-1))))
args_ = args_[(args_>=id1) * (args_<=id2)]
args = []
for m in range(nmols[k]):
args += list( args_ + m * num_atomss[k] )
if slice_slab != []:
filtr = slice_filtrs[k][args] * \
slice_filtrs[k][args]
args = args[filtr]
points = positionss[k][args]
geometry = fresnel.geometry.Sphere(scene, N = len(points))
geometry.radius[:] = radius
geometry.outline_width = outline_width
geometry.position[:] = points
geometry.color[:] = color_
geometry.material = fresnel.material.Material(
roughness=0.5,
primitive_color_mix=1)
# Hbonds
if hbondattributes != []:
color_, radius, outline_width = hbondattributes
color_ = to_rgb(color_)
hbonds = mdtraj.baker_hubbard(traj[frame])
hbonds_=[]
for b in hbonds:
if traj.top.atom(b[0]).name == 'N' and traj.top.atom(b[2]).name == 'O':
hbonds_ += [b]
hbonds = np.array(hbonds_)
if slice_slab != []:
slice_filtr = np.empty(0, dtype=bool)
for f in slice_filtrs:
slice_filtr = np.append(slice_filtr, f)
filtr = slice_filtr[hbonds[:,0]] * \
slice_filtr[hbonds[:,1]]
hbonds = hbonds[filtr]
pos = np.empty((0,3))
for p in positionss:
pos = np.append(pos,p,axis=0)
posH = pos[hbonds[:,1]]
posA = utils.unwrap_points(pos[hbonds[:,2]], posH, Lx, Ly, Lz)
points1 = posH
points2 = posA
geometry = fresnel.geometry.Cylinder(scene, N = len(points1))
geometry.radius[:] = radius
geometry.outline_width = outline_width
geometry.points[:] = list(zip(points1, points2))
geometry.color[:] = color_
geometry.material = fresnel.material.Material(
roughness=0.5,
primitive_color_mix=1)
# Lights
if lights == 'lightbox':
scene.lights = fresnel.light.lightbox()
elif lights == 'cloudy':
scene.lights = fresnel.light.cloudy()
elif lights == 'rembrandt':
scene.lights = fresnel.light.rembrandt()
# Camera
for view_ in view:
if view_[0] == 'eig':
try:
vname = view_[3]
except:
vname = ''
vi = eigvec[:,view_[1]]
vj = eigvec[:,view_[2]]
scene.camera = fresnel.camera.Orthographic.fit(scene)
scene.camera.position = 5 * vi + center
scene.camera.look_at = center
scene.camera.up = vj
elif view_[0] == 'axono': # use axonometric view
try:
vname = view_[1]
except:
vname = ''
scene.camera = fresnel.camera.Orthographic.fit(scene)
scene.camera.position = center + [4, 4, 5]
scene.camera.look_at = center
if preview:
out = fresnel.preview(scene, w=800, h=800)
else:
out = fresnel.pathtrace(scene, w=800, h=800, samples=16, light_samples=32)
PIL.Image.fromarray(out[:], mode='RGBA').save(vname+filename)
t = md.load('traj.nc', top=topology)
t = t.image_molecules(
anchor_molecules=solute_ref.topology.find_molecules()[0:1], inplace=True)
print('finish imaging molecules')
equi = 300 # the structure seems stable after this frame
length = len(t)
print(f'length of the simulation: {length}.')
# hard code the residue indices of CDK6 and CRBN (1-based)
CDK6 = list(range(1, 294))
CRBN = list(range(541, 922))
key_inter = dict()
lig_inter = dict()
for i in tqdm(range(length)):
hbonds = md.baker_hubbard(t[i])
label = lambda hbond: '%s -- %s' % (t.topology.atom(hbond[0]),
t.topology.atom(hbond[2]))
for hbond in hbonds:
if (str(t.topology.atom(hbond[0]))[4] == '-'
and int(str(t.topology.atom(hbond[0]))[3]) in CDK6) or (
str(t.topology.atom(hbond[0]))[5] == '-'
and int(str(t.topology.atom(hbond[0]))[3:5]) in CDK6) or (
str(t.topology.atom(hbond[0]))[6] == '-'
and int(str(t.topology.atom(hbond[0]))[3:6])
in CDK6): # 1-digit CDK6 or 2-digit or 3-digit
if len(str(t.topology.atom(hbond[2]))) > 6:
if str(t.topology.atom(hbond[2]))[6] == '-' and int(
str(t.topology.atom(hbond[2]))
[3:6]) in CRBN: # CRBN can only be 3-digit
if label(hbond) not in key_inter.keys():
def test_baker_hubbard_3(get_fn):
#different distance cutoffs->different hydrogen bonds found
t = md.load(get_fn('2waters_baker_hubbard.pdb'))
eq(np.zeros((0,3), dtype=int), md.baker_hubbard(t, exclude_water=False, distance_cutoff = 0.18))
eq(np.zeros((0,3), dtype=int), md.baker_hubbard(t, exclude_water=False, angle_cutoff=180))
eq(np.array([[0, 1, 3]]), md.baker_hubbard(t, exclude_water=False))
def plot_hbonds(args):
residue_pairs = set()
for r1 in args.residue_group_1:
for r2 in args.residue_group_2:
residue_pairs.add(tuple(sorted((r1, r2))))
print residue_pairs
print "Reading frames"
traj = md.load(args.input_traj,
top=args.pdb_file)
print "Computing hbonds"
n_windows = int(np.ceil(traj.n_frames / float(args.window_size)))
hbond_freq = dict()
for pair in residue_pairs:
hbond_freq[pair] = np.zeros(n_windows)
all_residues = set()
for r1, r2 in residue_pairs:
all_residues.add(r1)
all_residues.add(r2)
selection = " or ".join(["(resid %s)" % r for r in all_residues])
print selection
selected_atom_indices = traj.topology.select(selection)
traj = traj.atom_slice(selected_atom_indices)
print traj.n_atoms, traj.n_residues
for i in xrange(traj.n_frames):
hbonds = md.baker_hubbard(traj[i],
periodic=False)
if i % 1000 == 0:
print "Frame", (i+1)
seen_pairs = set()
for donor_idx, hydrogen_idx, acceptor_idx in hbonds:
res1 = traj.topology.atom(donor_idx).residue.index
res2 = traj.topology.atom(acceptor_idx).residue.index
key = tuple(sorted((res1, res2)))
if key in residue_pairs and key not in seen_pairs:
window_idx = i / args.window_size
hbond_freq[key][window_idx] += 1.0
seen_pairs.add(key)
for pair, freq in hbond_freq.iteritems():
freq /= float(args.window_size)
print "plotting"
if args.plot_type == "timeseries":
time = np.arange(1, n_windows + 1) * traj.timestep * args.window_size / 10.
for i, ((r1, r2), freq) in enumerate(hbond_freq.iteritems()):
label = "%s -- %s" % (r1 + 1, r2 + 1)
plt.plot(time, freq, label=label)
plt.xlabel('Time (ns)', fontsize=16)
plt.ylabel('H-bond Frequency', fontsize=16)
plt.ylim([-0.01, 1.01])
elif args.plot_type == "distribution":
for i, ((r1, r2), freq) in enumerate(hbond_freq.iteritems()):
label = "%s -- %s" % (r1 + 1, r2 + 1)
sns.distplot(freq, kde=False, label=label)
plt.ylabel('Counts', fontsize=16)
plt.xlabel('H-bond Frequency', fontsize=16)
plt.legend()
plt.savefig(args.figure_fl,
DPI=300)
import mdtraj as md
import mdtraj.testing
# Load up some example data. This is a little 20 frame PDB, straight
# from the RCSB
path = mdtraj.testing.get_fn('2EQQ.pdb')
t = md.load(path)
print t
# :func:`md.baker_hubbard` idenfies hydrogen bonds baced on cutoffs
# for the Donor-H...Acceptor distance and angle. The criterion employed
# is :math:`\theta > 120` and :math:`r_\text{H...Acceptor} < 2.5 A` in
# at least 10% of the trajectory. The return value is a list of the
# indices of the atoms (donor, h, acceptor) that satisfy this criteria.
hbonds = md.baker_hubbard(t)
label = lambda hbond : '%s -- %s' % (t.topology.atom(hbond[0]), t.topology.atom(hbond[2]))
for hbond in hbonds:
print label(hbond)
# Let's compute the actual distances between the donors and acceptors
da_distances = md.compute_distances(t, hbonds[:, [0,2]], periodic=False)
# Plot a histogram for a few of them
import matplotlib.pyplot as pp
pp.figure();
color = itertools.cycle(['r', 'b', 'gold'])
for i in [2, 3, 4]:
pp.hist(da_distances[:, i], color=next(color), label=label(hbonds[i]), alpha=0.5)
def Hbond_autocorrelation(grofile,
trajfile,
frame_iterator,
window_duration,
frame_interval,
filename=None):
"""
NOTE: For atomistic simulations
Autocorrelation is calculated as
auto(t) = < kij(t0) * k(t0+t) / <kij(t0)^2> >
kij: binary variable defining H-bond presence between i, j atoms
auto is averaged over all the hbonds and multiple time windows
frame_iterator: traj frames to use for calculating auto
window_duration: max time up till which auto is calculated
frame_interval: number of frames between start of consecutive time windows
autos are calculated after every frame_interval and then averaged
"""
traj = mdtraj.load(trajfile, top=grofile)
positions = traj.xyz
framewise_hbonds = []
all_hbonds = np.empty((0, 3))
k = {} # key is (D,H,A)
for n, f in enumerate(frame_iterator):
Lx, Ly, Lz = traj.unitcell_lengths[f]
hbonds = mdtraj.baker_hubbard(traj[f])
framewise_hbonds += [hbonds]
all_hbonds = np.append(all_hbonds, hbonds, axis=0)
all_hbonds = np.unique(all_hbonds, axis=0)
hbond_id_dict = {}
for i, hbond in enumerate(all_hbonds):
hbond_id_dict[tuple(hbond)] = i
# k is the array that stores hbond presence
k = np.zeros((len(all_hbonds), len(frame_iterator)))
for f, hbonds in enumerate(framewise_hbonds):
for hbond in hbonds:
k[hbond_id_dict[tuple(hbond)], f] = 1
# So <kij(t0)^2> = 1 because kij(t0) is 1 for all hbonds in that frame
# Caluclate average < kij(t0) * k(t0+t) >
# auto = np.empty((0,window_duration)) # collect auto for each window
# for i,_ in enumerate(frame_iterator[::frame_interval]):
# hbonds0 = framewise_hbonds[i]
# args = [hbond_id_dict[tuple(hbond)] for hbond in hbonds0]
# if len(frame_iterator[i:])>=window_duration:
# auto_ = k[args,i:i+1]*k[args,i:i+window_duration]
# auto = np.append(auto, auto_, axis=0)
# auto = np.mean(auto, axis=0)
auto = [1]
args = []
for i in range(1, len(frame_iterator)):
hbonds0 = framewise_hbonds[i]
args += [[hbond_id_dict[tuple(hbond)] for hbond in hbonds0]]
args = np.array(args)
auto = [1]
for i in range(1, len(frame_iterator)):
auto_ = []
for j in range(len(frame_iterator) - i):
auto_ += [np.mean(k[args[j], j] * k[args[j], j + i])]
auto += [np.mean(auto_)]
auto = np.array(auto)
if type(filename) != type(None):
fig = plt.figure(figsize=(4 / 1.2, 3 / 1.2))
plt.plot(range(len(auto)), auto, marker='o')
plt.title('H-bond Autocorrelation')
plt.xlabel('Frame Number')
plt.ylabel('Autocorrelation')
plt.subplots_adjust(bottom=0.14, left=0.15)
plt.savefig(filename, dpi=400)
return auto
def Hbond_orientation(grofile, trajfile, frame_iterator, eig_index):
"""
NOTE: For atomistic simulations
Calculates baker-hubbard hydrogen bond for frame_iterator
Calculates the fluctuation of the direction O-H bond as
theta is angle between the OH orientation and it's average.
Calculates Hbond orientation wrt to its molecule and wrt to the fiber axis
eig_index: {0,1,2} 0: largest eigenvalue 2: lowest eigenvalue
eigenvectors are ussed for calculating the fiber axis
and are calculated using the peptide backbone.
spatial_fluctuation
Hbond criteria: DHA angle > 2*np.pi/3 and H-A separation < 2.5 A
"""
traj = mdtraj.load(trajfile, top=grofile)
positions = traj.xyz
# all hbonds that ever occured in the traj
hbonds_all = np.empty((0, 3))
framewise_hbonds = []
for f in frame_iterator:
hbonds = mdtraj.baker_hubbard(traj[f])
# FILTER Hbonds that are only between NH and C=O
hbonds_ = []
for b in hbonds:
if traj.top.atom(b[0]).name == 'N' and traj.top.atom(
b[2]).name == 'O':
hbonds_ += [b]
hbonds = np.array(hbonds_)
framewise_hbonds += [hbonds]
hbonds_all = np.append(hbonds_all, hbonds, axis=0).astype(int)
hbonds_all = np.unique(hbonds_all, axis=0)
rOH = []
for i, f in enumerate(frame_iterator):
Lx, Ly, Lz = traj.unitcell_lengths[f]
posH = positions[f, hbonds_all[:, 1]]
posA = utils.unwrap_points(positions[f, hbonds_all[:, 2]], posH, Lx,
Ly, Lz)
rOH += [posH - posA]
rOH = np.array(rOH)
#------------------------------------ Gyration eigenvectors ------------------------
points = np.empty((0, 3))
for p in backbone_positionss:
points = np.append(points, p, axis=0)
center = np.mean(points, axis=0)
# Calculate gyration eigenvectors using only backbone atoms
# Gij = 1/N SUM_n:1_N [ rn_i * rn_j ]
points -= center
G = np.zeros((3, 3))
for i, j in itertools.product(range(3), range(3)):
G[i, j] = np.mean(points[:, i] * points[:, j])
w, v = scipy.linalg.eig(G)
args = np.argsort(w)[::-1]
eigvec = v[:, args]
#------------------------------------ Calculate ------------------------
# Calculate spatial fluctuation, averaged over all frames
fluc_spatial = []
rOH_mean = np.mean(rOH, axis=1)
for i in range(rOH.shape[0]):
thetas = [
quaternion.angle_v1tov2(rOH_, rOH_mean[i]) for rOH_ in rOH[i]
]
fluc_spatial += [np.sqrt(np.mean(np.array(thetas)**2))]
fluc_spatial = np.mean(fluc_spatial)
# Calculate temporal fluctuation, averaged over all hbonds
fluc_temporal = []
rOH_mean = np.mean(rOH, axis=0)
for i in range(rOH.shape[1]):
thetas = [
quaternion.angle_v1tov2(rOH_, rOH_mean[i]) for rOH_ in rOH[:, i]
]
fluc_temporal += [np.sqrt(np.mean(np.array(thetas)**2))]
fluc_temporal = np.mean(fluc_temporal)
return fluc_spatial, fluc_temporal
def draw_Hbonds(grofile, trajfile, topfile, itpfiles,
molnames, draw_box, frame, filename='snapshot_hbonds.png', preview=True):
"""
For atomistic simulations.
Draw snapshots with hbonds along the three gyration eigenvectors
"""
#---------------------------------------- Parameters ---------------------------------
radius_dir = dict(H=0, C=0.15, N=0.12, S=0.15, O=0.15)
radius_cylinder = 0.03
outline_width = 0.0001
color_C16 = to_rgb('#0D2D6C')
color_12C = to_rgb('#0D2D6C')
color_pep = to_rgb('#00FF00')
color_pep2 = to_rgb('#00FF00')
color_BMP = to_rgb('#e41a1c')
#--------------------------------------------------------------------------------------
# Calculate bonds and colors
traj = mdtraj.load(trajfile, top=grofile)
num_atomss = []
nmols = []
positions = []
start = 0
for i,molname in enumerate(molnames):
num_atomss += [utils.get_num_atoms_fromGRO(itpfiles[i].replace('.itp','')+'.gro')]
nmols += [utils.get_num_molecules_fromtop(topfile, molname)]
positions += list(traj.xyz[frame,start:start+num_atomss[i]*nmols[i]])
start += num_atomss[i]*nmols[i]
positions = np.array(positions)
N = len(positions)
Lx, Ly, Lz = traj.unitcell_lengths[frame]
residues = np.array([r for r in traj.top.residues])[:N]
atoms = np.array([a for a in traj.top.atoms])[:N]
# Collect backbone bonds i.e., only between C,N,CA (not C16)
bonds=[]
for b in traj.top.bonds:
if b[0].residue.name in ['C16','12C', 'HOH'] or b[1].residue.name in ['C16','12C', 'HOH']:
continue
if b[0].name in ['C','N','CA'] and b[1].name in ['C','N','CA']:
bonds += [ [b[0].index, b[1].index] ]
bonds = np.array(bonds)
radius = []
for atom in atoms:
radius += [ radius_dir[atom.name[0]] ]
# Hbonds
hbonds = mdtraj.baker_hubbard(traj[frame])
hbonds_=[]
for b in hbonds:
if traj.top.atom(b[0]).name == 'N' and traj.top.atom(b[2]).name == 'O':
hbonds_ += [b]
hbonds = np.array(hbonds_)
posH = positions[hbonds[:,1]]
posA = utils.unwrap_points(positions[hbonds[:,2]], posH, Lx, Ly, Lz)
# Define custom colors
colors = np.zeros((N,3))
colors[0:num_atomss[0]*nmols[0]] = color_pep
# colors[num_atomss[0]*nmols[0]:num_atomss[0]*nmols[0]+num_atomss[1]*nmols[1]] = color_pep2
# c_=[]
# for i in range(nmols[1]):
# c_+=[color_BMP]*128+[color_pep2]*(num_atomss[1]-128)
# colors[num_atomss[0]*nmols[0]:] = c_
for i,atom in enumerate(atoms):
if atom.residue.name == 'C16':
colors[i] = color_C16
elif atom.residue.name == '12C':
colors[i] = color_12C
colors = np.array(colors)
# alpha = 0.2
# colors = np.append(colors, [[alpha]]*len(colors), axis=1)
positions_backbone = positions[ np.sort(list(set(bonds.reshape(-1)))) ]
center = np.mean(positions_backbone, axis=0)
#--------------------------------------------------------------------------------------
# Calculate gyration eigenvectors
# Gij = 1/N SUM_n:1_N [ rn_i * rn_j ]
points = positions_backbone - np.mean(positions_backbone, axis=0)
G = np.zeros((3,3))
for i,j in itertools.product(range(3),range(3)):
G[i,j] = np.sum(points[:,i]*points[:,j])
G /= len(positions_backbone)
w,v = scipy.linalg.eig(G)
args = np.argsort(w)
v1 = v[:,args[2]]
v2 = v[:,args[1]]
v3 = v[:,args[0]]
#--------------------------------------------------------------------------------------
# Draw fresnel scene
# Sphere
# scene = fresnel.Scene()
# geometry = fresnel.geometry.Sphere(scene, N=len(positions), radius=np.array(radius), outline_width = 0.01)
# geometry.position[:] = positions
# geometry.color[:] = colors #fresnel.color.linear(colors)
for i,vi,vj in [['v3',v3,v1]]:
# Cylinder
scene = fresnel.Scene()
# scene.background_color = [1, 1, 1]
# scene.background_alpha = 1
geometry = fresnel.geometry.Cylinder(scene, N=len(bonds), radius=radius_cylinder, outline_width=outline_width)
geometry.points[:] = list(zip(positions[bonds[:,0]], positions[bonds[:,1]]))
geometry.color[:] = list(zip(colors[bonds[:,0]], colors[bonds[:,1]]))
geometry.material = fresnel.material.Material(
# color=fresnel.color.linear([0.1, 0.1, 0.6]),
roughness=0.5,
primitive_color_mix=1,
# specular=0,
spec_trans=1
)
# hbonds
geometry = fresnel.geometry.Cylinder(scene, N=len(hbonds), radius=0.015, outline_width=0.005)
geometry.points[:] = list(zip(posH, posA))
geometry.color[:] = to_rgb('#325288')
geometry.material = fresnel.material.Material(
# color=fresnel.color.linear([0.1, 0.1, 0.6]),
roughness=0.5,
primitive_color_mix=1,
# specular=1,
# spec_trans=1
)
scene.lights = fresnel.light.lightbox()
scene.camera = fresnel.camera.Orthographic.fit(scene)
scene.camera.position = 5 * vi + center
scene.camera.look_at = center
scene.camera.up = vj
# scene.lights = fresnel.light.lightbox()
if preview:
out = fresnel.preview(scene)
else:
out = fresnel.pathtrace(scene, w=800, h=800)
# out = fresnel.pathtrace(scene, w=800, h=800, samples=16, light_samples=32)
PIL.Image.fromarray(out[:], mode='RGBA').save(i+filename)
def create_json(self,isGPCR,trj_file,top_file,resi_to_group,resi_to_name,newpath,stride):
out_file = re.search("(\w*)(\.\w*)$" , newpath).group()
self.stdout.write(self.style.NOTICE("Reading MD trajectory..."))
num_frames=get_num_frames(trj_file,stride)
it=md.iterload(filename=trj_file,chunk=(50/stride), top=top_file , stride=stride)
f=0
self.stdout.write(self.style.NOTICE("Analyzing Hbond network. It may take a while..."))
hbond_frames = defaultdict(set)
for t in it:
for fnum,frame in enumerate(t[:]):
hbonds = md.baker_hubbard(frame, periodic=True)
for hbond in hbonds:
resi_1 = t.topology.atom(hbond[0]).residue
resi_2 = t.topology.atom(hbond[2]).residue
if ((resi_1 != resi_2) and (resi_1.is_protein) and (resi_2.is_protein)):
if (resi_1.index < resi_2.index):
key = ((str(resi_1.resSeq),str(resi_1.chain.index)),(str(resi_2.resSeq),str(resi_2.chain.index)))
else:
key = ((str(resi_2.resSeq),str(resi_2.chain.index)),(str(resi_1.resSeq),str(resi_1.chain.index)))
hbond_frames[key].add(f)
f+=1
self.stdout.write(self.style.NOTICE("%d%% completed"%((f/num_frames)*100)))
self.stdout.write(self.style.NOTICE("Writing hbonds to %s .."%out_file))
#Collect entries for edges and trees (grouping of nodes)
edge_entries = []
tree_paths = set()
for resi1,resi2 in hbond_frames:
if not resi1 in resi_to_name: continue
if not resi2 in resi_to_name: continue
resn1 = resi_to_name[resi1] if resi1 in resi_to_name else resi1[0]
resn2 = resi_to_name[resi2] if resi2 in resi_to_name else resi2[0]
if resn1=="None" or resn2=="None": continue
framelist = sorted(list(hbond_frames[(resi1,resi2)]))
helixinfo=get_cont_type(self,trj_file,resn1,resn2)
if (helixinfo):
edge_entries.append(" {\"name1\":\"%s\", \"name2\":\"%s\", \"frames\":%s, \"helixpos\":%s}"%(resn1,resn2,str(framelist),helixinfo))
else:
edge_entries.append(" {\"name1\":\"%s\", \"name2\":\"%s\", \"frames\":%s}"%(resn1,resn2,str(framelist)))
tree_paths.add(resi_to_group[resi1]+"."+resn1)
tree_paths.add(resi_to_group[resi2]+"."+resn2)
#Collect entries for tracks (coloring of nodes)
track_entries = []
#helix_colors = ["#1500D6","#003D97","#00E600","#00E600","#FEE200","#FF9000","#FF3B00","#FF0000"]
#helix_colors = ["#78C5D5","#459BA8","#79C268","#C5D747","#F5D63D","#F18C32","#E868A1","#BF63A6"]
helix_colors = {1:"#78C5D5",12:"#5FB0BF",2:"#459BA8",23:"#5FAF88",3:"#79C268",34:"#9FCD58",4:"#C5D747",45:"#DDD742",5:"#F5D63D",56:"#F3B138",6:"#F18C32",67:"#ED7A6A",7:"#E868A1",78:"#D466A4",8:"#BF63A6"}
if isGPCR:
for tp in tree_paths:
try:
#res_name = tp[tp.rfind("x")+1:]
res_name = tp.split(".",1)[1]
res_helix = int(tp[tp.rfind(".")+1:tp.find("x")])
track_entries.append(" { \"name\": \"%s\", \"color\": \"%s\" }"%(res_name,helix_colors[res_helix]))
except ValueError: pass
except IndexError: pass
except KeyError: pass
#Write everything
with open(newpath,"w") as of:
of.write("{\n")
of.write(" \"edges\": [\n")
of.write(",\n".join(edge_entries))
of.write("\n")
of.write(" ],\n")
of.write(" \"nodes\": [\n")
of.write(",\n".join(track_entries))
of.write("\n")
of.write(" ]\n")
of.write("}\n")
else:
for tp in tree_paths:
try:
#res_name = tp[tp.rfind("x")+1:]
res_name = tp[tp.rfind(".")+1:]
res_helix = int(tp[tp.rfind(".")+1:tp.find("x")])
track_entries.append(" { \"nodeName\": \"%s\", \"color\": \"%s\", \"size\":\"1.0\" }"%(res_name,helix_colors[res_helix]))
except ValueError: pass
except IndexError: pass
except KeyError: pass
#Write everything
with open(newpath,"w") as of:
of.write("{\n")
of.write(" \"edges\": [\n")
of.write(",\n".join(edge_entries))
of.write("\n")
of.write(" ],\n")
of.write(" \"trees\": [\n")
of.write(" {\n")
of.write(" \"treeLabel\":\"Helices\",\n")
of.write(" \"treePaths\": [\n")
of.write(",\n".join([" \""+tp+"\"" for tp in tree_paths]))
of.write("\n")
of.write(" ]\n")
of.write(" }\n")
of.write(" ],\n")
of.write(" \"tracks\": [\n")
of.write(" {\n")
of.write(" \"trackLabel\": \"Helices\",\n")
of.write(" \"trackProperties\": [\n")
of.write(",\n".join(track_entries))
of.write("\n")
of.write(" ]}\n")
of.write(" ],\n")
of.write(" \"defaults\":{\"edgeColor\":\"rgba(50,50,50,100)\", \"edgeWidth\":2 }\n")
of.write("}\n")
formatter_class=argparse.RawDescriptionHelpFormatter)
#parser.add_argument('-', "--", help="", default="")
parser.add_argument("-v",
"--verbose",
action="store_true",
help="be verbose")
parser.add_argument("file", help="", default="", nargs='+')
return parser
if __name__ == '__main__':
parser = get_parser()
args = parser.parse_args()
if list != type(args.file):
args.file = [args.file]
for f in args.file:
import mdtraj as md
print(f, '---------------------')
t = md.load(f)
print(md.kabsch_sander(t))
hb = md.wernet_nilsson(t)
print(hb)
print(len(hb[0]))
hb = md.baker_hubbard(t)
print(hb)
print(len(hb))
