def get_distance(file_name, res1, atom1, res2, atom2):
pymol.finish_launching()
cmd.delete('all')
cmd.load(file_name)
cmd.select('atom1', 'resn ' + res1 + ' and name ' + atom1)
cmd.select('atom2', 'resn ' + res2 + ' and name ' + atom2)
print cmd.get_distance('atom1', 'atom2')
def generate_distances(obj1,
startres,
endres,
atname,
filename="",
resi_offset=0):
if (filename != ""):
file = open(filename, 'w')
for first_res_iterate in range(int(startres), int(endres)):
for second_res_iterate in range(
int(first_res_iterate) + 1,
int(endres) + 1):
mydist = cmd.get_distance(
atom1=obj1 + " and resi " + str(first_res_iterate) +
" and name " + atname,
atom2=obj1 + " and resi " + str(second_res_iterate) +
" and name " + atname)
print str(first_res_iterate) + " " + str(
second_res_iterate) + " " + str(mydist)
if (filename != ""):
file.write("AtomPair " + atname + " " +
str(int(first_res_iterate) + int(resi_offset)) +
" " + atname + " " +
str(int(second_res_iterate) + int(resi_offset)) +
" HARMONIC " + str(mydist) + " " + str(2) + "\n")
if (filename != ""):
file.close()
def TMdistCheck(selection, z):
"""
determine cross section distances about origin of trans-membrane region of protein PDB
(distance from origin to protein atoms in xy plane)
"""
cmd.pseudoatom("origin0", pos=[0, 0, 10])
dmax = []
for ang in range(0, 181, 10):
dlist = []
cmd.rotate('z', ang, selection)
xLine = "{} and z > {} and z < {} and y > {} and y < {}".format(selection, -z, z, -z, z)
atoms = cmd.index(xLine)
if len(atoms) == 0:
print("No atoms in {}.".format(xLine))
continue
# find R in only one cross-section
for at1 in cmd.index("origin0"):
for at2 in atoms:
dist = cmd.get_distance(atom1=at1, atom2=at2, state=0)
dlist.append(dist)
dmax.append(max(dlist))
cmd.rotate('z', -ang, selection)
if len(dmax) == 0:
meanXY = -1
else:
meanXY = np.mean(dmax)
cmd.pseudoatom("origin0", pos=[0, 0, 0])
return meanXY
def check_disulphide_criteria(pdb, resnum_i, resnum_j, f):
selection_i = "resi " + str(resnum_i)
selection_j = "resi " + str(resnum_j)
for frame_i in [1, 2]:
rotamer_i_pymol_prefix = "/" + "rotamer_" + str(resnum_i) + "_" + str(frame_i) + "///" + resnum_i + "/"
chi1_i = cmd.get_dihedral(rotamer_i_pymol_prefix + "N", rotamer_i_pymol_prefix + "CA", rotamer_i_pymol_prefix + "CB", rotamer_i_pymol_prefix + "SG")
theta_i = cmd.get_angle(rotamer_i_pymol_prefix + "CA", rotamer_i_pymol_prefix + "CB", rotamer_i_pymol_prefix + "SG")
for frame_j in [1, 2]:
rotamer_j_pymol_prefix = "/" + "rotamer_" + str(resnum_j) + "_" + str(frame_j) + "///" + resnum_j + "/"
chi1_j = cmd.get_dihedral(rotamer_j_pymol_prefix + "N", rotamer_j_pymol_prefix + "CA", rotamer_j_pymol_prefix + "CB", rotamer_j_pymol_prefix + "SG")
theta_j = cmd.get_angle(rotamer_j_pymol_prefix + "CA", rotamer_j_pymol_prefix + "CB", rotamer_j_pymol_prefix + "SG")
chi3 = cmd.get_dihedral(rotamer_i_pymol_prefix + "CB", rotamer_i_pymol_prefix + "SG", rotamer_j_pymol_prefix + "SG", rotamer_j_pymol_prefix + "CB")
#Energy = compute_energy(chi1_i, chi1_j, theta_i, theta_j, chi3)
s_gamma_distance = cmd.get_distance(rotamer_i_pymol_prefix + "SG", rotamer_j_pymol_prefix + "SG")
if (s_gamma_distance < 3 and ((chi3 > -110 and chi3 < -60) or (chi3 > 70 and chi3 < 130))):
print rotamer_i_pymol_prefix, rotamer_j_pymol_prefix, s_gamma_distance, chi3
f.write("%s\t%s\t%f\t%f\n" % (rotamer_i_pymol_prefix, rotamer_j_pymol_prefix, s_gamma_distance, chi3))
rotamer_i = "rotamer_" + str(resnum_i) + "_" + str(frame_i)
rotamer_j = "rotamer_" + str(resnum_j) + "_" + str(frame_j)
cmd.enable(rotamer_i)
cmd.enable(rotamer_j)
cmd.distance(rotamer_i_pymol_prefix + "SG", rotamer_j_pymol_prefix + "SG")
cmd.create(rotamer_i + rotamer_j, rotamer_i_pymol_prefix + "or" + rotamer_j_pymol_prefix)
def evaluate_clash(atom1, atom2, threshold):
"""Evaluate if atoms are closer that trashold.
Parameters
----------
atom1 : String
String selection for atom1.
atom2 : String
String selection for atom1.
threshold : Float
Minimum distance to report a clash.
Returns
-------
bool
If distance is less than threshold, it returns True.
"""
# get distance between atoms
distance = cmd.get_distance(atom1, atom2)
if distance <= threshold:
return True
return False
def f_get_monomer_distances(monomer_PDB, monomer_PDB_type, term_residue, iface_res, iface_residues):
e_dist = -1
s_dist = -1
min_iface_dist = -1
try:
if ((monomer_PDB != "NA") & (iface_res != "NA") & (term_residue != "NA")):
if (monomer_PDB_type == "Model"):
this_PDB_path = PATH_PDB_MONO_MOD
else:
this_PDB_path = PATH_PDB_MONO_EXP
PDB_file = "%s/%s" % (this_PDB_path, monomer_PDB)
cmd.load(PDB_file, "this_mono")
# distance from terminal to interface center
e_dist = cmd.get_distance("first this_mono & name ca & resi %s" % term_residue, "first this_mono & name ca & resi %s" % iface_res)
## minimum distance to interface residues
if (iface_residues != ["NA"]):
if (term_residue in iface_residues):
min_iface_dist = 0
else:
resi_txt = " or ".join(["resi " + this_res for this_res in iface_residues])
min_iface_dist = distancetoatom.distancetoatom(origin="first this_mono & name ca & resi %s" % term_residue, selection="this_mono & name ca & (%s)" % resi_txt, property_name="", cutoff=1000)[2][4]
except:
print "ERROR in monomer distances %s (%s) %s %s\n" % (monomer_PDB, monomer_PDB_type, term_residue, iface_res)
cmd.delete("this_mono")
to_return = { 'e_dist': e_dist }
return to_return
def get_Ca_distance(pymol_object, chainID1, aa_number1, chainID2, aa_number2):
"""Get distance between CA atoms between two residues.
Method to measure the distance between Ca carbon of different residues
defined by their chainID and residue number.
Parameters
----------
pymol_object : String
Name of Pymol object in the session.
chainID1 : String
ChainID of the first residue.
aa_number1 : Integer
Residue number of the first residue.
chainID2 : String
ChainID of the second residue.
aa_number2 : Integer
Residue number of the second residue.
Returns
-------
distance : Float
Value of distance between the two Ca carbons selected.
"""
# Atom selection following Pymol format
atom1 = pymol_object + '//' + chainID1 + '/' + str(aa_number1) + '/CA'
atom2 = pymol_object + '//' + chainID2 + '/' + str(aa_number2) + '/CA'
distance = cmd.get_distance(atom1, atom2)
return distance
def get_6dof_cst(D3, D2, D1, U1, U2, U3):
cur_cst = {
"distanceAB": [0.0, 0.2, 80.0, 0, 0],
"angle_A": [0.0, 5.0, 10.0, 360, 0],
"angle_B": [0.0, 5.0, 10.0, 360, 0],
"torsion_A": [0.0, 10.0, 10.0, 360, 0],
"torsion_AB": [0.0, 10.0, 10.0, 360, 0],
"torsion_B": [0.0, 10.0, 10.0, 360, 0]
}
if U1.split("/")[-1] == "NZ" and U2.split("/")[-1] == "CE" and U3.split(
"/")[-1] == "2HZ": #means processing constraint for LYS
cur_cst = {
"distanceAB": [
0.0, 0.1, 80.0, 1, 0
], #the only difference is periodicity will be set at 1 indicating covalent interaction in the cst file
"angle_A": [0.0, 5.0, 10.0, 360, 0],
"angle_B": [0.0, 5.0, 10.0, 360, 0],
"torsion_A": [0.0, 10.0, 10.0, 360, 0],
"torsion_AB": [0.0, 10.0, 10.0, 360, 0],
"torsion_B": [0.0, 10.0, 10.0, 360, 0]
}
cur_cst["distanceAB"][0] = round(cmd.get_distance(D1, U1), 1)
cur_cst["angle_A"][0] = round(cmd.get_angle(D2, D1, U1), 1)
cur_cst["angle_B"][0] = round(cmd.get_angle(D1, U1, U2), 1)
cur_cst["torsion_A"][0] = round(cmd.get_dihedral(D3, D2, D1, U1), 1)
cur_cst["torsion_AB"][0] = round(cmd.get_dihedral(D2, D1, U1, U2), 1)
cur_cst["torsion_B"][0] = round(cmd.get_dihedral(D1, U1, U2, U3), 1)
return cur_cst
def findAverDist(selection):
dlist = []
cmd.pseudoatom("origin0", pos=[0, 0, 0])
for at1 in cmd.index("origin0"):
for at2 in cmd.index(selection)[::30]:
dist = cmd.get_distance(atom1=at1, atom2=at2, state=0)
dlist.append(dist)
return np.mean(dlist)
def get_terminal_residues_and_euclidian_distances_from_residue(chain, residue, position=0):
N_res = len(cmd.get_model("chain %s & name ca" % chain).atom)
if (position < N_res):
N_term_res = cmd.get_model("chain %s & name ca and resi 1-" % chain).atom[position].resi # smallest residue is 1 (negative residues are ignored)
C_term_res = cmd.get_model("chain %s & name ca" % chain).atom[-(position+1)].resi
d_N_term_iface = cmd.get_distance("first chain %s & name ca & resi %s" % (chain, N_term_res), residue) # we have to use "first" because there was some strange error message
d_C_term_iface = cmd.get_distance("first chain %s & name ca & resi %s" % (chain, C_term_res), residue)
else:
N_term_res = "NA"
C_term_res = "NA"
d_N_term_iface = float('nan')
d_C_term_iface = float('nan')
to_return = {'N_term_res' : N_term_res,
'C_term_res' : C_term_res,
'd_N_term_iface' : d_N_term_iface,
'd_C_term_iface' : d_C_term_iface}
return to_return
def find_beta_hbonds(selection,
mindist,
maxdist,
anglemin,
verbose: bool = False,
nitrogen_atomnames='N+NT',
oxygen_atomnames='O+OT1+OT2',
hydrogen_atomnames='H+HN+HT1+HT2+HT+H1+H2+H3'):
"""
Detect hydrogen bonds in beta peptides (and probably other peptides, too)
Inputs:
selection: a selection containing everything,
"""
donors = cmd.get_model('({}) and name {}'.format(selection,
nitrogen_atomnames))
acceptors = cmd.get_model('({}) and name {}'.format(
selection, oxygen_atomnames))
if verbose:
print('Finding hydrogen bonds in selection {}'.format(selection))
print('Donors: {}'.format(len(donors.atom)))
print('Acceptors: {}'.format(len(acceptors.atom)))
for d in donors.atom:
assert isinstance(d, chempy.Atom)
hydrogens = cmd.get_model(
'(neighbor (({}) and index {})) and name {}'.format(
selection, d.index, hydrogen_atomnames))
if verbose:
print('Looking at donor {}, having {} hydrogens'.format(
d.index, len(hydrogens.atom)))
for h in hydrogens.atom:
assert isinstance(h, chempy.Atom)
for a in acceptors.atom:
assert isinstance(a, chempy.Atom)
# check hydrogen-acceptor distance
dist = cmd.get_distance(
'({}) and name {} and index {}'.format(
selection, oxygen_atomnames, a.index),
'({}) and name {} and index {}'.format(
selection, hydrogen_atomnames, h.index))
cmd.unpick()
angle = cmd.get_angle(
'({}) and name {} and index {}'.format(
selection, oxygen_atomnames,
a.index), '({}) and name {} and index {}'.format(
selection, hydrogen_atomnames, h.index),
'({}) and name {} and index {}'.format(
selection, nitrogen_atomnames, d.index))
if verbose:
print('Distance between hydrogen {} and acceptor {}: {}'.
format(h.index, a.index, dist))
print(
'Angle between donor {}, hydrogen {} and acceptor {}: {}'
.format(d.index, h.index, a.index, angle))
if (dist <= float(maxdist)) and (dist >= float(mindist)) and (
angle >= float(anglemin)):
yield d.index, h.index, a.index, dist, angle
def DrawDRSASA_ByRes(fname):
cols, rows, matrix, direc = ReadProtDNAByResTable(fname)
mtrx = np.array(matrix).flatten()
mtrx = mtrx[mtrx != 0]
mvalue = np.max(mtrx)
minvalue = np.min(mtrx)
mv075 = mvalue * 0.75
median = np.median(mtrx)
avg = np.average(mtrx)
cutoff = mvalue * 0.05
cmd.color("grey", "all")
print median, avg, cutoff, minvalue
Rl = []
Gl = []
Bl = []
for row in range(len(matrix)):
for col in range(len(matrix[row])):
v = float(matrix[row][col])
if v < cutoff:
continue
R = 1.8 * v / mvalue
rid = [str(item) for item in rows[row]]
cid = [str(item) for item in cols[col]]
sele1, resn1 = GenSele(rid[0], rid[1], rid[2])
sele2, resn2 = GenSele(cid[0], cid[1], cid[2])
print(sele1, sele2)
cmd.select("atom1", sele1)
cmd.select("atom2", sele2)
d = cmd.get_distance("atom1", "atom2")
if direc == 0:
resn_s = resn2
elif direc == 1:
resn_s = resn1
if (v >= mv075):
color = "red red"
Rl.append(resn_s)
cmd.color("red", resn_s)
elif (v > median):
color = "green green"
Gl.append(resn_s)
if not resn_s in Rl:
cmd.color("green", resn_s)
else:
color = "blue blue"
if (not resn_s in Rl) and (not resn_s in Gl):
cmd.color("blue", resn_s)
if direc == 0:
cgo_arrow("atom2", "atom1", 0.1, d * 0.25, d * 0.1, R, color,
"/".join(rid) + "_" + "/".join(cid))
elif direc == 1:
cgo_arrow("atom1", "atom2", 0.1, d * 0.25, d * 0.1, R, color,
"/".join(rid) + "_" + "/".join(cid))
def findMaxDist(selection):
"""
finds the longest distance within a molecule
"""
dlist = []
for at1 in cmd.index(selection):
for at2 in cmd.index(selection):
dist = cmd.get_distance(atom1=at1, atom2=at2, state=0)
dlist.append(dist)
dmax = max(dlist)
return dmax
def DistancesFromPKSelection(selections = []):
""" Function doc """
distances = {}
try:
distances['pk1pk2'] = str(cmd.get_distance('pk1','pk2') )
except:
distances['pk1pk2'] = None
try:
distances['pk1pk3'] = str(cmd.get_distance('pk1','pk3') )
except:
distances['pk1pk3'] = None
try:
distances['pk1pk4'] = str(cmd.get_distance('pk1','pk4') )
except:
distances['pk1pk4'] = None
try:
distances['pk2pk3'] = str(cmd.get_distance('pk2','pk3') )
except:
distances['pk2pk3'] = None
try:
distances['pk2pk4'] = str(cmd.get_distance('pk2','pk4') )
except:
distances['pk2pk4'] = None
try:
distances['pk3pk4'] = str(cmd.get_distance('pk3','pk4') )
except:
distances['pk3pk4'] = None
return distances
def get_hbdists(angles, resmin, resmax, resistep, selection='all', helicize=True):
if helicize:
helicize_beta_peptide(angles, selection)
dists = []
for r, rstep in zip(range(resmin, resmax + 1), itertools.cycle(resistep)):
if rstep == 0: continue
if r<resmin or r+rstep<resmin or r>resmax or r+rstep>resmax: continue
selections = ['({}) and resi {} and name HN'.format(selection, r),
'({}) and resi {} and name O'.format(selection, r + rstep)]
if not all([cmd.count_atoms(sel) for sel in selections]):
continue
dists.append(cmd.get_distance(*selections))
return np.array(dists)
def doFinish(self):
r_aA = cmd.get_distance(atom1="pw2", atom2="pw3", state=0)
cmd.distance(self.params_str[0], "pw2", "pw3")
th_a = cmd.get_angle(atom1="pw1", atom2="pw2", atom3="pw3", state=0)
cmd.angle(self.params_str[1], "pw1", "pw2", "pw3")
th_A = cmd.get_angle(atom1="pw2", atom2="pw3", atom3="pw4", state=0)
cmd.angle(self.params_str[2], "pw2", "pw3", "pw4")
if not (r_aA and th_a and th_A):
showerror(self.parent, "Error!",
"Maybe you made a mistake when choosing atoms!")
self.reset()
phi_ba = cmd.get_dihedral(atom1="pw0",
atom2="pw1",
atom3="pw2",
atom4="pw3",
state=0)
cmd.dihedral(self.params_str[3], "pw0", "pw1", "pw2", "pw3")
phi_aA = cmd.get_dihedral(atom1="pw1",
atom2="pw2",
atom3="pw3",
atom4="pw4",
state=0)
cmd.dihedral(self.params_str[4], "pw1", "pw2", "pw3", "pw4")
phi_AB = cmd.get_dihedral(atom1="pw2",
atom2="pw3",
atom3="pw4",
atom4="pw5",
state=0)
cmd.dihedral(self.params_str[5], "pw2", "pw3", "pw4", "pw5")
index_c = cmd.id_atom("pw0")
index_c_name = getAtomString('pw0')
index_b = cmd.id_atom("pw1")
index_b_name = getAtomString('pw1')
index_a = cmd.id_atom("pw2")
index_a_name = getAtomString('pw2')
index_A = cmd.id_atom("pw3")
index_A_name = getAtomString('pw3')
index_B = cmd.id_atom("pw4")
index_B_name = getAtomString('pw4')
index_C = cmd.id_atom("pw5")
index_C_name = getAtomString('pw5')
self.setBondForceParam(r_aA, th_a, th_A, phi_ba, phi_aA, phi_AB,
index_c, index_b, index_a, index_A, index_B,
index_C)
self.setAtomsDef(index_c_name, index_b_name, index_a_name,
index_A_name, index_B_name, index_C_name)
top = Toplevel(
self.parent) # <- freeze when open gro file in pymol 1.X
Output(top, self.bondForceParams, self.atoms_def)
cmd.set_wizard()
def getOrderedDist(self, motif, id):
distDict = {}
orderedDistDict = {}
resilist = []
chain = lib.getChain(id)
for res in motif:
resilist.append(res[1])
for res_1 in motif:
for res_2 in motif:
if res_1[1] != res_2[1]:
if res_1[0] == 'GLY':
atom_1 = 'CA'
elif self.isMetal(res_1[0]):
atom_1 = res_1[0]
else:
atom_1 = 'CB'
if res_2[0] == 'GLY':
atom_2 = 'CA'
elif self.isMetal(res_2[0]):
atom_2 = res_2[0]
else:
atom_2 = 'CB'
cmd.reinitialize()
cmd.fetch(id, async=0, path=glb.FETCH_PATH)
dstr = chain + '/' + res_1[
1] + '/' + atom_1 + ' and ' + chain + '/' + res_2[
1] + '/' + atom_2
try:
d = cmd.get_distance(
chain + '/' + res_1[1] + '/' + atom_1,
chain + '/' + res_2[1] + '/' + atom_2)
distDict.update({res_1[1] + '_' + res_2[1]: d})
except CmdException:
print "Can't calculate distance between ", dstr, " ... :("
orderedDistDict = OrderedDict(
sorted(distDict.items(), key=lambda x: x[1]))
return orderedDistDict
def check_disulphide(pdb, resnum_i, resnum_j, f):
selection_i = "resi " + str(resnum_i)
selection_j = "resi " + str(resnum_j)
# cmd.wizard("mutagenesis")
# cmd.get_wizard().set_mode("CYS")
cmd.do("refresh_wizard")
# Select the rotamer
for frame_i in [1, 2, 3]:
# cmd.do("refresh_wizard")
cmd.get_wizard().do_select(selection_i)
cmd.frame(frame_i)
cmd.create("rotamer_i_" + str(frame_i), "mutation", frame_i, 1)
rotamer_i_pymol_prefix = "/" + "rotamer_i_" + str(frame_i) + "///" + resnum_i + "/"
for frame_j in [1, 2, 3]:
# cmd.do("refresh_wizard")
cmd.get_wizard().do_select(selection_j)
cmd.frame(frame_j)
cmd.create("rotamer_j_" + str(frame_j), "mutation", frame_j, 1)
rotamer_j_pymol_prefix = "/" + "rotamer_j_" + str(frame_j) + "///" + resnum_j + "/"
# s_gamma_distance = cmd.get_distance(rotamer_i_pymol_prefix + "SG", rotamer_j_pymol_prefix + "SG")
# print s_gamma_distance
cmd.set_wizard("clear")
for frame_i in [1, 2, 3]:
rotamer_i_pymol_prefix = "/" + "rotamer_i_" + str(frame_i) + "///" + resnum_i + "/"
for frame_j in [1, 2, 3]:
rotamer_j_pymol_prefix = "/" + "rotamer_j_" + str(frame_j) + "///" + resnum_j + "/"
s_gamma_distance = cmd.get_distance(rotamer_i_pymol_prefix + "SG", rotamer_j_pymol_prefix + "SG")
print s_gamma_distance
def get_bond_lenghts(atom_name, pdb_file):
try:
cmd.load(pdb_file)
n_states = cmd.count_states('all')
n_residues = cmd.count_atoms('name CA')
distance = np.zeros((n_states, n_residues))
for s in range(1, n_states + 1):
conf = []
for i in range(1, n_residues + 1):
try:
dst = cmd.get_distance('resi {} and name CA'.format(i),
'resi {} and name {}'.format(
i, atom_name),
state=s)
conf.append(dst)
except:
conf.append(np.nan)
distance[s - 1] = conf
return distance
except:
print('Cannot open file {}. Please try a diferent PDB file.'.format(
pdb_file))
def find_hbonds(selection_donor_and_hydrogen,
selection_acceptor=None,
dmin: float = 1.,
dmax: float = 2.5,
anglemin: float = 135):
dmin = float(dmin)
dmax = float(dmax)
anglemin = float(anglemin)
selection_hydrogen = '({}) and (e. H)'.format(selection_donor_and_hydrogen)
found_bonds = []
if selection_acceptor is None:
selection_acceptor = selection_donor_and_hydrogen
for acceptor in iterate_indices(
'({}) and (e. N+O)'.format(selection_acceptor)):
print('Trying acceptor idx {}'.format(acceptor))
for hydrogen in iterate_indices(
'({}) and (e. H) and not (neighbor (idx {} and ({})))'.format(
selection_hydrogen, acceptor, selection_acceptor)):
donors = list(
iterate_indices(
'neighbor ((idx {}) and ({})) and not ((idx {}) and ({}))'.
format(hydrogen, selection_hydrogen, acceptor,
selection_acceptor)))
donor = donors[0]
dist = cmd.get_distance(
'(idx {}) and ({})'.format(hydrogen, selection_hydrogen),
'(idx {}) and ({})'.format(acceptor, selection_acceptor))
angle = cmd.get_angle(
'(idx {}) and ({})'.format(donor,
selection_donor_and_hydrogen),
'(idx {}) and ({})'.format(hydrogen, selection_hydrogen),
'(idx {}) and ({})'.format(acceptor, selection_acceptor))
if dist >= dmin and dist <= dmax and angle >= anglemin:
found_bonds.append((donor, hydrogen, acceptor, dist, angle))
for donor, hydrogen, acceptor, dist, angle in found_bonds:
yield (acceptor, hydrogen, dist)
def get_euclidian_distances_bw_terminals():
# get N_terms and C_terms (only CA atoms)
cmd.select("A_N_term", "first chain A & name ca")
cmd.select("A_C_term", "last chain A & name ca")
cmd.select("B_N_term", "first chain B & name ca")
cmd.select("B_C_term", "last chain B & name ca")
# euclidian distance between terminals
d_A_N_term_to_B_N_term = cmd.get_distance("A_N_term", "B_N_term")
d_A_N_term_to_B_C_term = cmd.get_distance("A_N_term", "B_C_term")
d_A_N_term_to_A_C_term = cmd.get_distance("A_N_term", "A_C_term")
d_A_C_term_to_B_N_term = cmd.get_distance("A_C_term", "B_N_term")
d_A_C_term_to_B_C_term = cmd.get_distance("A_C_term", "B_C_term")
d_B_N_term_to_B_C_term = cmd.get_distance("B_N_term", "B_C_term")
#return d_A_N_term_to_B_N_term, d_A_N_term_to_B_C_term, d_A_N_term_to_A_C_term, d_A_C_term_to_B_N_term, d_A_C_term_to_B_C_term, d_B_N_term_to_B_C_term
to_return = {'d_A_N_term_to_B_N_term' : d_A_N_term_to_B_N_term,
'd_A_N_term_to_B_C_term' : d_A_N_term_to_B_C_term,
'd_A_N_term_to_A_C_term' : d_A_N_term_to_A_C_term,
'd_A_C_term_to_B_N_term' : d_A_C_term_to_B_N_term,
'd_A_C_term_to_B_C_term' : d_A_C_term_to_B_C_term,
'd_B_N_term_to_B_C_term' : d_B_N_term_to_B_C_term}
return to_return
write_cst = open('cstfile.txt', 'w')
for i in [x for x in range(1, 248) if x not in missing_positions]:
#determining number of missing positions for with respect to position i
minus_i = 0
for miss_i in range(len(missing_positions)):
if missing_positions[miss_i] < i:
minus_i += 1
for j in [x for x in range(i + 1, 249) if x not in missing_positions]:
#determining number of missing positions for with respect to position j
minus_j = 0
for miss_j in range(len(missing_positions)):
if missing_positions[miss_j] < j:
minus_j += 1
distance = cmd.get_distance(name + ' and name CA and resi ' + str(i),
name + ' and name CA and resi ' + str(j))
if distance < cutoff:
element = [i - minus_i, j - minus_j, distance]
atom_list.append(element)
for element in atom_list:
write_cst.write('AtomPair CA ' + str(element[0]) + ' CA ' +
str(element[1]) + ' HARMONIC ' + str(element[2]) +
' 2.0\n')
write_cst.close()
for filename in filenames:
with open(filename, 'r') as f:
lines = f.readlines()
lines = list(filter(filter_func, lines))
dis_pairs.extend(list(map(map_func, lines)))
restraints.extend(list(map(map_func2, lines)))
out_lines = []
for dis_pair, restraint in zip(dis_pairs, restraints):
group1 = "(id %d)" % dis_pair[0]
group2 = "(id %d)" % dis_pair[1]
cmd.distance("%d-%d" % (dis_pair[0], dis_pair[1]), group1, group2)
resns = []
resis = []
atoms = []
cmd.iterate("id %d+%d" % dis_pair, "resns.append(resn)")
cmd.iterate("id %d+%d" % dis_pair, "resis.append(resi)")
cmd.iterate("id %d+%d" % dis_pair, "atoms.append(name)")
distance = cmd.get_distance(atom1=group1, atom2=group2)
out_lines.append("[ %s%s(%s)-%s%s(%s) ~ %.2fA (%s, %s, %s)]\n" %
((resns[0], resis[0], atoms[0], resns[1], resis[1],
atoms[1], distance) + restraint))
out_lines.append("%d %d\n" % dis_pair)
# write dis_pairs to distance_pairs.ndx for analysis
with open("dist_out.ndx", 'w') as f:
for line in out_lines:
f.write(line)
print(line)
def set_dihedral_angles_update(pymol_object, chainID, Aa_list,
phi_psi_list, protect_selection,
moving_atom, target_atom, start_num=1):
"""Set several dihedral angles to a set of amino acids.
Function that will change the dihedral angles for each amino acid in
Aa_list for the ones in the phi_psi_list. Amino acids selected in
protect_selection will not move. After changing the angles the new
structure is saved.
This method is an updated version of "set_dihedral_angles". Instead of
changing the angles of the structures and then setting them back to
the original values, this method creates a copy of the pymol object
and then changes its angles. Thus, this does not modify the initial
structure.
This method also returns a list with information regarding the amino acid
modified, the angle used, the distance between moving atom and target atom
and the pdb file created. This is useful to create a log of the
modifications made.
Parameters
----------
pymol_object : String
Name of Pymol object in the session.
chainID : String
ChainID of residue.
Aa_list : List
List of amino acid numbers (int).
phi_psi_list : List
List of tuples containing phi and psi angles.
protect_selection : String
Slection string from pymol_object which will remain static.
Example: '//X/44-316/*'
moving_atom : String
Atom selection for atom 1 used for distance mesurement, ussualy from
chain being modified.
target_atom : String
Atom selection for atom 2 used for distance mesurement.
start_num : Int, optional
Number used to start the pdb files counter. The default is 1.
Returns
-------
pdb_files : List
List of tuples containing information about the output pdb file,
distance between target-moving atoms, aminoacid modified and new phi
and psi angles: (pdb_name,distance, aa_number, (new_phi, new_psi)).
"""
# track of PDB file numbers
pdb_num = start_num
# pdb_file_list = [] #PDB file name list as output
pdb_files = []
for aa_number in Aa_list:
for dihedral_angles in phi_psi_list:
# Create a copy of object to be modified
cmd.copy('obj_copy', pymol_object)
# Protect residues
cmd.protect('obj_copy'+protect_selection)
new_phi, new_psi = dihedral_angles
set_phi_psi_angles('obj_copy', chainID, aa_number,
phi=new_phi, psi=new_psi)
# get distance
distance = cmd.get_distance('obj_copy' + moving_atom, target_atom)
# save new structure with pdb_num as name
pdb_name = '{}_{}.pdb'.format(pymol_object, pdb_num)
cmd.save(pdb_name, 'obj_copy')
pdb_files.append((pdb_name, distance, aa_number, (new_phi, new_psi)))
pdb_num += 1
# Remove the object copy
cmd.delete('obj_copy')
print('Finished!')
return pdb_files
def DrawDRSASA_ByAtom(fname, mode='0'):
mode = int(mode)
cols, rows, matrix, direc, sumv = ReadDRSASAIntTable(fname)
mtrx = np.array(matrix).flatten()
mtrx = mtrx[mtrx != 0]
mvalue = np.max(mtrx)
minvalue = np.min(mtrx)
mv075 = mvalue * 0.75
median = np.median(mtrx)
avg = np.average(mtrx)
cutoff = mvalue * 0.05
cmd.color("grey", "all")
print median, avg, cutoff, minvalue
Rl = []
Gl = []
Bl = []
cmd.set('suspend_updates', 'on')
view = cmd.get_view()
for row in range(len(matrix)):
for col in range(len(matrix[row])):
v = float(matrix[row][col])
if v < cutoff:
continue
R = 1.8 * v / mvalue
nR = v / mvalue
colorn = "drsasa_" + str(row) + "_" + str(col)
cmd.set_color(colorn, (int(255 * nR), 0, 255 - int(255 * nR)))
rid = [str(item) for item in rows[row]]
cid = [str(item) for item in cols[col]]
print(rid, cid)
sele1 = GenSeleAtom(rid[0], rid[1], rid[2], rid[3])
sele2 = GenSeleAtom(cid[0], cid[1], cid[2], cid[3])
print(sele1, sele2)
cmd.select("atom1", sele1)
cmd.select("atom2", sele2)
d = cmd.get_distance("atom1", "atom2")
if direc == "row":
atom_s = sele2
elif direc == "col":
atom_s = sele1
#name = "/".join(rid)+"_"+"/".join(cid)
name = "a_" + str(row) + "_" + str(col)
if mode == 0:
if (v >= mv075):
color = colorn + " " + colorn
Rl.append(atom_s)
cmd.color("red", atom_s)
elif (v > median):
color = "green green"
Gl.append(atom_s)
if not atom_s in Rl:
cmd.color("green", atom_s)
else:
color = "blue blue"
if (not atom_s in Rl) and (not atom_s in Gl):
cmd.color("blue", atom_s)
elif mode == 1:
color = colorn + " " + colorn
if direc == "row":
if mode == 0:
cgo_arrow("atom2", "atom1", 0.1, d * 0.25, d * 0.1, R,
color, name)
elif mode == 1:
cgo_arrow("atom2", "atom1", 0.1, d * 0.25, d * 0.1, 0.2,
color, name)
elif direc == "col":
if mode == 0:
cgo_arrow("atom1", "atom2", 0.1, d * 0.25, d * 0.1, R,
color, name)
elif mode == 1:
cgo_arrow("atom1", "atom2", 0.1, d * 0.25, d * 0.1, 0.2,
color, name)
cmd.set_view(view)
cmd.set('suspend_updates', 'off')
def ens_measure(pk1 = None,
pk2 = None,
pk3 = None,
pk4 = None,
name = None,
log = None,
verbose = True):
'''
DESCRIPTION
Statistics from ensemble structure measurements. If:
2 selections give = distance
3 selections give = angle
4 selections give = dihedral angle
USAGE
ens_measure pk1, pk2, pk3, pk4, name, log, verbose
ARGUMENTS
log = name of log file
verbose = prints individual measurements
EXAMPLE
ens_measure atom1, atom2, name = 'measure', log 'ens.log'
'''
print >> log, '\nEnsemble measurement'
if [pk1, pk2, pk3, pk4].count(None) > 2:
print '\nERROR: Please supply at least 2 seletions'
return
number_models = cmd.count_states(pk1)
measurements = []
# distance
if [pk1, pk2, pk3, pk4].count(None) == 2:
print >> log, 'Distance'
if name == None: name = 'ens_distance'
# display as object
cmd.distance(name = name,
selection1 = pk1,
selection2 = pk2)
# get individual values
for n in xrange(number_models):
measurements.append( cmd.get_distance(pk1, pk2, n+1) )
assert len(measurements) == number_models
# angle
if [pk1, pk2, pk3, pk4].count(None) == 1:
print >> log, 'Angle'
# display as object
if name == None: name = 'ens_angle'
cmd.angle(name = name,
selection1 = pk1,
selection2 = pk2,
selection3 = pk3)
# get individual values
for n in xrange(number_models):
measurements.append( cmd.get_angle(atom1 = pk1,
atom2 = pk2,
atom3 = pk3,
state = n+1) )
assert len(measurements) == number_models
# Dihedral angle
if [pk1, pk2, pk3, pk4].count(None) == 0:
print >> log, 'Dihedral angle'
# display as object
if name == None: name = 'ens_dihedral'
cmd.dihedral(name = name,
selection1 = pk1,
selection2 = pk2,
selection3 = pk3,
selection4 = pk4)
# get individual values
for n in xrange(number_models):
measurements.append( cmd.get_dihedral(atom1 = pk1,
atom2 = pk2,
atom3 = pk3,
atom4 = pk4,
state = n+1) )
assert len(measurements) == number_models
# print stats
if verbose:
print >> log, ' State Value'
for n, measurement in enumerate(measurements):
print >> log, ' %4d %3.3f '%(n+1, measurement)
print >> log, '\nMeasurement statistics'
print_array_stats(array = measurements,
log = log)
def distance(a, idA, b, idB):
atomA = "%s and id %s" % (a, idA)
atomB = "%s and id %s" % (b, idB)
#print atomA
#print atomB
return cmd.get_distance(atomA, atomB)
def ens_measure(pk1=None,
pk2=None,
pk3=None,
pk4=None,
name=None,
log=None,
verbose=True):
'''
DESCRIPTION
Statistics from ensemble structure measurements. If:
2 selections give = distance
3 selections give = angle
4 selections give = dihedral angle
USAGE
ens_measure pk1, pk2, pk3, pk4, name, log, verbose
ARGUMENTS
log = name of log file
verbose = prints individual measurements
EXAMPLE
ens_measure atom1, atom2, name = 'measure', log 'ens.log'
'''
print('\nEnsemble measurement', file=log)
if [pk1, pk2, pk3, pk4].count(None) > 2:
print('\nERROR: Please supply at least 2 seletions')
return
number_models = cmd.count_states(pk1)
measurements = []
# distance
if [pk1, pk2, pk3, pk4].count(None) == 2:
print('Distance', file=log)
if name == None: name = 'ens_distance'
# display as object
cmd.distance(name=name, selection1=pk1, selection2=pk2)
# get individual values
for n in range(number_models):
measurements.append(cmd.get_distance(pk1, pk2, n + 1))
assert len(measurements) == number_models
# angle
if [pk1, pk2, pk3, pk4].count(None) == 1:
print('Angle', file=log)
# display as object
if name == None: name = 'ens_angle'
cmd.angle(name=name, selection1=pk1, selection2=pk2, selection3=pk3)
# get individual values
for n in range(number_models):
measurements.append(
cmd.get_angle(atom1=pk1, atom2=pk2, atom3=pk3, state=n + 1))
assert len(measurements) == number_models
# Dihedral angle
if [pk1, pk2, pk3, pk4].count(None) == 0:
print('Dihedral angle', file=log)
# display as object
if name == None: name = 'ens_dihedral'
cmd.dihedral(name=name,
selection1=pk1,
selection2=pk2,
selection3=pk3,
selection4=pk4)
# get individual values
for n in range(number_models):
measurements.append(
cmd.get_dihedral(atom1=pk1,
atom2=pk2,
atom3=pk3,
atom4=pk4,
state=n + 1))
assert len(measurements) == number_models
# print stats
if verbose:
print(' State Value', file=log)
for n, measurement in enumerate(measurements):
print(' %4d %3.3f ' % (n + 1, measurement), file=log)
print('\nMeasurement statistics', file=log)
print_array_stats(array=measurements, log=log)
def save_shell_figures(mol_pdb_file,
shell_pdb_files,
graph,
atom_colors,
dpi=3000,
overwrite=False,
out_dir=""):
"""Save all mol/shell/substructure figures."""
cmd.reinitialize()
sleep(0.5)
mol_color_hetero_img = os.path.join(out_dir, "mol_plain.png")
mol_color_types_img = os.path.join(out_dir, "mol_atom_types.png")
pymol_load_with_defaults(mol_pdb_file)
cmd.zoom('all', complete=1, buffer=1)
if overwrite or not os.path.isfile(mol_color_hetero_img):
cmd.util.cbaw()
pymol_color_atoms_by_elem()
cmd.ray(dpi)
cmd.png(mol_color_hetero_img)
partial_opaque_to_opaque(mol_color_hetero_img)
sleep(0.5)
if overwrite or not os.path.isfile(mol_color_types_img):
pymol_color_by_atom_types(atom_colors)
cmd.ray(dpi)
cmd.png(mol_color_types_img)
partial_opaque_to_opaque(mol_color_types_img)
sleep(0.5)
stored.names_ids = []
cmd.iterate("all", "stored.names_ids.append((ID, name))")
ids_names_map = dict(stored.names_ids)
atom_colors = {
ids_names_map[atom_id + 1]: color
for atom_id, color in atom_colors.items()
}
vector_shell_pdb_file = None
vector_shell = None
radii = set()
for pdb_file in shell_pdb_files:
identifier = int(os.path.basename(pdb_file).split('.')[0])
shell_image_file = os.path.join(out_dir,
"{}_shell.png".format(identifier))
graph.node[identifier]["image"] = shell_image_file
if not overwrite and os.path.isfile(shell_image_file):
continue
cmd.reinitialize()
pymol_load_with_defaults(pdb_file)
shell = list(graph.node[identifier]["shell"])[0]
radius = shell.radius
if radius > 0:
radii.add(radius)
draw_shell_sphere(radius, linespacing=radius * .15 / 1.5)
cmd.center('sphere_*')
cmd.origin('sphere_*')
if vector_shell is None and round(
radius / RADIUS_MULTIPLIER) == 1.:
vector_shell_pdb_file = pdb_file
vector_shell = shell
pymol_color_by_atom_types(atom_colors, mode="name")
cmd.turn('y', 90)
cmd.turn('x', 35)
cmd.zoom('all', complete=1)
cmd.ray(dpi)
cmd.png(shell_image_file)
partial_opaque_to_opaque(shell_image_file)
sleep(0.5)
vector_figure = os.path.join(out_dir, "vector_axes.png")
if overwrite or not os.path.isfile(vector_figure):
cmd.reinitialize()
pymol_load_with_defaults(vector_shell_pdb_file)
radius = vector_shell.radius
draw_shell_sphere(radius, linespacing=radius * .15 / 1.5)
center_atom = vector_shell.center_atom
for atom in vector_shell.atoms:
dist = cmd.get_distance(
"{} and id {}".format(vector_shell.identifier, center_atom),
"{} and id {}".format(vector_shell.identifier, atom),
state=1)
if dist <= radius:
coords = cmd.get_coords("{} and id {}".format(
vector_shell.identifier, atom),
state=1)[0]
draw_sphere_marker(radius, coords)
cmd.center('sphere_*')
cmd.origin('sphere_*')
pymol_color_by_atom_types(atom_colors, mode="name")
cmd.turn('y', 90)
cmd.turn('x', 35)
cmd.delete(str(vector_shell.identifier))
cmd.zoom('all', complete=1)
cmd.ray(dpi)
cmd.png(vector_figure)
partial_opaque_to_opaque(vector_figure)
sleep(0.5)
axes_figure = os.path.join(out_dir, "axes.png")
if overwrite or not os.path.isfile(axes_figure):
cmd.reinitialize()
pymol_load_with_defaults()
draw_shell_sphere(min(radii), linespacing=min(radii) * .15 / 1.5)
sleep(.1)
draw_xy_axes(scale=min(radii))
sleep(.1)
cmd.turn('y', 90)
cmd.turn('x', 35)
cmd.zoom('all', complete=1)
cmd.ray(dpi)
cmd.png(axes_figure)
partial_opaque_to_opaque(axes_figure)
sleep(0.5)
from pymol import cmd
import json
from tqdm import tqdm
distances = {}
for i in tqdm(range(23, 1017)):
for j in range(i + 1, 1017):
distances["{} {}".format(i, j)] = cmd.get_distance(
atom1="{}/CA".format(i), atom2="{}/CA".format(j), state=-1)
with open("distances.json", "w") as fh:
json.dump(distances, fh, indent=4)
with open("distances.json", "r") as fh:
dist = json.load(fh)
ff = ob.OBForceField.FindForceField(forcefield)
ff.Setup(mol)
if cutoff == True:
ff.EnableCutOff(True)
ff.SetVDWCutOff(cut_vdw)
ff.SetElectrostaticCutOff(cut_elec)
if method == 'cg':
ff.ConjugateGradients(nsteps, conv)
else:
ff.SteepestDescent(nsteps, conv)
ff.GetCoordinates(mol)
nrg = ff.Energy()
pdb_string = obconversion.WriteString(mol)
cmd.delete(name)
if name == 'all':
name = 'all_'
cmd.read_pdbstr(pdb_string, name)
return nrg
pbl = []
for res_name_i in aa:
for res_name_j in aa:
cmd.fab(res_name_i + res_name_j)
minimize(selection=sel, forcefield='GAFF')
a = cmd.get_distance('resi 1 and name C', 'resi 2 and name N')
pbl.append(a)
cmd.delete('all')
mean = sum(pbl) / len(pbl)
print(mean)
def run(self):
my_view = cmd.get_view()
#mark Search
if self.mode == 'Search':
#show message
cmd.wizard("message", "Searching conformers...")
cmd.refresh()
if self.currentLabel.uid != "Rx":
self.search()
print "Creating Rotamers in PyMOL...",
for aRotamer in self.currentLabel.ensembles["mW"].rotamers:
self.createRotamerInPymol(aRotamer, "mW")
# if self.thoroughness == "painstaking" and self.currentLabel.uid == "R1":
# scoringWeights = {"totalContactWeight": 0.0, "typeOfContactWeight": 1.0}
# for aRotamer in self.currentLabel.ensembles["mW"].rotamers:
# aRotamer.score(scoringWeights)
# self.currentLabel.ensembles["mW"].sortRotamers("chi2")
# numberOfRotamers = len(self.currentLabel.ensembles["mW"].rotamers)
# newEnsemble = ensemble.Ensemble()
# newEnsemble.name = "contactFit"
# newEnsemble.rotamers = self.currentLabel.ensembles["mW"].rotamers[0:20]
# self.currentLabel.ensembles["contactFit"] = newEnsemble
# for aRotamer in self.currentLabel.ensembles["contactFit"].rotamers:
# self.createRotamerInPymol(aRotamer, "contactFit")
print "done!"
elif self.currentLabel.uid == "Rx":
ca1 = numpy.array(
cmd.get_model(self.residue1Name + " & name CA",
1).get_coord_list()[0])
ca2 = numpy.array(
cmd.get_model(self.residue2Name + " & name CA",
1).get_coord_list()[0])
try:
cb1 = numpy.array(
cmd.get_model(self.residue1Name + " & name CB",
1).get_coord_list()[0])
except:
cb1 = ca1
try:
cb2 = numpy.array(
cmd.get_model(self.residue2Name + " & name CB",
1).get_coord_list()[0])
except:
cb2 = ca2
environmentatoms = numpy.array(cmd.get_model("(%s within 10 of %s or %s) and not (%s or %s)" \
%(self.pickedObject1, \
self.residue1Name, \
self.residue2Name, \
self.residue1Name, \
self.residue2Name), 1).get_coord_list())
anchor1rotamers = self.currentLabel.calculateCone(
ca1, cb1, environmentatoms, numberOfAtoms=8000)
anchor2rotamers = self.currentLabel.calculateCone(
ca2, cb2, environmentatoms, numberOfAtoms=8000)
solutions1 = []
solutions2 = []
for anchor1rotamer in anchor1rotamers:
anAtom = anchor1rotamer.atoms["N1"]
solutions1.append(anAtom.coordinate)
for anchor2rotamer in anchor2rotamers:
anAtom = anchor2rotamer.atoms["N1"]
solutions2.append(anAtom.coordinate)
#determine common accessible volume
distances1 = self.currentLabel.quick_map(solutions1, cb2)
distances2 = self.currentLabel.quick_map(solutions2, cb1)
indices1 = numpy.where(numpy.any(distances1 > 6, axis=1))
indices2 = numpy.where(numpy.any(distances2 > 6, axis=1))
solutions1 = numpy.delete(solutions1, indices1, 0)
solutions2 = numpy.delete(solutions2, indices2, 0)
solutions = numpy.concatenate((solutions1, solutions2))
#create resulting ensemble
newEnsemble = ensemble.Ensemble()
newEnsemble.name = "mW"
id = 0
newRotamers = []
if len(solutions) > 0:
for solution in solutions:
newRotamer = rotamer.Rotamer()
thisAtom = atom.Atom()
thisAtom.coordinate = solution
thisAtom.name = "N1"
thisAtom.element = "N"
newRotamer.id = id
newRotamer.atoms["N1"] = thisAtom
id += 1
newRotamers.append(newRotamer)
else:
print "Did not find any possible N1 locations. Are the two anchorpoints too far apart?"
newEnsemble.rotamers = newRotamers
self.currentLabel.ensembles[newEnsemble.name] = newEnsemble
cmd.load(
"%s/labels/%s" % (self.path, self.currentLabel.pdbFile),
"currentLabel")
for aRotamer in self.currentLabel.ensembles["mW"].rotamers:
self.createRotamerInPymol(aRotamer, "mW")
self.numberOfLabel += 1
self.finalCosmetics()
#dismiss message
cmd.wizard()
#mark Measure
elif self.mode == "Measure":
cmd.wizard("message", "Calculating distances...")
cmd.refresh()
print "\n\n\nDistance calculation:\n"
print "The dashed lines are the c-beta distance (green),\nand the distance between the geometric averages\nof the two ensembles (yellow).\n"
print "The following statistics refer to the distribution\nof the individual distances between all conformers (may take a while):\n"
#find out what the selections are
stored.label1 = []
stored.label2 = []
stored.label1Coordinates = []
stored.label2Coordinates = []
stored.atomNames1 = []
stored.atomNames2 = []
#extract label info
cmd.iterate(self.residue1Name, 'stored.label1.append(segi)')
cmd.iterate(self.residue2Name, 'stored.label2.append(segi)')
cmd.iterate(self.residue1Name, 'stored.atomNames1.append(name)')
cmd.iterate(self.residue2Name, 'stored.atomNames2.append(name)')
try:
label1 = label.Label.fromfile("labels/%s.txt" %
stored.label1[0])
cmd.iterate_state(
0,
"%s & name %s" % (self.residue1Name, label1.spinLocation),
'stored.label1Coordinates.append((x,y,z))')
except:
cmd.iterate_state(0, "%s" % (self.residue1Name),
'stored.label1Coordinates.append((x,y,z))')
try:
label2 = label.Label.fromfile("labels/%s.txt" %
stored.label2[0])
cmd.iterate_state(
0,
"%s & name %s" % (self.residue2Name, label2.spinLocation),
'stored.label2Coordinates.append((x,y,z))')
except:
cmd.iterate_state(0, "%s" % (self.residue2Name),
'stored.label2Coordinates.append((x,y,z))')
#calculate distances
distances = distanceDistribution.DistanceDistribution()
dist = distances.calculateDistanceDistribution(
stored.label1Coordinates, stored.label2Coordinates)
#create pseudoatom at average coordinate of each ensemble and display the distance between them
atoms1 = numpy.array(stored.label1Coordinates)
atoms2 = numpy.array(stored.label2Coordinates)
avgAtoms1 = numpy.average(atoms1, axis=0)
avgAtoms2 = numpy.average(atoms2, axis=0)
self.createPseudoatom(avgAtoms1, "tmp_average1", 1)
self.createPseudoatom(avgAtoms2, "tmp_average2", 1)
cmd.distance(self.object_prefix + "avg", "tmp_average1 & name PS1",
"tmp_average2 & name PS1")
cmd.delete("tmp_average1")
cmd.delete("tmp_average2")
#cbeta distance if cbeta is present in both selections
#cBetaDistance = 0.0
if any("CB" in atom for atom in stored.atomNames1) and any(
"CB" in atom for atom in stored.atomNames2):
cmd.distance(self.object_prefix + "cBeta",
self.residue1Name + " & name CB",
self.residue2Name + " & name CB")
#for some reason, cmd.distance does not return the correct distance. Although it is shown in the viewer...
#get_distance gives the correct distance, but does not create the object in the viewer.
cBetaDistance = cmd.get_distance(
self.residue1Name + " & name CB",
self.residue2Name + " & name CB")
cmd.set("dash_color", "green", self.object_prefix + "cBeta")
histogram = numpy.histogram(dist, numpy.arange(100))
envelopePlot = numpy.zeros((100, 2))
envelopePlot[0:99] = numpy.column_stack(
(histogram[1][0:len(histogram[1]) - 1], histogram[0]))
#put point in mid of bin
envelopePlot[:, 0] += 0.5
normEnvelopePlot = numpy.copy(envelopePlot)
normEnvelopePlot[:, 1] = normEnvelopePlot[:, 1] / numpy.amax(
histogram[0])
#combine dist and histogram to single array before output
output = numpy.column_stack((envelopePlot, normEnvelopePlot[:, 1]))
averageDistance = numpy.average(dist)
#make graph dictionary for mtsslPlotter
graphtitle = "%s-%s" % (self.residue1Name, self.residue2Name)
xlim = [0, 100]
ylim = [0, 1]
plotDictionary = self.makeGraphDataDictionary(
graphtitle, "DistanceDistribution", "Distance (Angstrom)",
"Relative Probability", output[:, 0], output[:,
2], 0, xlim, ylim)
stored.plots.append(plotDictionary)
print "Distribution plot added to memory. Inspect it with mtsslPlotter."
#Copy to clipboard
header = "Dist. Count Norm.Count\n"
outputStr = header + numpy.array_str(output)
outputStr = outputStr.replace("[", "")
outputStr = outputStr.replace("]", "")
self.copyStringToClipboard(outputStr)
#Write to file
if self.writeToFile:
try:
filename = "%s-%s" % (self.residue1Name, self.residue2Name)
numpy.savetxt(filename + ".txt", output, delimiter='\t')
print "Written to file:"
print "%s/%s" % (os.getcwd(), filename)
except:
print "Writing to file failed!"
print self.calculateStatistics2(dist)
try:
if cBetaDistance > 0.0:
print "Cbeta distance: %3.1f" % cBetaDistance
except:
print "No Cbeta distance."
cmd.wizard()
#mark Distance Map
elif self.mode == "Distance Map":
#show message
cmd.wizard("message",
"Calculating distance maps. Please be patient...")
cmd.refresh()
dm = distanceMap.DistanceMap(self.writeToFile, self.currentLabel,
self.homoOligomerMode)
if self.pickedObject1 == self.pickedObject2:
dm.intraDistanceMap(self.pickedObject1)
else:
dm.interDistanceMap(self.pickedObject1, self.pickedObject2)
print "Done!"
cmd.wizard()
self.cleanupAfterRun()
cmd.set_view(my_view)
def builderCorona(theta, fi, detergent, protein, detR):
# Build symmates with desired rotations
refresh()
cmd.pseudoatom("origin0"+protein, pos=[0, 0, 0])
thetaSteps = len(theta)
angleVer = np.linspace(-90, 90, thetaSteps)
i = 0
roffi = []
# find surface grid todo: choose better one of these two approaches
# for f in fi:
# find distances to surface
# cmd.rotate("z", (str)(-f), protein)
# xLine = "{} and z > {} and z < {} and y > {} and y < {} and x > 0".format(protein, -detR, detR, -5, 5)
# atoms = cmd.index(xLine)
# dlist = []
# if len(atoms) == 0:
# print("No atoms at azimuthal angle: Phi = {}.".format(f))
# continue
# # find R in only one cross-section
# for at1 in cmd.index("origin0"):
# for at2 in atoms[::10]:
# dist = cmd.get_distance(atom1=at1, atom2=at2, state=0)
# dlist.append(dist)
# r = max(dlist) # * np.cos(np.deg2rad(t))
# roffi.append(r)
# cmd.rotate("z", (str)(f), protein)
r = 0
cmd.rotate("z", -90, detergent)
for t, a in zip(theta, angleVer):
for n, f in enumerate(fi):
###################EXPERIMENTAL###################
cmd.rotate("z", str(-f), protein)
cmd.translate("[0,0,{}]".format(r * np.sin(np.deg2rad(t))), protein)
xLine = "{} and z > {} and z < {} and y > {} and y < {} and x > 0 and name CA".format(protein, -detR, detR,
-1, 1)
atoms = cmd.index(xLine)
dlist = []
if len(atoms) == 0:
print("No atoms at azimuthal angle: Phi = {}.".format(f))
continue
# find R in only one cross-section
for at1 in cmd.index("origin0"):
for at2 in atoms:
dist = cmd.get_distance(atom1=at1, atom2=at2, state=0)
dlist.append(dist)
r = max(dlist) # * np.cos(np.deg2rad(t))
roffi.append(r)
cmd.rotate("z", str(f), protein)
cmd.translate("[0,0,{}]".format(-r * np.sin(np.deg2rad(t))), protein)
####################################################
# r = roffi[n] / np.cos(np.deg2rad(t))
i += 1
cmd.copy("seg{}".format(i), detergent)
cmd.alter("seg{}".format(i), "resi={}".format(i)) # assign residue numbers
# corona
cmd.rotate("y", str(-a), "seg{}".format(i))
cmd.translate("[{},0,0]".format(r + 0.6 * detR * np.cos(np.deg2rad(a))), "seg{}".format(i))
cmd.translate("[0,0,{}]".format((r + detR) * np.sin(np.deg2rad(t))), "seg{}".format(i))
cmd.rotate("z", str(f), "seg{}".format(i))
# print(f"seg{i} phi = {f} theta = {t} Distance: {r}") #DEBUG
cmd.create("corona", "seg*")
cmd.delete("seg*")
cmd.delete("origin0"+protein)
