def collect_ftmap(cls):
"""Collect cluster objects from an FTMap session."""
for obj in pm.get_object_list():
if obj.endswith(".pdb"):
new_name = obj[:-4].replace("crosscluster", "consensus")
pm.set_name(obj, new_name)
yield from cls.collect()
def cell_shift(object, dX, dY, dZ, rename = 1):
if rename:
oldName = object.split("_")
oldPre = oldName[0]
oldX = int(oldName[1])
oldY = int(oldName[2])
oldZ = int(oldName[3])
newX = "_" + str(int(dX) + oldX)
newY = "_" + str(int(dY) + oldY)
newZ = "_" + str(int(dZ) + oldZ)
newName = oldPre + newX + newY + newZ
#if cmd.get_names().find(newName) != -1:
# print "Symmetry partner already exists in destination position!"
# quit()
cmd.set_name(object, newName)
object = newName
stored.shift = [float(dX),float(dY),float(dZ)]
stored.sgInfo = cmd.get_symmetry(object)
a,b,c,alpha,beta,gamma = stored.sgInfo[0:6]
ca = math.cos(math.radians(alpha))
cb = math.cos(math.radians(beta))
cg = math.cos(math.radians(gamma))
sb = math.sin(math.radians(beta))
sg = math.sin(math.radians(gamma))
stored.fracToOrt = N.array([[a, b * cg, c * cb],
[0.0, b * sg, c * (ca - cb * cg) / sg],
[0.0, 0.0, c * sb * math.sqrt(1.0 - ((cb * cg - ca) / (sb * sg))**2)]])
stored.fracToOrt = stored.fracToOrt.transpose()
stored.ortToFrac = inv(stored.fracToOrt)
cmd.cell_shift_helper = cell_shift_helper
cmd.alter_state(1, object, "x,y,z = cmd.cell_shift_helper([x,y,z],stored.shift)")
def build_seq(name, seq,ss=None,phi=None,psi=None):
"""
usage: build_seq name, seq [, ss=helix | phi=phi, psi=psi]
example: build_seq peptide, QGAADLESLGQYFEEMKTKLIQDMTE, ss=helix
will build the above sequence in a helical conformation
ss can be: helix or h or alpha (phi=-57, psi=-47)
antiparallel or beta (phi=-139, psi=-135)
parallel (phi=-119, psi=113)
3/10 helix (phi=-40.7,psi=30)
polypro (phi=-78, psi=149) (polyproline helix type II)
Alternatively, you can specify the phi and psi angles directly:
build_seq peptide, QGAADLESLGQ, phi=-60, psi=-40
This will create an object with the name you provided, unless
unless that selection already exists, then it will build onto that.
"""
if name in cmd.get_names("selections"):
obj='pk1'
else:
obj=seq[0:3]
if phi == None or psi == None:
if ss == None:
phi = -139
psi = -135
else:
ss = ss.lower()
if ss[0:5] == 'helix' or ss[0] == 'h' or ss[0:5] == 'alpha':
phi = -57
psi = -47
elif ss[0:5] == 'antip' or ss[0:4] == 'beta':
phi = -139
psi = -135
elif ss[0:5] == 'paral':
phi = -119
psi = 113
elif ss[0:4] == '3/10':
phi = -40.7
psi = -30
elif ss[0:7] == 'polypro':
phi = -78
psi = 149
print "Building sequence: ",seq
### Here seq_convert is used ###
# seq3=seq_convert.seq1_to_seq3(seq)
seq3=seq1_to_seq3(seq)
attach_amino_acid(obj,seq3[0].lower(),phi,psi)
for aa in seq3[1:]:
aa = aa.lower()
attach_amino_acid('pk1',aa,phi,psi)
cmd.delete('pk1')
cmd.delete('pkmol')
cmd.set_name(seq3[0].lower(), name)
def draw_ENM(structure_filepath, script_filepath, structure_name="CAonly", output_dir='.', view=None):
""" Draws elastic network model of a structure and saves image.
"""
cmd.delete('all')
cmd.load(structure_filepath, "CAonly")
cmd.run(script_filepath)
# Set name
if structure_name == "CAonly":
pass
else:
cmd.set_name("CAonly", structure_name)
# Set view
if view == None:
cmd.orient()
else:
cmd.set_view(view)
cmd.viewport(width=1200, height=1200)
cmd.zoom(complete=1)
png_filepath = os.path.join(output_dir, structure_name) + ".png"
pse_filepath = os.path.join(output_dir, structure_name) + ".pse"
cmd.save(pse_filepath)
cmd.set('ray_opaque_background', 0)
cmd.png(png_filepath, width=1200, height=1200, ray=1)
return (pse_filepath, png_filepath)
def load_rep(target, offtarget):
tprot = target[0]
tprot_type = target[1]
tligs = target[2:]
cmd.load(tprot, tprot_type)
for lig in tligs:
cmd.load(lig, '%s_poses' % tprot_type[0])
ligand_cartoon('(%s_poses or %s)' % (tprot_type[0], tprot_type))
cmd.set_name('polar_contacts', '%s_polar_contacts' % tprot_type[0])
util.cbag('(%s_poses or %s)' % (tprot_type[0], tprot_type))
if offtarget:
oprot = offtarget[0]
oprot_type = offtarget[1]
oligs = offtarget[2:]
cmd.load(oprot, 'Off-Target')
for lig in oligs:
cmd.load(lig, 'O_poses')
ligand_cartoon('(O_poses or Off-Target)')
cmd.set_name('polar_contacts', 'O_polar_contacts')
util.cbam('(O_poses or Off-Target)')
# cmd.bg_color('white')
# representation(rep)
cmd.remove("all & hydro & not nbr. (don.|acc.)")
def select_catres(selection):
""" Makes individual selections, each one containing all residues of the same
index (in the PDB) from all objects."""
groups = defaultdict(list)
for obj in cmd.get_object_list(f'{selection}'):
stored.ranked_atoms = {}
cmd.iterate(obj, "stored.ranked_atoms[rank] = (f'/{model}//{chain}/{resi}', type)")
# Make a list of residue selections, in the same order as in the PDB
residues = []
for k,v in sorted(stored.ranked_atoms.items()):
if v[1] == 'HETATM':
continue
if v[0] not in residues:
residues.append(v[0])
for i, sele in enumerate(residues):
groups[i].append(sele)
# Now make group selections
for i,reslist in groups.items():
selection_name = f'catres_{i}'
cmd.select('temp', 'none')
for sele in reslist:
cmd.select('cur', sele)
cmd.select('temp', '(temp) or (cur)')
cmd.set_name('temp', selection_name)
cmd.delete('cur')
def Btn_ExtractLigand_Clicked(self):
state = cmd.get_state()
# Get the Drop Down List Selection Name
ddlSelection = self.defaultOption.get()
if ddlSelection == '' or self.Validate_ObjectSelection(
ddlSelection, 'Ligand', state):
return
LigandPath = tkFileDialog.asksaveasfilename(
filetypes=[('PDB File', '*.pdb')],
initialdir=self.top.FlexAIDLigandProject_Dir,
title='Save the PDB File',
initialfile=ddlSelection,
defaultextension='.pdb')
if len(LigandPath) > 0:
LigandPath = os.path.normpath(LigandPath)
if General.validate_String(LigandPath, '.pdb', True, False, True):
self.DisplayMessage(
" ERROR: Could not save the file because you entered an invalid name.",
2)
return
if self.top.ValidateSaveProject(LigandPath, 'Ligand'):
self.DisplayMessage(
" ERROR: The file can only be saved at its default location",
2)
return
try:
cmd.save(LigandPath, ddlSelection, state)
LigandName = os.path.basename(os.path.splitext(LigandPath)[0])
cmd.extract(self.ExtractObject, ddlSelection)
cmd.set_name(self.ExtractObject, LigandName)
if ddlSelection != LigandName:
# as if the object was renamed, delete the object
cmd.delete(ddlSelection)
except:
self.DisplayMessage(
" ERROR: An error occured while extracting the ligand object.",
1)
return
self.LigandPath.set(os.path.normpath(LigandPath))
self.LigandName.set(LigandName)
#self.LigandMD5.set(General.hashfile(self.LigandPath.get()))
self.Reset_Ligand()
self.DisplayMessage(
' Successfully extracted the ligand: ' +
self.LigandName.get() + "'", 0)
def build_seq(name, seq, ss=None, phi=None, psi=None):
"""
usage: build_seq name, seq [, ss=helix | phi=phi, psi=psi]
example: build_seq peptide, QGAADLESLGQYFEEMKTKLIQDMTE, ss=helix
will build the above sequence in a helical conformation
ss can be: helix or h or alpha (phi=-57, psi=-47)
antiparallel or beta (phi=-139, psi=-135)
parallel (phi=-119, psi=113)
3/10 helix (phi=-40.7,psi=30)
polypro (phi=-78, psi=149) (polyproline helix type II)
Alternatively, you can specify the phi and psi angles directly:
build_seq peptide, QGAADLESLGQ, phi=-60, psi=-40
This will create an object with the name you provided, unless
unless that selection already exists, then it will build onto that.
"""
if name in cmd.get_names("selections"):
obj = 'pk1'
else:
obj = seq[0:3]
if phi == None or psi == None:
if ss == None:
phi = -139
psi = -135
else:
ss = ss.lower()
if ss[0:5] == 'helix' or ss[0] == 'h' or ss[0:5] == 'alpha':
phi = -57
psi = -47
elif ss[0:5] == 'antip' or ss[0:4] == 'beta':
phi = -139
psi = -135
elif ss[0:5] == 'paral':
phi = -119
psi = 113
elif ss[0:4] == '3/10':
phi = -40.7
psi = -30
elif ss[0:7] == 'polypro':
phi = -78
psi = 149
print "Building sequence: ", seq
### Here seq_convert is used ###
# seq3=seq_convert.seq1_to_seq3(seq)
seq3 = seq1_to_seq3(seq)
attach_amino_acid(obj, seq3[0].lower(), phi, psi)
for aa in seq3[1:]:
aa = aa.lower()
attach_amino_acid('pk1', aa, phi, psi)
cmd.delete('pk1')
cmd.delete('pkmol')
cmd.set_name(seq3[0].lower(), name)
def cell_shift(object, dX, dY, dZ, rename=1):
if rename:
oldName = object.split("_")
oldPre = oldName[0]
oldX = int(oldName[1])
oldY = int(oldName[2])
oldZ = int(oldName[3])
newX = "_" + str(int(dX) + oldX)
newY = "_" + str(int(dY) + oldY)
newZ = "_" + str(int(dZ) + oldZ)
newName = oldPre + newX + newY + newZ
#if cmd.get_names().find(newName) != -1:
# print "Symmetry partner already exists in destination position!"
# quit()
cmd.set_name(object, newName)
object = newName
stored.shift = [float(dX), float(dY), float(dZ)]
stored.sgInfo = cmd.get_symmetry(object)
a, b, c, alpha, beta, gamma = stored.sgInfo[0:6]
ca = math.cos(math.radians(alpha))
cb = math.cos(math.radians(beta))
cg = math.cos(math.radians(gamma))
sb = math.sin(math.radians(beta))
sg = math.sin(math.radians(gamma))
stored.fracToOrt = N.array(
[[a, b * cg, c * cb], [0.0, b * sg, c * (ca - cb * cg) / sg],
[0.0, 0.0,
c * sb * math.sqrt(1.0 - ((cb * cg - ca) / (sb * sg))**2)]])
stored.fracToOrt = stored.fracToOrt.transpose()
stored.ortToFrac = inv(stored.fracToOrt)
cmd.cell_shift_helper = cell_shift_helper
cmd.alter_state(1, object,
"x,y,z = cmd.cell_shift_helper([x,y,z],stored.shift)")
def testGroupRename(self):
'''
Rename group entries which have a group name prefix when renaming the group
'''
cmd.set('group_auto_mode', 2)
cmd.pseudoatom('g1.m1')
cmd.pseudoatom('g1.m2')
cmd.set_name('g1', 'g2')
m_list = []
cmd.iterate('g2', 'm_list.append(model)', space=locals())
self.assertItemsEqual(m_list, ['g2.m1', 'g2.m2'])
def builder(residues, bonds, mol_name):
"""Using the list generated by read_input connects monosacharides in
a single oligosaccharide"""
cmd.set('suspend_updates', 'on')
cmd.feedback('disable', 'executive', 'actions')
every_object = cmd.get_object_list('all')
if mol_name in every_object:
cmd.delete(mol_name)
every_object.remove(mol_name)
if every_object:
sel = 'not (' + ' or '.join(every_object) + ') and'
else:
sel = ''
for i in range(0, len(residues)):
res_name = residues[i]
cmd.load(os.path.join(path, 'db_glycans', '%s.pdb' % res_name))
cmd.set_name(res_name,
i) #rename object (necessary to avoid repeating names)
cmd.alter(i, 'resi = %s' % i) #name residues for further referencing
cmd.sort(i)
for i in range(0, len(bonds)):
resi_i, resi_j, atom_i, atom_j = bonds[i][0], bonds[i][2], bonds[i][
4], bonds[i][5]
if atom_i > atom_j:
cmd.remove('%s (resi %s and name O%s+H%so)' %
(sel, resi_j, atom_j, atom_j))
cmd.remove('%s (resi %s and name H%so)' % (sel, resi_i, atom_i))
cmd.fuse('%s (resi %s and name O%s)' % (sel, resi_i, atom_i),
'%s (resi %s and name C%s)' % (sel, resi_j, atom_j),
mode=2)
else:
cmd.remove('%s (resi %s and name O%s+H%so)' %
(sel, resi_i, atom_i, atom_i))
cmd.remove('%s (resi %s and name H%so)' % (sel, resi_j, atom_j))
cmd.fuse('%s (resi %s and name C%s)' % (sel, resi_i, atom_i),
'%s (resi %s and name O%s)' % (sel, resi_j, atom_j),
mode=2)
cmd.delete('%s' % i)
cmd.copy(mol_name, '%s' % resi_j)
cmd.delete('%s' % resi_j)
for i in range(0, len(bonds)):
set_phi(mol_name, bonds[i], -60)
set_psi(mol_name, bonds[i], 120)
cmd.delete('pk1')
cmd.delete('pk2')
cmd.delete('pkbond')
cmd.delete('pkmol')
if babel:
fast_min(mol_name, 5000)
minimize(mol_name)
else:
fast_min(mol_name, 5000)
cmd.feedback('enable', 'executive', 'actions')
cmd.set('suspend_updates', 'off')
def _add_vis(self, mymol, row, l_cgo):
mycolind = int((np.sign(row.sdiff) + 1) / 2)
if self.df_rgn_seg_res_bb is None:
cmd.select(
"sel1",
"/%s/%s and i. %d and name ca" % (mymol, row.seg1, row.res1))
cmd.select(
"sel2",
"/%s/%s and i. %d and name ca" % (mymol, row.seg2, row.res2))
else:
df_unique_rgnsegbb = self.df_rgn_seg_res_bb[["seg"
]].drop_duplicates()
for myrgn in [row.rgn1, row.rgn2]:
selstr = "/%s and (" % (mymol)
for sindex, srow in df_unique_rgnsegbb.iterrows():
df_sel = self.df_rgn_seg_res_bb.query(
"rgn == '%s' and seg == '%s'" % (myrgn, srow.seg))
if df_sel.shape[0] > 0:
selstr += "(c. %s and i. %s) or" % (srow.seg, "+".join(
[str(x) for x in df_sel.res.values[0]]))
selstr = selstr[:-3] + ")"
cmd.select("%s" % myrgn, selstr)
cmd.set_name("%s" % row.rgn1, "sel1")
cmd.set_name("%s" % row.rgn2, "sel2")
count1 = cmd.count_atoms("sel1")
count2 = cmd.count_atoms("sel2")
if 0 in [count1, count2]:
raise ValueError(
"ZeroCount: count(%s.%d.%s.ca): %d, count(%s.%d.%s.ca): %d" %
(row.seg1, row.res1, row.rnm1, count1, row.seg2, row.res2,
row.rnm2, count2))
else:
com("sel1", state=1)
#cmd.color(self.sgn2col[mycolind], "sel1")
coord1 = cmd.get_model("sel1_COM", state=1).atom[0].coord
cmd.delete("sel1_COM")
com("sel2", state=1)
#cmd.color(self.sgn2col[mycolind], "sel2")
coord2 = cmd.get_model("sel2_COM", state=1).atom[0].coord
cmd.delete("sel2_COM")
l_cgo += [ \
LINEWIDTH, self.linewidth, \
BEGIN, LINES, \
COLOR, self.l_r[mycolind], self.l_g[mycolind], self.l_b[mycolind], \
VERTEX, coord1[0], coord1[1],coord1[2], \
VERTEX, coord2[0], coord2[1],coord2[2], \
END \
]
cmd.show("sticks", "sel1")
cmd.show("sticks", "sel2")
cmd.delete("sel1")
cmd.delete("sel2")
def setNative(self, base=""): # --- get last structure --- # if base == "": sess = cmd.get_session() for i in sess["names"]: if type(i) is ListType: base = i[0] cmd.set_name(base, "native") file = base + ".pdb" self.viewer.setNative(file) self.viewer.displayNative()
def export_pymol(file1, file2):
py_object1 = file1.rsplit(".sdf", maxsplit=1)[0]
py_object2 = file2.rsplit(".sdf", maxsplit=1)[0]
pref1 = py_object1.split("/")[-1]
pref2 = py_object2.split("/")[-1]
cmd.load(filename=file1)
cmd.set_name(pref1, "query_conf")
cmd.load(filename=file2)
cmd.split_states(object="query_conf")
cmd.split_states(object=pref2)
cmd.delete("query_conf")
cmd.delete(pref2)
cmd.save(f"{py_object2}.pse")
cmd.delete("all")
def setDesigned(self, base=""): # --- get last structure --- # if base == "": sess = cmd.get_session() for i in sess["names"]: if type(i) is ListType: base = i[0] file = base + ".pdb" cmd.set_name(base, "designed") self.viewer.setDesign(file) self.viewer.selectCatalytic() self.viewer.displayDesigned()
def getListOfModels(self):
#models can not contain the underscore character '_'
#this is a Pmw limitation, but PyMOL does add such
#characters often
initialList = cmd.get_object_list()
outputList = list();
for m in initialList:
if '_' in m:
newName = m.translate(None,"_")
cmd.set_name(m,newName)
message("WARNING Renaming model \'"+m+ "\' to \'"+ newName+"\'")
m = newName
outputList.append(m)
return outputList
def main(design_path, original_pdbs_directory='pdb'):
"""loads to the pymol session the original blades of the design.
Args:
design_path: path to the wanted design
original_pdbs_directory: path to directory where all pdbs are
"""
segment_count = 0
for line in open(design_path):
if line.startswith('segment_') and 'frm' not in line:
segment_count += 1
original = line.split()[-1]
name = '{}_{}'.format(segment_count, original)
print name
cmd.load('{}/{}.pdb'.format(original_pdbs_directory, original))
cmd.set_name(original, name)
def Btn_ExtractLigand_Clicked(self):
state = cmd.get_state()
# Get the Drop Down List Selection Name
ddlSelection = self.defaultOption.get()
if ddlSelection == '' or self.Validate_ObjectSelection(ddlSelection, 'Ligand', state):
return
LigandPath = tkFileDialog.asksaveasfilename(filetypes=[('PDB File','*.pdb')],
initialdir=self.top.FlexAIDLigandProject_Dir, title='Save the PDB File',
initialfile=ddlSelection, defaultextension='.pdb')
if len(LigandPath) > 0:
LigandPath = os.path.normpath(LigandPath)
if General.validate_String(LigandPath, '.pdb', True, False, True):
self.DisplayMessage(" ERROR: Could not save the file because you entered an invalid name.", 2)
return
if self.top.ValidateSaveProject(LigandPath, 'Ligand'):
self.DisplayMessage(" ERROR: The file can only be saved at its default location", 2)
return
try:
cmd.save(LigandPath, ddlSelection, state)
LigandName = os.path.basename(os.path.splitext(LigandPath)[0])
cmd.extract(self.ExtractObject, ddlSelection)
cmd.set_name(self.ExtractObject, LigandName)
if ddlSelection != LigandName:
# as if the object was renamed, delete the object
cmd.delete(ddlSelection)
except:
self.DisplayMessage(" ERROR: An error occured while extracting the ligand object.", 1)
return
self.LigandPath.set(os.path.normpath(LigandPath))
self.LigandName.set(LigandName)
#self.LigandMD5.set(General.hashfile(self.LigandPath.get()))
self.Reset_Ligand()
self.DisplayMessage(' Successfully extracted the ligand: ' + self.LigandName.get() + "'", 0)
def refreshModelSelectionWidget(self):
self.modsW.deleteall()
mols = self.getListOfModels()
for m in mols:
if '_' in m:
newName = m
newName.replace('_', '-')
cmd.set_name(m,newName)
m = newName
message("Renaming a model...")
self.modsW.add(m)
if 1 > len(self.getListOfModels()):
self.warnLabel.pack(fill='both', expand=True, padx=10, pady=5)
else:
self.warnLabel.pack_forget()
return
def refreshModelSelectionWidget(self):
self.modsW.deleteall()
mols = self.getListOfModels()
for m in mols:
if '_' in m:
newName = m
newName.replace('_', '-')
cmd.set_name(m, newName)
m = newName
message("Renaming a model...")
self.modsW.add(m)
if 1 > len(self.getListOfModels()):
self.warnLabel.pack(fill='both', expand=True, padx=10, pady=5)
else:
self.warnLabel.pack_forget()
return
def builder(residues, bonds, mol_name):
"""Using the list generated by read_input connects monosacharides in
a single oligosaccharide"""
cmd.set('suspend_updates', 'on')
cmd.feedback('disable', 'executive', 'actions')
every_object = cmd.get_object_list('all')
if mol_name in every_object:
cmd.delete(mol_name)
every_object.remove(mol_name)
if every_object:
sel = 'not (' + ' or '.join(every_object) + ') and'
else:
sel = ''
for i in range(0, len(residues)):
res_name = residues[i]
cmd.load(os.path.join(path, 'db_glycans', '%s.pdb' % res_name))
cmd.set_name(res_name, i) #rename object (necessary to avoid repeating names)
cmd.alter(i, 'resi = %s' % i) #name residues for further referencing
cmd.sort(i)
for i in range(0, len(bonds)):
resi_i, resi_j, atom_i, atom_j = bonds[i][0], bonds[i][2], bonds[i][4], bonds[i][5]
if atom_i > atom_j:
cmd.remove('%s (resi %s and name O%s+H%so)' % (sel, resi_j, atom_j, atom_j))
cmd.remove('%s (resi %s and name H%so)' % (sel, resi_i, atom_i))
cmd.fuse('%s (resi %s and name O%s)' % (sel, resi_i, atom_i), '%s (resi %s and name C%s)' % (sel, resi_j, atom_j), mode=2)
else:
cmd.remove('%s (resi %s and name O%s+H%so)' % (sel, resi_i, atom_i, atom_i))
cmd.remove('%s (resi %s and name H%so)' % (sel, resi_j, atom_j))
cmd.fuse('%s (resi %s and name C%s)' % (sel, resi_i, atom_i), '%s (resi %s and name O%s)' % (sel, resi_j, atom_j), mode=2)
cmd.delete('%s' % i)
cmd.copy(mol_name, '%s' % resi_j)
cmd.delete('%s' % resi_j)
for i in range(0, len(bonds)):
set_phi(mol_name, bonds[i], -60)
set_psi(mol_name, bonds[i], 120)
cmd.delete('pk1')
cmd.delete('pk2')
cmd.delete('pkbond')
cmd.delete('pkmol')
if babel:
fast_min(mol_name, 5000)
minimize(mol_name)
else:
fast_min(mol_name, 5000)
cmd.feedback('enable', 'executive', 'actions')
cmd.set('suspend_updates', 'off')
def _add_vis(self, mymol, row, l_cgo):
mycolind = int((np.sign(row.sdiff) + 1) / 2)
if self.df_rgn_seg_res_bb is None:
if not hasattr(row, "seg"):
raise ValueError(
"row has no column \"seg\", but self.df_rgn_seg_res_bb is None - maybe parameter \"coarse_grain_type\" is not properly set?"
)
cmd.select(
"sel",
"/%s/%s and i. %d and not h." % (mymol, row.seg, row.res))
else:
if not hasattr(row, "rgn"):
raise ValueError(
"row has no column \"rgn\", but self.df_rgn_seg_res_bb is not None - maybe parameter \"coarse_grain_type\" is not properly set?"
)
df_unique_rgnsegbb = self.df_rgn_seg_res_bb[["seg"
]].drop_duplicates()
for myrgn in [row.rgn]:
selstr = "/%s and (" % (mymol)
for sindex, srow in df_unique_rgnsegbb.iterrows():
df_sel = self.df_rgn_seg_res_bb.query(
"rgn == '%s' and seg == '%s'" % (myrgn, srow.seg))
if df_sel.shape[0] > 0:
selstr += "(c. %s and i. %s) or" % (srow.seg, "+".join(
[str(x) for x in df_sel.res.values[0]]))
selstr = selstr[:-3] + ")"
cmd.select("%s" % myrgn, selstr)
cmd.set_name("%s" % row.rgn, "sel")
count = cmd.count_atoms("sel")
if count == 0:
if self.df_rgn_seg_res_bb is None:
raise ValueError("count for %s.%d.%s.%d is zero!" %
(row.seg, row.res, row.rnm))
else:
raise ValueError("count for %s is zero!" % (row.rgn))
else:
if self.df_rgn_seg_res_bb is None:
cmd.show("sticks", "sel and (sidechain or name ca)")
cmd.color(self.sgn2col[mycolind],
"sel and (sidechain or name ca)")
else:
#cmd.show("sticks", "sel")
cmd.color(self.sgn2col[mycolind], "sel")
cmd.delete("sel")
def sort_dcoms(subs):
N = len(subs) / 2
for i in range(1, N + 1):
assert "tmp%iA" % i in cmd.get_object_list()
for i in range(1, N + 1):
assert "tmp%iB" % i in cmd.get_object_list()
coms = [com(s) for s in subs]
tmp = [(coms[0].distance(x), i) for i, x in enumerate(coms)]
tmp.sort()
td = tmp[2][0] - tmp[1][0] < tmp[3][0] - tmp[2][0]
ring = [tmp[1 if td else 2][1], 0, tmp[2 if td else 3][1]]
while len(ring) < N:
tmp = [(coms[ring[-1]].distance(x), i) for i, x in enumerate(coms)]
tmp.sort()
assert (tmp[2][0] - tmp[1][0] < tmp[3][0] - tmp[2][0]) == td
v1 = tmp[1 if td else 2][1]
v2 = tmp[2 if td else 3][1]
assert ring[-2] in (v1, v2)
ring.append(v1 if v2 == ring[-2] else v2)
# print ring
# print [subs[i] for i in ring]
namemap = {}
for i, r in enumerate(ring):
assert not subs[r] in namemap
namemap[subs[r]] = "sub%iA" % (i + 1)
tmp = [(coms[r].distance(x), j) for j, x in enumerate(coms)]
tmp.sort()
# print r, [subs[x[1]] for x in tmp]
sub_partner = subs[tmp[3 if td else 1][1]]
assert not sub_partner in namemap
namemap[sub_partner] = "sub%iB" % (i + 1)
assert len(set(namemap.keys())) == 2 * N
for i in range(1, N + 1):
assert "tmp%iA" % i in cmd.get_object_list()
for i in range(1, N + 1):
assert "tmp%iB" % i in cmd.get_object_list()
chains = {}
for i in range(N):
chains["sub%iA" % (i + 1)] = string.uppercase[2 * N + 0]
chains["sub%iB" % (i + 1)] = string.uppercase[2 * N + 1]
for k in namemap:
cmd.set_name(k, namemap[k])
cmd.alter(namemap[k], "chain = '%s'" % chains[namemap[k]])
for i in chains:
assert i in cmd.get_object_list()
def extrude_hub_at_single_n(single_name=None,
hub_name=None,
component_id=None):
"""Extrudes a hub at the n-terminus of a single module.
Args:
- single_name - string
- hub_name - string
- component_id - string id of the module component inside the hub to
extend into
"""
if single_name is None or \
hub_name is None or \
component_id is None:
print(extrude_hub_at_single_n.__doc__)
else:
double_name = '-'.join([single_name, single_name])
pdb_dir = os.getcwd() + '/../../resources/pdb_aligned/'
cmd.load(pdb_dir + '/singles/' + single_name + '.pdb')
cmd.set_name(single_name, 'single')
cmd.load(pdb_dir + '/doubles/' + double_name + '.pdb')
cmd.set_name(double_name, 'double')
cmd.load(pdb_dir + '/doubles/' + double_name + '.pdb')
cmd.set_name(double_name, 'double-o')
cmd.load(pdb_dir + '/hubs/' + hub_name + '.pdb')
cmd.set_name(hub_name, 'hub')
xdb = utilities.read_json(os.getcwd() +
'/../../resources/xdb.json')
double_info = xdb['double_data'][single_name][single_name]
# first, drop the double for reference
tx('double',
rot=double_info['rot'],
tran_after=double_info['tran'])
hub_comp_info = xdb['hub_data'][hub_name]['component_info']
comp_a_cc = hub_comp_info[component_id]['c_connections'][
single_name]
# The frame drop order is important here
# drop hub into component frame
tx('hub', rot=comp_a_cc['rot'], tran_after=comp_a_cc['tran'])
# drop hub into double's frame
tx('hub', rot=double_info['rot'], tran_after=double_info['tran'])
noclip()
print('Extruded Hub {} Component {} at Single {}\'s N-Term'.\
format(hub_name, component_id, single_name))
def show_active_siteMYR():
"""
Select, shows active site of MYR ligand in range of 5 Angstrom
"""
print(' >>>> Show active site <<<<')
file_object = open('Full_AS_intr_res_list.csv', 'w')
file_object1 = open('AS_intr_res_list.csv', 'w')
#cmd.do("select active_site, ligands around 5");
obj_list = cmd.get_names('objects')
print(obj_list)
for obj in obj_list:
cmd.do("AS_res_list=[]")
cmd.do("AS_L = []")
cmd.do("AS_L_num = []")
cmd.do("Lig_list=[]")
cmd.do("fix_Lig_list=[]")
cmd.do("AS_res_num_list=[]")
obj_us_list = []
print(obj)
cmd.do("select resn MYR and " + str(obj))
cmd.do("iterate sele, Lig_list.append((resi + resn))")
#print list of ligands in pdbs
cmd.do("fix_Lig_list=set(list(Lig_list))")
#print((str(obj), fix_Lig_list))
cmd.do("select sele1,( br. " + str(obj) +
" within 5 of sele) and not sele")
#and not sele")
cmd.do("util.cbay sele1")
cmd.do("iterate sele1, AS_res_list.append((resi, resn))")
cmd.do("iterate sele1, AS_res_num_list.append((resi))")
cmd.do("AS_L=(list(set(AS_res_list)))")
cmd.do("AS_L_num=(list(set(AS_res_num_list)))")
#print(str(obj), fix_Lig_list, fix_Lig_list, AS_L)\
#change obj to list for purpose of futher file playing :P
cmd.do("if AS_L==[]: AS_L=['0']")
cmd.do("if AS_L_num==[]: AS_L_num=['0']")
file_object.write(csv_formatted_output(obj, fix_Lig_list, AS_L))
file_object1.write(csv_formatted_output(obj, fix_Lig_list, AS_L_num))
cmd.set_name("sele1", "AS_" + str(obj))
file_object.close()
file_object1.close()
def test2667(self):
cmd.fragment('ala', 'm1')
cmd.alter_state(1, '%m1', 's.label_placement_offset = [1., 0., 0.]')
with testing.mktemp('.pse') as filename:
cmd.save(filename)
cmd.set_name('m1', 'm2')
cmd.load(filename, partial=1)
# now we have two copies (m1 m2). If unique ids are converted upon
# loading, then there will be no settings cross-leaking. Otherwise
# changing m1 settings will affect m2.
cmd.alter_state(1, '%m1', 's.label_placement_offset = [0., 1., 0.]')
m2_setting = []
cmd.iterate_state(1,
'first %m2', 'm2_setting.append(s.label_placement_offset)',
space=locals())
self.assertArrayEqual([1., 0., 0.], m2_setting[0], 0.001)
def test2667(self):
cmd.fragment('ala', 'm1')
cmd.alter_state(1, '%m1', 's.label_placement_offset = [1., 0., 0.]')
with testing.mktemp('.pse') as filename:
cmd.save(filename)
cmd.set_name('m1', 'm2')
cmd.load(filename, partial=1)
# now we have two copies (m1 m2). If unique ids are converted upon
# loading, then there will be no settings cross-leaking. Otherwise
# changing m1 settings will affect m2.
cmd.alter_state(1, '%m1', 's.label_placement_offset = [0., 1., 0.]')
m2_setting = []
cmd.iterate_state(1,
'first %m2',
'm2_setting.append(s.label_placement_offset)',
space=locals())
self.assertArrayEqual([1., 0., 0.], m2_setting[0], 0.001)
def load_rep(target, offtarget):
tprot = target[0]
tprot_type = target[1]
tligs = target[2:]
cmd.load(tprot, tprot_type)
for lig in tligs:
cmd.load(lig, '%s_poses' % tprot_type[0])
ligand_cartoon('(%s_poses or %s)' % (tprot_type[0], tprot_type))
cmd.set_name('polar_contacts', '%s_polar_contacts' % tprot_type[0])
util.cbag('(%s_poses or %s)' % (tprot_type[0], tprot_type))
if offtarget:
oprot = offtarget[0]
oprot_type = offtarget[1]
oligs = offtarget[2:]
cmd.load(oprot, 'Off-Target')
for lig in oligs:
cmd.load(lig, 'O_poses')
ligand_cartoon('(O_poses or Off-Target)')
cmd.set_name('polar_contacts', 'O_polar_contacts')
util.cbam('(O_poses or Off-Target)')
def getListOfModels(self):
#models can not contain the underscore character '_'
#this is a Pmw limitation, but PyMOL does add such
#characters often
#dots are also removed, as they confuse crysol
initialList = cmd.get_object_list()
outputList = list()
for m in initialList:
if '_' in m:
newName = m.translate(None, "_")
cmd.set_name(m, newName)
message("WARNING Renaming model \'" + m + "\' to \'" +
newName + "\'")
m = newName
if '.' in m:
newName = m.translate(None, ".")
cmd.set_name(m, newName)
message("WARNING Renaming model \'" + m + "\' to \'" +
newName + "\'")
m = newName
outputList.append(m)
return outputList
def extrude_single_at_single_n(single_name=None, ext_single_name=None):
"""Extrudes a single at the n-terminus of a single module.
Args:
- single_name - string name of the fixed single
- ext_single_name - string name of the extension single
"""
if single_name is None or \
ext_single_name is None:
print(extrude_single_at_single_n.__doc__)
else:
double_name = '-'.join([ext_single_name, single_name])
pdb_dir = os.getcwd() + '/../../resources/pdb_aligned/'
cmd.load(pdb_dir + '/doubles/' + double_name + '.pdb')
cmd.set_name(double_name, 'double')
cmd.load(pdb_dir + '/singles/' + single_name + '.pdb')
cmd.set_name(single_name, 'single')
cmd.load(pdb_dir + '/singles/' + ext_single_name + '.pdb')
cmd.set_name(ext_single_name, 'single-ext')
xdb = utilities.read_json(os.getcwd() +
'/../../resources/xdb.json')
double_info = xdb['double_data'][ext_single_name][single_name]
# first, drop the double (into its A frame) for reference
tx('double',
rot=double_info['rot'],
tran_after=double_info['tran'])
# extrude N term - drop into double's A frame
tx('single-ext',
rot=double_info['rot'],
tran_after=double_info['tran'])
cmd.disable('single-*')
cmd.enable('single-ext')
noclip()
print('Extruded Single {} at Single {}\'s N-Term'.\
format(ext_single_name, single_name))
def extrude_hub_at_single_c(single_name=None,
hub_name=None,
component_id=None):
"""Extrudes a hub at the c-terminus of a single module.
Args:
- single_name - string
- hub_name - string
- component_id - string, indicating which module component inside the hub
to extend into
"""
if single_name is None or \
hub_name is None or \
component_id is None:
print(extrude_hub_at_single_c.__doc__)
else:
double_name = '-'.join([single_name, single_name])
pdb_dir = os.getcwd() + '/../../resources/pdb_aligned/'
cmd.load(pdb_dir + '/singles/' + single_name + '.pdb')
cmd.set_name(single_name, 'single')
cmd.load(pdb_dir + '/doubles/' + double_name + '.pdb')
cmd.set_name(double_name, 'double')
cmd.load(pdb_dir + '/hubs/' + hub_name + '.pdb')
cmd.set_name(hub_name, 'hub')
xdb = utilities.read_json(os.getcwd() +
'/../../resources/xdb.json')
hub_comp_info = xdb['hub_data'][hub_name]['component_info']
comp_a_cc = hub_comp_info[component_id]['n_connections'][
single_name]
tx('hub', rot=comp_a_cc['rot'], tran_after=comp_a_cc['tran'])
noclip()
print('Extruded Hub {} Component {} at Single {}\'s C-Term'.\
format(hub_name, component_id, single_name))
def extrude_single_at_single_c(single_name=None, ext_single_name=None):
"""Extrudes a single at the c-terminus of a single module.
Args:
- single_name - string name of the fixed single
- ext_single_name - string name of the extension single
"""
if single_name is None or \
ext_single_name is None:
print(extrude_single_at_single_c.__doc__)
else:
double_name = '-'.join([single_name, ext_single_name])
pdb_dir = os.getcwd() + '/../../resources/pdb_aligned/'
cmd.load(pdb_dir + '/doubles/' + double_name + '.pdb')
cmd.set_name(double_name, 'double')
cmd.load(pdb_dir + '/singles/' + single_name + '.pdb')
cmd.set_name(single_name, 'single')
cmd.load(pdb_dir + '/singles/' + ext_single_name + '.pdb')
cmd.set_name(ext_single_name, 'single-ext')
xdb = utilities.read_json(os.getcwd() +
'/../../resources/xdb.json')
double_info = xdb['double_data'][single_name][ext_single_name]
# extrude C term - raise
tx('single-ext',
rot=np.array(double_info['rot']).transpose().tolist(),
tran_before=[-t for t in double_info['tran']])
cmd.disable('single-*')
cmd.enable('single-ext')
noclip()
print('Extruded Single {} at Single {}\'s N-Term'.\
format(ext_single_name, single_name))
def visualize_in_pymol(plcomplex):
"""Visualizes the protein-ligand pliprofiler at one site in PyMOL."""
vis = PyMOLVisualizer(plcomplex)
#####################
# Set everything up #
#####################
pdbid = plcomplex.pdbid
lig_members = plcomplex.lig_members
chain = plcomplex.chain
if config.PEPTIDES != []:
vis.ligname = 'PeptideChain%s' % plcomplex.chain
if config.INTRA is not None:
vis.ligname = 'Intra%s' % plcomplex.chain
ligname = vis.ligname
hetid = plcomplex.hetid
metal_ids = plcomplex.metal_ids
metal_ids_str = '+'.join([str(i) for i in metal_ids])
########################
# Basic visualizations #
########################
start_pymol(run=True, options='-pcq', quiet=not config.DEBUG)
vis.set_initial_representations()
cmd.load(plcomplex.sourcefile)
current_name = cmd.get_object_list(selection='(all)')[0]
write_message('Setting current_name to "%s" and pdbid to "%s\n"' % (current_name, pdbid), mtype='debug')
cmd.set_name(current_name, pdbid)
cmd.hide('everything', 'all')
if config.PEPTIDES != []:
cmd.select(ligname, 'chain %s and not resn HOH' % plcomplex.chain)
else:
cmd.select(ligname, 'resn %s and chain %s and resi %s*' % (hetid, chain, plcomplex.position))
write_message("Selecting ligand for PDBID %s and ligand name %s with: " % (pdbid, ligname), mtype='debug')
write_message('resn %s and chain %s and resi %s*' % (hetid, chain, plcomplex.position), mtype='debug')
# Visualize and color metal ions if there are any
if not len(metal_ids) == 0:
vis.select_by_ids(ligname, metal_ids, selection_exists=True)
cmd.show('spheres', 'id %s and %s' % (metal_ids_str, pdbid))
# Additionally, select all members of composite ligands
if len(lig_members) > 1:
for member in lig_members:
resid, chain, resnr = member[0], member[1], str(member[2])
cmd.select(ligname, '%s or (resn %s and chain %s and resi %s)' % (ligname, resid, chain, resnr))
cmd.show('sticks', ligname)
cmd.color('myblue')
cmd.color('myorange', ligname)
cmd.util.cnc('all')
if not len(metal_ids) == 0:
cmd.color('hotpink', 'id %s' % metal_ids_str)
cmd.hide('sticks', 'id %s' % metal_ids_str)
cmd.set('sphere_scale', 0.3, ligname)
cmd.deselect()
vis.make_initial_selections()
vis.show_hydrophobic() # Hydrophobic Contacts
vis.show_hbonds() # Hydrogen Bonds
vis.show_halogen() # Halogen Bonds
vis.show_stacking() # pi-Stacking Interactions
vis.show_cationpi() # pi-Cation Interactions
vis.show_sbridges() # Salt Bridges
vis.show_wbridges() # Water Bridges
vis.show_metal() # Metal Coordination
vis.refinements()
vis.zoom_to_ligand()
vis.selections_cleanup()
vis.selections_group()
vis.additional_cleanup()
if config.DNARECEPTOR:
# Rename Cartoon selection to Line selection and change repr.
cmd.set_name('%sCartoon' % plcomplex.pdbid, '%sLines' % plcomplex.pdbid)
cmd.hide('cartoon', '%sLines' % plcomplex.pdbid)
cmd.show('lines', '%sLines' % plcomplex.pdbid)
if config.PEPTIDES != []:
filename = "%s_PeptideChain%s" % (pdbid.upper(), plcomplex.chain)
if config.PYMOL:
vis.save_session(config.OUTPATH, override=filename)
elif config.INTRA is not None:
filename = "%s_IntraChain%s" % (pdbid.upper(), plcomplex.chain)
if config.PYMOL:
vis.save_session(config.OUTPATH, override=filename)
else:
filename = '%s_%s' % (pdbid.upper(), "_".join([hetid, plcomplex.chain, plcomplex.position]))
if config.PYMOL:
vis.save_session(config.OUTPATH)
if config.PICS:
vis.save_picture(config.OUTPATH, filename)
def split_alignment(object, object1=None, object2=None, delimiter="_"):
"""DESCRIPTION
Splits a two-state object into two separate objects.
USAGE
split_alignment object[, object1, object2][, delimiter]
ARGUMENTS
object Two-state input object
object1 What to name the first state from the object [optional]
object2 What to name the second state from the object [optional]
delimiter Delimiter which separates object1 and object2 in the object name.
See DETAILS. [default '_']
DETAILS
The input object must contain at least two states. Additional states are
ignored.
If object1 and object2 are ommitted, the script will attempt to generate
them based on the input object's name. The name is split around the first
instance of <delimiter>. Thus, objects which follow the convention
"object1_object2" will be properly split without additional arguments.
EXAMPLES
# Results in objects '1AX8.A' and '3PIV.A'
split_alignment 1AX8.A_3PIV.A
# Results in objects 'query' and 'target'
split_alignment alignment, query, target
# Results in objects '1AX8.A' and '3PIV.A'
split_alignment 1AX8.A_vs_3PIV.A, delimiter="_vs_"
"""
# check that we have at least two states
if cmd.count_states(object) < 2:
print ("Error: input object must contain at least two states.")
return
prefix = "split%04d_" % random.randint(0, 9999) # make unique
# guess output names
if object1 is None and object2 is None:
try:
d = object.index(delimiter)
object1 = object[:d]
object2 = object[d + len(delimiter) :]
except:
object1 = "%s_%04d" % (object, 1)
object2 = "%s_%04d" % (object, 2)
print "Warning: '%s' not found in '%s'. Using names %s and %s." % (delimiter, object, object1, object2)
# split them
cmd.split_states(object, prefix=prefix)
# rename to output names
cmd.set_name("%s%04d" % (prefix, 1), object1)
cmd.set_name("%s%04d" % (prefix, 2), object2)
# delete other states
for o in cmd.get_names("objects"):
if o.startswith(prefix):
cmd.delete(o)
def spl_extract():
for name in cmd.get_names("all"):
#if name in ['5zwo', '5gm6', '5lj3', '5mps', '6exn', '5ylz', '5y88', '3jb9', '6icz', '6ff7', '5yzg', '5xjc', '5gan', '6qw6', '3jcr', '6qx9', '6ah0']: # this should be auto
print(" \ Extracting mode for %s" % name)
for n in cmd.get_names("all"):
if '5zwo' in n:
object_name = n
print(object_name)
if '5zwo' in name.lower():
cmd.extract("PRP8_B5zwo", "chain A and " + object_name)
cmd.extract("BRR2_B5zwo", "chain D and " + object_name)
cmd.extract("LEA1_B5zwo", "chain o and " + object_name)
cmd.extract("Msl1_B5zwo", "chain p and " + object_name)
cmd.extract("SNU114_B5zwo", "chain C and " + object_name)
cmd.extract("U2_B5zwo", "chain H and " + object_name)
cmd.extract("U5_B5zwo", "chain B and " + object_name)
cmd.extract("U6_B5zwo", "chain F and " + object_name)
cmd.extract("U4_B5zwo", "chain I and " + object_name)
cmd.extract("Intron_B5zwo", "chain G and " + object_name)
cmd.extract("PRP4_B5zwo", "chain K and " + object_name)
cmd.extract("PRP31_B5zwo", "chain L and " + object_name)
cmd.extract("PRP6_B5zwo", "chain N and " + object_name)
cmd.extract("PRP3_B5zwo", "chain J and " + object_name)
cmd.extract("DIB1_B5zwo", "chain E and " + object_name)
cmd.extract("SNU13_B5zwo", "chain M and " + object_name)
cmd.extract("LSM8_B5zwo", "chain z and " + object_name)
cmd.extract("LSM2_B5zwo", "chain q and " + object_name)
cmd.extract("LSM3_B5zwo", "chain r and " + object_name)
cmd.extract("LSM6_B5zwo", "chain x and " + object_name)
cmd.extract("LSM5_B5zwo", "chain t and " + object_name)
cmd.extract("LSM7_B5zwo", "chain y and " + object_name)
cmd.extract("LSM4_B5zwo", "chain s and " + object_name)
cmd.extract("SNU66_B5zwo", "chain O and " + object_name)
cmd.extract("BUD13_B5zwo", "chain Y and " + object_name)
cmd.extract("Cus1_B5zwo", "chain 2 and " + object_name)
cmd.extract("HSH155_B5zwo", "chain 1 and " + object_name)
cmd.extract("HSH49_B5zwo", "chain 4 and " + object_name)
cmd.extract("PML1_B5zwo", "chain Z and " + object_name)
cmd.extract("PRP11_B5zwo", "chain v and " + object_name)
cmd.extract("RDS3_B5zwo", "chain 5 and " + object_name)
cmd.extract("RSE1_B5zwo", "chain 3 and " + object_name)
cmd.extract("SNU17_B5zwo", "chain X and " + object_name)
cmd.extract("Ysf3_B5zwo", "chain 6 and " + object_name)
cmd.extract("SMB1_1_B5zwo", "chain a and " + object_name)
cmd.extract("SMB1_2_B5zwo", "chain P and " + object_name)
cmd.extract("SMB1_3_B5zwo", "chain h and " + object_name)
cmd.extract("SME1_1_B5zwo", "chain e and " + object_name)
cmd.extract("SME1_2_B5zwo", "chain T and " + object_name)
cmd.extract("SME1_3_B5zwo", "chain i and " + object_name)
cmd.extract("SMX3_1_B5zwo", "chain f and " + object_name)
cmd.extract("SMX3_2_B5zwo", "chain U and " + object_name)
cmd.extract("SMX3_3_B5zwo", "chain j and " + object_name)
cmd.extract("SMX2_1_B5zwo", "chain g and " + object_name)
cmd.extract("SMX2_2_B5zwo", "chain V and " + object_name)
cmd.extract("SMX2_3_B5zwo", "chain k and " + object_name)
cmd.extract("SMD3_1_B5zwo", "chain d and " + object_name)
cmd.extract("SMD3_2_B5zwo", "chain S and " + object_name)
cmd.extract("SMD3_3_B5zwo", "chain l and " + object_name)
cmd.extract("SMD1_1_B5zwo", "chain b and " + object_name)
cmd.extract("SMD1_2_B5zwo", "chain Q and " + object_name)
cmd.extract("SMD1_3_B5zwo", "chain m and " + object_name)
cmd.extract("SMD2_1_B5zwo", "chain c and " + object_name)
cmd.extract("SMD2_2_B5zwo", "chain R and " + object_name)
cmd.extract("SMD2_3_B5zwo", "chain n and " + object_name)
cmd.extract("PRP9_B5zwo", "chain u and " + object_name)
cmd.extract("PRP21_B5zwo", "chain w and " + object_name)
cmd.extract("SNU23_B5zwo", "chain W and " + object_name)
cmd.extract("PRP38_B5zwo", "chain 0 and " + object_name)
cmd.extract("SPP381_B5zwo", "chain 9 and " + object_name)
cmd.set_name(object_name, "unknown_other_B5zwo")
cmd.group("B5zwo", "*_B5zwo")
cmd.do("order *, yes")
for n in cmd.get_names("all"):
if '5gm6' in n:
object_name = n
print(object_name)
if '5gm6' in name.lower():
cmd.extract("PRP8_Ba5gm6", "chain A and " + object_name)
cmd.extract("BRR2_Ba5gm6", "chain B and " + object_name)
cmd.extract("BUD31_Ba5gm6", "chain T and " + object_name)
cmd.extract("CEF1_Ba5gm6", "chain c and " + object_name)
cmd.extract("CWC15_Ba5gm6", "chain S and " + object_name)
cmd.extract("CWC2_hRBM22_Ba5gm6", "chain R and " + object_name)
cmd.extract("CWC21_Ba5gm6", "chain X and " + object_name)
cmd.extract("CWC22_Ba5gm6", "chain Z and " + object_name)
cmd.extract("PRP45_Ba5gm6", "chain P and " + object_name)
cmd.extract("CDC40_Ba5gm6", "chain n and " + object_name)
cmd.extract("PRP19_Ba5gm6", "chain f and " + object_name)
cmd.extract("PRP46_Ba5gm6", "chain O and " + object_name)
cmd.extract("SLT11/ECM2_Ba5gm6", "chain Q and " + object_name)
cmd.extract("SNT309_Ba5gm6", "chain t and " + object_name)
cmd.extract("SNU114_Ba5gm6", "chain C and " + object_name)
cmd.extract("SYF2_Ba5gm6", "chain f and " + object_name)
cmd.extract("SYF1_Ba5gm6", "chain v and " + object_name)
cmd.extract("U2_Ba5gm6", "chain 2 and " + object_name)
cmd.extract("U5_Ba5gm6", "chain 5 and " + object_name)
cmd.extract("U6_Ba5gm6", "chain 6 and " + object_name)
cmd.extract("Intron_Ba5gm6", "chain M and " + object_name)
cmd.extract("Exon_Ba5gm6", "chain N and " + object_name)
cmd.extract("BUD13_Ba5gm6", "chain W and " + object_name)
cmd.extract("CLF2_Ba5gm6", "chain d and " + object_name)
cmd.extract("Cus1_Ba5gm6", "chain H and " + object_name)
cmd.extract("CWC24_Ba5gm6", "chain a and " + object_name)
cmd.extract("CWC27_Ba5gm6", "chain b and " + object_name)
cmd.extract("HSH155_Ba5gm6", "chain G and " + object_name)
cmd.extract("HSH49_Ba5gm6", "chain e and " + object_name)
cmd.extract("PML1_Ba5gm6", "chain U and " + object_name)
cmd.extract("PRP11_Ba5gm6", "chain I and " + object_name)
cmd.extract("PRP2_Ba5gm6", "chain Y and " + object_name)
cmd.extract("RDS3_Ba5gm6", "chain J and " + object_name)
cmd.extract("RSE1_Ba5gm6", "chain F and " + object_name)
cmd.extract("SNU17_Ba5gm6", "chain V and " + object_name)
cmd.extract("Ysf3_Ba5gm6", "chain K and " + object_name)
cmd.set_name(object_name, "unknown_other_Ba5gm6")
cmd.group("Ba5gm6", "*_Ba5gm6")
cmd.do("order *, yes")
for n in cmd.get_names("all"):
if '5lj3' in n:
object_name = n
print(object_name)
if '5lj3' in name.lower():
cmd.extract("PRP8_C5lj3", "chain A and " + object_name)
cmd.extract("BUD31_C5lj3", "chain L and " + object_name)
cmd.extract("CEF1_C5lj3", "chain O and " + object_name)
cmd.extract("CLF1_C5lj3", "chain S and " + object_name)
cmd.extract("CWC15_C5lj3", "chain P and " + object_name)
cmd.extract("CWC16/YJU2_C5lj3", "chain D and " + object_name)
cmd.extract("CWC2_hRBM22_C5lj3", "chain M and " + object_name)
cmd.extract("CWC21_C5lj3", "chain R and " + object_name)
cmd.extract("CWC22_C5lj3", "chain H and " + object_name)
cmd.extract("CWC25_C5lj3", "chain F and " + object_name)
cmd.extract("ISY1_C5lj3", "chain G and " + object_name)
cmd.extract("LEA1_C5lj3", "chain W and " + object_name)
cmd.extract("Msl1_C5lj3", "chain Y and " + object_name)
cmd.extract("PRP45_C5lj3", "chain K and " + object_name)
cmd.extract("PRP46_C5lj3", "chain J and " + object_name)
cmd.extract("SLT11/ECM2_C5lj3", "chain N and " + object_name)
cmd.extract("SNU114_C5lj3", "chain C and " + object_name)
cmd.extract("SYF1_C5lj3", "chain T and " + object_name)
cmd.extract("U2_C5lj3", "chain Z and " + object_name)
cmd.extract("U5_C5lj3", "chain U and " + object_name)
cmd.extract("U6_C5lj3", "chain V and " + object_name)
cmd.extract("Intron_C5lj3", "chain I and " + object_name)
cmd.extract("Exon_C5lj3", "chain E and " + object_name)
cmd.extract("SMB1_1_C5lj3", "chain b and " + object_name)
cmd.extract("SMB1_2_C5lj3", "chain k and " + object_name)
cmd.extract("SME1_1_C5lj3", "chain e and " + object_name)
cmd.extract("SME1_2_C5lj3", "chain p and " + object_name)
cmd.extract("SMX3_1_C5lj3", "chain f and " + object_name)
cmd.extract("SMX3_2_C5lj3", "chain q and " + object_name)
cmd.extract("SMX2_1_C5lj3", "chain g and " + object_name)
cmd.extract("SMX2_2_C5lj3", "chain r and " + object_name)
cmd.extract("SMD3_1_C5lj3", "chain d and " + object_name)
cmd.extract("SMD3_2_C5lj3", "chain n and " + object_name)
cmd.extract("SMD1_1_C5lj3", "chain h and " + object_name)
cmd.extract("SMD1_2_C5lj3", "chain l and " + object_name)
cmd.extract("SMD2_1_C5lj3", "chain j and " + object_name)
cmd.extract("SMD2_2_C5lj3", "chain m and " + object_name)
cmd.set_name(object_name, "unknown_other_C5lj3")
cmd.group("C5lj3", "*_C5lj3")
cmd.do("order *, yes")
for n in cmd.get_names("all"):
if '5mps' in n:
object_name = n
print(object_name)
if '5mps' in name.lower():
cmd.extract("PRP8_Cs5mps", "chain A and " + object_name)
cmd.extract("BUD31_Cs5mps", "chain L and " + object_name)
cmd.extract("CEF1_Cs5mps", "chain O and " + object_name)
cmd.extract("CLF1_Cs5mps", "chain S and " + object_name)
cmd.extract("CWC15_Cs5mps", "chain P and " + object_name)
cmd.extract("CWC2_hRBM22_Cs5mps", "chain M and " + object_name)
cmd.extract("CWC21_Cs5mps", "chain R and " + object_name)
cmd.extract("CWC22_Cs5mps", "chain H and " + object_name)
cmd.extract("PRP45_Cs5mps", "chain K and " + object_name)
cmd.extract("CDC40_Cs5mps", "chain o and " + object_name)
cmd.extract("PRP46_Cs5mps", "chain J and " + object_name)
cmd.extract("SLT11/ECM2_Cs5mps", "chain N and " + object_name)
cmd.extract("SNU114_Cs5mps", "chain C and " + object_name)
cmd.extract("SYF2_Cs5mps", "chain y and " + object_name)
cmd.extract("SYF1_Cs5mps", "chain T and " + object_name)
cmd.extract("U2_Cs5mps", "chain 2 and " + object_name)
cmd.extract("U5_Cs5mps", "chain 5 and " + object_name)
cmd.extract("U6_Cs5mps", "chain 6 and " + object_name)
cmd.extract("5EXON_Cs5mps", "chain E and " + object_name)
cmd.extract("Intron_Cs5mps", "chain I and " + object_name)
cmd.extract("Exon_Cs5mps", "chain E and " + object_name)
cmd.extract("SMB1_Cs5mps", "chain b and " + object_name)
cmd.extract("SME1_Cs5mps", "chain e and " + object_name)
cmd.extract("SMX3_Cs5mps", "chain f and " + object_name)
cmd.extract("SMX2_Cs5mps", "chain g and " + object_name)
cmd.extract("SMD3_Cs5mps", "chain d and " + object_name)
cmd.extract("SMD1_Cs5mps", "chain h and " + object_name)
cmd.extract("SMD2_Cs5mps", "chain j and " + object_name)
cmd.extract("PRP18_Cs5mps", "chain a and " + object_name)
cmd.extract("SLU7_Cs5mps", "chain c and " + object_name)
cmd.set_name(object_name, "unknown_other_Cs5mps")
cmd.group("Cs5mps", "*_Cs5mps")
cmd.do("order *, yes")
for n in cmd.get_names("all"):
if '6exn' in n:
object_name = n
print(object_name)
if '6exn' in name.lower():
cmd.extract("PRP8_P6exn", "chain A and " + object_name)
cmd.extract("BUD31_P6exn", "chain L and " + object_name)
cmd.extract("CEF1_P6exn", "chain O and " + object_name)
cmd.extract("CLF1_P6exn", "chain S and " + object_name)
cmd.extract("CWC15_P6exn", "chain P and " + object_name)
cmd.extract("CWC16/YJU2_P6exn", "chain D and " + object_name)
cmd.extract("CWC2_hRBM22_P6exn", "chain M and " + object_name)
cmd.extract("CWC21_P6exn", "chain R and " + object_name)
cmd.extract("CWC22_P6exn", "chain H and " + object_name)
cmd.extract("LEA1_P6exn", "chain W and " + object_name)
cmd.extract("Msl1_P6exn", "chain Y and " + object_name)
cmd.extract("PRP45_P6exn", "chain K and " + object_name)
cmd.extract("CDC40_P6exn", "chain o and " + object_name)
cmd.extract("PRP19_1_P6exn", "chain t and " + object_name)
cmd.extract("PRP19_2_P6exn", "chain u and " + object_name)
cmd.extract("PRP19_3_P6exn", "chain v and " + object_name)
cmd.extract("PRP19_4_P6exn", "chain w and " + object_name)
cmd.extract("PRP46_P6exn", "chain J and " + object_name)
cmd.extract("SLT11/ECM2_P6exn", "chain N and " + object_name)
cmd.extract("SNU114_P6exn", "chain C and " + object_name)
cmd.extract("SYF1_P6exn", "chain T and " + object_name)
cmd.extract("U2_P6exn", "chain 2 and " + object_name)
cmd.extract("U5_P6exn", "chain 5 and " + object_name)
cmd.extract("U6_P6exn", "chain 6 and " + object_name)
cmd.extract("Intron_P6exn", "chain I and " + object_name)
cmd.extract("Exon_P6exn", "chain E and " + object_name)
cmd.extract("SMB1_1_P6exn", "chain b and " + object_name)
cmd.extract("SMB1_2_P6exn", "chain k and " + object_name)
cmd.extract("SME1_1_P6exn", "chain e and " + object_name)
cmd.extract("SME1_2_P6exn", "chain p and " + object_name)
cmd.extract("SMX3_1_P6exn", "chain f and " + object_name)
cmd.extract("SMX3_2_P6exn", "chain q and " + object_name)
cmd.extract("SMX2_1_P6exn", "chain g and " + object_name)
cmd.extract("SMX2_2_P6exn", "chain r and " + object_name)
cmd.extract("SMD3_1_P6exn", "chain d and " + object_name)
cmd.extract("SMD3_2_P6exn", "chain n and " + object_name)
cmd.extract("SMD1_1_P6exn", "chain h and " + object_name)
cmd.extract("SMD1_2_P6exn", "chain l and " + object_name)
cmd.extract("SMD2_1_P6exn", "chain j and " + object_name)
cmd.extract("SMD2_2_P6exn", "chain m and " + object_name)
cmd.extract("PRP22_P6exn", "chain V and " + object_name)
cmd.extract("PRP18_P6exn", "chain a and " + object_name)
cmd.extract("SLU7_P6exn", "chain c and " + object_name)
cmd.extract("unassigned_P6exn", "chain X and " + object_name)
cmd.set_name(object_name, "unknown_other_P6exn")
cmd.group("P6exn", "*_P6exn")
cmd.do("order *, yes")
for n in cmd.get_names("all"):
if '5ylz' in n:
object_name = n
print(object_name)
if '5ylz' in name.lower():
cmd.extract("PRP8_P5ylz", "chain A and " + object_name)
cmd.extract("BUD31_P5ylz", "chain L and " + object_name)
cmd.extract("CEF1_P5ylz", "chain J and " + object_name)
cmd.extract("CLF1_P5ylz", "chain I and " + object_name)
cmd.extract("CWC15_P5ylz", "chain P and " + object_name)
cmd.extract("CWC2_hRBM22_P5ylz", "chain N and " + object_name)
cmd.extract("CWC21_P5ylz", "chain R and " + object_name)
cmd.extract("CWC22_P5ylz", "chain S and " + object_name)
cmd.extract("LEA1_P5ylz", "chain o and " + object_name)
cmd.extract("Msl1_P5ylz", "chain p and " + object_name)
cmd.extract("PRP45_P5ylz", "chain Q and " + object_name)
cmd.extract("CDC40_P5ylz", "chain T and " + object_name)
cmd.extract("PRP19_1_P5ylz", "chain q and " + object_name)
cmd.extract("PRP19_2_P5ylz", "chain r and " + object_name)
cmd.extract("PRP19_3_P5ylz", "chain s and " + object_name)
cmd.extract("PRP19_4_P5ylz", "chain t and " + object_name)
cmd.extract("PRP46_P5ylz", "chain O and " + object_name)
cmd.extract("SLT11/ECM2_P5ylz", "chain M and " + object_name)
cmd.extract("SNT309_P5ylz", "chain G and " + object_name)
cmd.extract("SNU114_P5ylz", "chain C and " + object_name)
cmd.extract("SYF2_P5ylz", "chain K and " + object_name)
cmd.extract("SYF1_P5ylz", "chain H and " + object_name)
cmd.extract("U2_P5ylz", "chain F and " + object_name)
cmd.extract("U5_P5ylz", "chain B and " + object_name)
cmd.extract("U6_P5ylz", "chain D and " + object_name)
cmd.extract("Intron_P5ylz", "chain E and " + object_name)
cmd.extract("SMB1_1_P5ylz", "chain a and " + object_name)
cmd.extract("SMB1_2_P5ylz", "chain h and " + object_name)
cmd.extract("SME1_1_P5ylz", "chain b and " + object_name)
cmd.extract("SME1_2_P5ylz", "chain i and " + object_name)
cmd.extract("SMX3_1_P5ylz", "chain c and " + object_name)
cmd.extract("SMX3_2_P5ylz", "chain j and " + object_name)
cmd.extract("SMX2_1_P5ylz", "chain d and " + object_name)
cmd.extract("SMX2_2_P5ylz", "chain k and " + object_name)
cmd.extract("SMD3_1_P5ylz", "chain e and " + object_name)
cmd.extract("SMD3_2_P5ylz", "chain l and " + object_name)
cmd.extract("SMD1_1_P5ylz", "chain f and " + object_name)
cmd.extract("SMD1_2_P5ylz", "chain m and " + object_name)
cmd.extract("SMD2_1_P5ylz", "chain g and " + object_name)
cmd.extract("SMD2_2_P5ylz", "chain n and " + object_name)
cmd.extract("PRP22_P5ylz", "chain W and " + object_name)
cmd.extract("PRP18_P5ylz", "chain U and " + object_name)
cmd.extract("SLU7_P5ylz", "chain V and " + object_name)
cmd.set_name(object_name, "unknown_other_P5ylz")
cmd.group("P5ylz", "*_P5ylz")
cmd.do("order *, yes")
for n in cmd.get_names("all"):
if '5y88' in n:
object_name = n
print(object_name)
if '5y88' in name.lower():
cmd.extract("PRP8_I5y88", "chain A and " + object_name)
cmd.extract("BUD31_I5y88", "chain L and " + object_name)
cmd.extract("CLF1_I5y88", "chain I and " + object_name)
cmd.extract("CWC15_I5y88", "chain P and " + object_name)
cmd.extract("CWC16/YJU2_I5y88", "chain R and " + object_name)
cmd.extract("CWC2_hRBM22_I5y88", "chain N and " + object_name)
cmd.extract("CWC25_I5y88", "chain G and " + object_name)
cmd.extract("Intron_2_I5y88", "chain E and " + object_name)
cmd.extract("LEA1_I5y88", "chain o and " + object_name)
cmd.extract("Msl1_I5y88", "chain p and " + object_name)
cmd.extract("PRP45_I5y88", "chain Q and " + object_name)
cmd.extract("CDC40_I5y88", "chain S and " + object_name)
cmd.extract("PRP19_1_I5y88", "chain q and " + object_name)
cmd.extract("PRP19_2_I5y88", "chain r and " + object_name)
cmd.extract("PRP19_3_I5y88", "chain s and " + object_name)
cmd.extract("PRP19_4_I5y88", "chain t and " + object_name)
cmd.extract("PRP46_I5y88", "chain O and " + object_name)
cmd.extract("SLT11/ECM2_I5y88", "chain M and " + object_name)
cmd.extract("SNT309_I5y88", "chain G and " + object_name)
cmd.extract("SNU114_I5y88", "chain C and " + object_name)
cmd.extract("SYF2_I5y88", "chain K and " + object_name)
cmd.extract("SYF1_I5y88", "chain H and " + object_name)
cmd.extract("U2_I5y88", "chain F and " + object_name)
cmd.extract("U5_I5y88", "chain B and " + object_name)
cmd.extract("U6_I5y88", "chain D and " + object_name)
cmd.extract("Intron_I5y88", "chain x and " + object_name)
cmd.extract("RNA_I5y88", "chain x and " + object_name)
cmd.extract("cwc23_I5y88", "chain T and " + object_name)
cmd.extract("SPP382_I5y88", "chain U and " + object_name)
cmd.extract("NTR2_I5y88", "chain V and " + object_name)
cmd.extract("PRP43_I5y88", "chain W and " + object_name)
cmd.extract("SMB1_1_I5y88", "chain a and " + object_name)
cmd.extract("SMB1_2_I5y88", "chain h and " + object_name)
cmd.extract("SME1_1_I5y88", "chain b and " + object_name)
cmd.extract("SME1_2_I5y88", "chain i and " + object_name)
cmd.extract("SMX3_1_I5y88", "chain c and " + object_name)
cmd.extract("SMX3_2_I5y88", "chain j and " + object_name)
cmd.extract("SMX2_1_I5y88", "chain d and " + object_name)
cmd.extract("SMX2_2_I5y88", "chain k and " + object_name)
cmd.extract("SMD3_1_I5y88", "chain e and " + object_name)
cmd.extract("SMD3_2_I5y88", "chain l and " + object_name)
cmd.extract("SMD1_1_I5y88", "chain f and " + object_name)
cmd.extract("SMD1_2_I5y88", "chain m and " + object_name)
cmd.extract("SMD2_1_I5y88", "chain g and " + object_name)
cmd.extract("SMD2_2_I5y88", "chain n and " + object_name)
cmd.set_name(object_name, "unknown_other_I5y88")
cmd.group("I5y88", "*_I5y88")
cmd.do("order *, yes")
for n in cmd.get_names("all"):
if '3jb9' in n:
object_name = n
print(object_name)
if '3jb9' in name.lower():
cmd.extract("U2_3jb9", "chain P and " + object_name)
cmd.extract("U5_3jb9", "chain C and " + object_name)
cmd.extract("U6_3jb9", "chain N and " + object_name)
cmd.extract("Intron_1_3jb9", "chain O and " + object_name)
cmd.extract("Intron_2_3jb9", "chain Q and " + object_name)
cmd.extract("Spp42_yPrp8_3jb9", "chain A and " + object_name)
cmd.extract("CWF15_yCWC15_3jb9", "chain h and " + object_name)
cmd.set_name(object_name, "unknown_other_3jb9")
cmd.group("3jb9", "*_3jb9")
cmd.do("order *, yes")
for n in cmd.get_names("all"):
if '6icz' in n:
object_name = n
print(object_name)
if '6icz' in name.lower():
cmd.extract("CWC15_hP_6icz", "chain P and " + object_name)
cmd.extract("U2_hP_6icz", "chain H and " + object_name)
cmd.extract("U5_hP_6icz", "chain B and " + object_name)
cmd.extract("U6_hP_6icz", "chain F and " + object_name)
cmd.extract("Intron_hP_6icz", "chain G and " + object_name)
cmd.extract("cwc23_hP_6icz", "chain 6ICZ and " + object_name)
cmd.set_name(object_name, "unknown_other_hP_6icz")
cmd.group("hP_6icz", "*_hP_6icz")
cmd.do("order *, yes")
for n in cmd.get_names("all"):
if '6ff7' in n:
object_name = n
print(object_name)
if '6ff7' in name.lower():
cmd.extract("CWC15_hBa_6ff7", "chain R and " + object_name)
cmd.extract("CWC2_hRBM22_hBa_6ff7", "chain P and " + object_name)
cmd.extract("U2_hBa_6ff7", "chain 2 and " + object_name)
cmd.extract("U5_hBa_6ff7", "chain 5 and " + object_name)
cmd.extract("U6_hBa_6ff7", "chain 6 and " + object_name)
cmd.extract("Intron_hBa_6ff7", "chain Z and " + object_name)
cmd.set_name(object_name, "unknown_other_hBa_6ff7")
cmd.group("hBa_6ff7", "*_hBa_6ff7")
cmd.do("order *, yes")
for n in cmd.get_names("all"):
if '5yzg' in n:
object_name = n
print(object_name)
if '5yzg' in name.lower():
cmd.extract("CWC15_hC_5yzg", "chain P and " + object_name)
cmd.extract("CWC2_hRBM22_hC_5yzg", "chain O and " + object_name)
cmd.extract("CWC25_hC_5yzg", "chain X and " + object_name)
cmd.extract("PRP16_hDHX38_hC_5yzg", "chain Z and " + object_name)
cmd.extract("U2_hC_5yzg", "chain H and " + object_name)
cmd.extract("U5_hC_5yzg", "chain B and " + object_name)
cmd.extract("U6_hC_5yzg", "chain F and " + object_name)
cmd.extract("Intron_hC_5yzg", "chain G and " + object_name)
cmd.set_name(object_name, "unknown_other_hC_5yzg")
cmd.group("hC_5yzg", "*_hC_5yzg")
cmd.do("order *, yes")
for n in cmd.get_names("all"):
if '5xjc' in n:
object_name = n
print(object_name)
if '5xjc' in name.lower():
cmd.extract("CWC15_hX_5xjc", "chain P and " + object_name)
cmd.extract("CWC25_hX_5xjc", "chain X and " + object_name)
cmd.extract("U2_hX_5xjc", "chain H and " + object_name)
cmd.extract("U5_hX_5xjc", "chain B and " + object_name)
cmd.extract("U6_hX_5xjc", "chain F and " + object_name)
cmd.extract("Intron_hX_5xjc", "chain G and " + object_name)
cmd.extract("PRKRIP1_hX_5xjc", "chain X and " + object_name)
cmd.set_name(object_name, "unknown_other_hX_5xjc")
cmd.group("hX_5xjc", "*_hX_5xjc")
cmd.do("order *, yes")
for n in cmd.get_names("all"):
if '5gan' in n:
object_name = n
print(object_name)
if '5gan' in name.lower():
cmd.extract("PRP8_y3_5gan", "chain A and " + object_name)
cmd.extract("BRR2_y3_5gan", "chain B and " + object_name)
cmd.extract("PRP45_y3_5gan", "chain H and " + object_name)
cmd.extract("SNU114_y3_5gan", "chain C and " + object_name)
cmd.extract("U5_y3_5gan", "chain U and " + object_name)
cmd.extract("U6_y3_5gan", "chain W and " + object_name)
cmd.extract("U4_y3_5gan", "chain V and " + object_name)
cmd.extract("PRP31_y3_5gan", "chain F and " + object_name)
cmd.extract("PRP6_y3_5gan", "chain J and " + object_name)
cmd.extract("PRP3_y3_5gan", "chain G and " + object_name)
cmd.extract("DIB1_y3_5gan", "chain D and " + object_name)
cmd.extract("SNU13_y3_5gan", "chain K and " + object_name)
cmd.extract("LSM8_y3_5gan", "chain 8 and " + object_name)
cmd.extract("LSM2_y3_5gan", "chain 2 and " + object_name)
cmd.extract("LSM3_y3_5gan", "chain 3 and " + object_name)
cmd.extract("LSM6_y3_5gan", "chain 6 and " + object_name)
cmd.extract("LSM5_y3_5gan", "chain 5 and " + object_name)
cmd.extract("LSM7_y3_5gan", "chain 7 and " + object_name)
cmd.extract("LSM4_y3_5gan", "chain 4 and " + object_name)
cmd.extract("SNU66_y3_5gan", "chain E and " + object_name)
cmd.extract("SMB1_1_y3_5gan", "chain b and " + object_name)
cmd.extract("SMB1_2_y3_5gan", "chain k and " + object_name)
cmd.extract("SME1_1_y3_5gan", "chain e and " + object_name)
cmd.extract("SME1_2_y3_5gan", "chain p and " + object_name)
cmd.extract("SMX3_1_y3_5gan", "chain f and " + object_name)
cmd.extract("SMX3_2_y3_5gan", "chain q and " + object_name)
cmd.extract("SMX2_1_y3_5gan", "chain g and " + object_name)
cmd.extract("SMX2_2_y3_5gan", "chain r and " + object_name)
cmd.extract("SMD3_1_y3_5gan", "chain d and " + object_name)
cmd.extract("SMD3_2_y3_5gan", "chain n and " + object_name)
cmd.extract("SMD1_1_y3_5gan", "chain h and " + object_name)
cmd.extract("SMD1_2_y3_5gan", "chain l and " + object_name)
cmd.extract("SMD2_1_y3_5gan", "chain j and " + object_name)
cmd.extract("SMD2_2_y3_5gan", "chain m and " + object_name)
cmd.extract("unassigned_y3_5gan", "chain X and " + object_name)
cmd.set_name(object_name, "unknown_other_y3_5gan")
cmd.group("y3_5gan", "*_y3_5gan")
cmd.do("order *, yes")
for n in cmd.get_names("all"):
if '6qw6' in n:
object_name = n
print(object_name)
if '6qw6' in name.lower():
cmd.extract("PRP8_h3_6qw6", "chain 5A and " + object_name)
cmd.extract("U5_h3_6qw6", "chain 5 and " + object_name)
cmd.extract("U6_h3_6qw6", "chain 6 and " + object_name)
cmd.extract("U4_h3_6qw6", "chain 4 and " + object_name)
cmd.extract("Prp28_h3_6qw6", "chain 5X and " + object_name)
cmd.set_name(object_name, "unknown_other_h3_6qw6")
cmd.group("h3_6qw6", "*_h3_6qw6")
cmd.do("order *, yes")
for n in cmd.get_names("all"):
if '3jcr' in n:
object_name = n
print(object_name)
if '3jcr' in name.lower():
cmd.extract("PRP8_h3_3jcr", "chain A and " + object_name)
cmd.extract("BRR2_h3_3jcr", "chain C and " + object_name)
cmd.extract("SNU114_h3_3jcr", "chain B and " + object_name)
cmd.extract("U5_h3_3jcr", "chain H and " + object_name)
cmd.extract("U6_h3_3jcr", "chain N and " + object_name)
cmd.extract("U4_h3_3jcr", "chain M and " + object_name)
cmd.extract("PRP4_h3_3jcr", "chain L and " + object_name)
cmd.extract("PRP31_h3_3jcr", "chain J and " + object_name)
cmd.extract("PRP6_h3_3jcr", "chain G and " + object_name)
cmd.extract("PRP3_h3_3jcr", "chain K and " + object_name)
cmd.extract("SNU13_h3_3jcr", "chain I and " + object_name)
cmd.extract("LSM8_h3_3jcr", "chain 8 and " + object_name)
cmd.extract("LSM2_h3_3jcr", "chain 2 and " + object_name)
cmd.extract("LSM3_h3_3jcr", "chain 3 and " + object_name)
cmd.extract("LSM5_h3_3jcr", "chain 5 and " + object_name)
cmd.extract("LSM7_h3_3jcr", "chain 7 and " + object_name)
cmd.extract("LSM4_h3_3jcr", "chain 4 and " + object_name)
cmd.extract("SMD3_1_h3_3jcr", "chain R and " + object_name)
cmd.extract("SMD3_2_h3_3jcr", "chain r and " + object_name)
cmd.extract("SMD1_1_h3_3jcr", "chain P and " + object_name)
cmd.extract("SMD1_2_h3_3jcr", "chain p and " + object_name)
cmd.extract("SMD2_1_h3_3jcr", "chain Q and " + object_name)
cmd.extract("SMD2_2_h3_3jcr", "chain q and " + object_name)
cmd.extract("U5-40K_h3_3jcr", "chain D and " + object_name)
cmd.extract("Dim1_h3_3jcr", "chain E and " + object_name)
cmd.extract("Prp28_h3_3jcr", "chain F and " + object_name)
cmd.extract("SmE_1_h3_3jcr", "chain S and " + object_name)
cmd.extract("SmE_2_h3_3jcr", "chain s and " + object_name)
cmd.extract("SmF_1_h3_3jcr", "chain T and " + object_name)
cmd.extract("SmF_2_h3_3jcr", "chain t and " + object_name)
cmd.extract("SmG_1_h3_3jcr", "chain U and " + object_name)
cmd.extract("SmG_2_h3_3jcr", "chain u and " + object_name)
cmd.extract("Sad1_h3_3jcr", "chain V and " + object_name)
cmd.extract("SmB_1_h3_3jcr", "chain O and " + object_name)
cmd.extract("SmB_2_h3_3jcr", "chain o and " + object_name)
cmd.set_name(object_name, "unknown_other_h3_3jcr")
cmd.group("h3_3jcr", "*_h3_3jcr")
cmd.do("order *, yes")
for n in cmd.get_names("all"):
if '6qx9' in n:
object_name = n
print(object_name)
if '6qx9' in name.lower():
cmd.extract("PRP8_h3_6qx9", "chain 5A and " + object_name)
cmd.extract("U2_h3_6qx9", "chain 2 and " + object_name)
cmd.extract("U5_h3_6qx9", "chain 5 and " + object_name)
cmd.extract("U6_h3_6qx9", "chain 6 and " + object_name)
cmd.extract("U4_h3_6qx9", "chain 4 and " + object_name)
cmd.extract("Intron_h3_6qx9", "chain I and " + object_name)
cmd.extract("U1_h3_6qx9", "chain 1 and " + object_name)
cmd.extract("Prp28_h3_6qx9", "chain 5X and " + object_name)
cmd.set_name(object_name, "unknown_other_h3_6qx9")
cmd.group("h3_6qx9", "*_h3_6qx9")
cmd.do("order *, yes")
for n in cmd.get_names("all"):
if '6ah0' in n:
object_name = n
print(object_name)
if '6ah0' in name.lower():
cmd.extract("PRP8_h_Bp_6ah0", "chain A and " + object_name)
cmd.extract("U2_h_Bp_6ah0", "chain H and " + object_name)
cmd.extract("U5_h_Bp_6ah0", "chain B and " + object_name)
cmd.extract("U6_h_Bp_6ah0", "chain F and " + object_name)
cmd.extract("U4_h_Bp_6ah0", "chain I and " + object_name)
cmd.extract("Intron_h_Bp_6ah0", "chain G and " + object_name)
cmd.extract("Prp28_h_Bp_6ah0", "chain X and " + object_name)
cmd.set_name(object_name, "unknown_other_h_Bp_6ah0")
cmd.group("h_Bp_6ah0", "*_h_Bp_6ah0")
cmd.do("order *, yes")
def _add_vis(self, mymol, row, l_cgo):
if (self.is_only_water_access and (not "WAT" in [row.rnm1, row.rnm2])):
return None
mycolind = int((np.sign(row.sdiff) + 1) / 2)
if self.df_rgn_seg_res_bb is None:
cmd.select(
"sel1", "/%s/%s and i. %d and %s and not h." %
(mymol, row.seg1, row.res1, self.bb2selstr[row.bb1]))
cmd.select(
"sel2", "/%s/%s and i. %d and %s and not h." %
(mymol, row.seg2, row.res2, self.bb2selstr[row.bb2]))
else:
if "bb" in self.df_rgn_seg_res_bb:
df_unique_rgnsegbb = self.df_rgn_seg_res_bb[[
"seg", "bb"
]].drop_duplicates()
for myrgn in [row.rgn1, row.rgn2]:
selstr = "/%s and (" % (mymol)
for sindex, srow in df_unique_rgnsegbb.iterrows():
df_sel = self.df_rgn_seg_res_bb.query(
"rgn == '%s' and seg == '%s' and bb == %d" %
(myrgn, srow.seg, srow.bb))
if df_sel.shape[0] > 0:
selstr += "(c. %s and i. %s and %s) or" % (
srow.seg, "+".join(
[str(x)
for x in df_sel.res.values[0]]), srow.bb)
selstr = selstr[:-3] + ")"
cmd.select("%s" % myrgn, selstr)
else:
df_unique_rgnsegbb = self.df_rgn_seg_res_bb[[
"seg"
]].drop_duplicates()
for myrgn in [row.rgn1, row.rgn2]:
selstr = "/%s and (" % (mymol)
for sindex, srow in df_unique_rgnsegbb.iterrows():
df_sel = self.df_rgn_seg_res_bb.query(
"rgn == '%s' and seg == '%s'" %
(row.rgn1, srow.seg))
if df_sel.shape[0] > 0:
selstr += "(c. %s and i. %s) or" % (
srow.seg, "+".join(
[str(x) for x in df_sel.res.values[0]]))
selstr = selstr[:-3] + ")"
cmd.select("%s" % myrgn, selstr)
cmd.set_name("%s" % row.rgn1, "sel1")
cmd.set_name("%s" % row.rgn2, "sel2")
count1 = cmd.count_atoms("sel1")
count2 = cmd.count_atoms("sel2")
if count1 == 0:
if count2 == 0:
raise ValueError(
"counts of both %s.%d.%s.%d and %s.%d.%s.%d are zero!" %
(row.seg1, row.res1, row.rnm1, row.bb1, row.seg2, row.res2,
row.rnm2, row.bb2))
else:
if self.df_rgn_seg_res_bb is None:
cmd.show("sticks", "sel2")
#cmd.color(self.sgn2col[mycolind], "sel2")
else:
com("sel2", state=1)
coord2 = cmd.get_model("sel2_COM", state=1).atom[0].coord
cmd.delete("sel2_COM")
cmd.color(self.sgn2col[mycolind], "sel2")
l_cgo += [ \
COLOR, self.l_r[mycolind], self.l_g[mycolind], self.l_b[mycolind], \
SPHERE, coord2[0], coord2[1],coord2[2], self.sphererad \
]
elif count2 == 0:
if self.df_rgn_seg_res_bb is None:
cmd.show("sticks", "sel1")
#cmd.color(self.sgn2col[mycolind], "sel1")
else:
com("sel1", state=1)
cmd.color(self.sgn2col[mycolind], "sel1")
coord1 = cmd.get_model("sel1_COM", state=1).atom[0].coord
cmd.delete("sel1_COM")
l_cgo += [ \
COLOR, self.l_r[mycolind], self.l_g[mycolind], self.l_b[mycolind], \
SPHERE, coord1[0], coord1[1],coord1[2], self.sphererad \
]
else:
com("sel1", state=1)
coord1 = cmd.get_model("sel1_COM", state=1).atom[0].coord
cmd.delete("sel1_COM")
com("sel2", state=1)
coord2 = cmd.get_model("sel2_COM", state=1).atom[0].coord
cmd.delete("sel2_COM")
l_cgo += [ \
LINEWIDTH, self.linewidth, \
BEGIN, LINES, \
COLOR, self.l_r[mycolind], self.l_g[mycolind], self.l_b[mycolind], \
VERTEX, coord1[0], coord1[1],coord1[2], \
VERTEX, coord2[0], coord2[1],coord2[2], \
END \
]
if self.df_rgn_seg_res_bb is None:
cmd.show("sticks", "sel1")
cmd.show("sticks", "sel2")
util.cbag("sel1")
util.cbag("sel2")
else:
cmd.color(self.sgn2col[mycolind], "sel1")
cmd.color(self.sgn2col[mycolind], "sel2")
cmd.delete("sel1")
cmd.delete("sel2")
def cyspka(molecule, chain, residue, SeeProgress='yes', pH=7.2, MoveSGatom='no', SGatom=str((0, 0, 0))):
# If SeeProgress='yes', computation time will take 10-20% extra, but nice to follow.
cmd.refresh()
RotationRange = 360
RotationDegree = 1
# For error checking, the energies can be printed out
printMC = 'no'
printSC = 'no'
# Parameters
DieElecSpheDist = 7.0
DieElecWaterDist = 1.4
DieElecWater = 78.5
DieElecCore = 4.0
BornPenaltyB = 1.0
AvogadroR = 8.31446216
Temp = 298
DeltapKMCSC = 0
pK1 = 9.25
pK2 = 8.0
NotPopuDist = 2.4
PopEnergyPenalty = 10000000
# Side chain discrete charges
DieElecSC = 40.0
SCchargeASP = -1
SCchargeGLU = -1
SCchargeOXT = -1
SCchargeARG = +1
SCchargeHIS = +1
SCchargeLYS = +1
SCchargeMET1 = +1
# Main chain partial charges
NrMainchainNeighBours = 5
DieElecMC = 22.0
MCchargeC = +0.55
MCchargeO = -0.55
MCchargeN = -0.35
MCchargeH = +0.35
MCchargeProCA = +0.1
MCchargeProCD = +0.1
MCchargeProN = -0.2
# Loading an Cys residue, give it a logic name, and aligning it. The oxygen atom can not be aligned in many cases, and are skipped.
# We use only this molecule, to find the initial position of the SG atom, and to rotate the SG atom around the CA-CB bond. The molecule atom positions are not used for electric potential calculatons.
Cysmolecule = str(molecule) + str(residue) + "Cys"
cmd.fragment("cys")
cmd.set_name('cys', Cysmolecule)
# We use pair_fir, since align and super gets unstable with so few atoms
pairfitCys(Cysmolecule, molecule, chain, residue)
# Give nice representations quickly
cmd.show("sticks", Cysmolecule)
cmd.select(str(molecule) + str(residue) + "Res", "/" + molecule + "//" + chain + "/" + residue)
print("/" + molecule + "//" + chain + "/" + residue)
cmd.show("sticks", str(molecule) + str(residue) + "Res")
cmd.disable(str(molecule) + str(residue) + "Res")
# Find out what is the residuename we are investigating for
Respdbstr = cmd.get_pdbstr(str(molecule) + str(residue) + "Res")
Ressplit = Respdbstr.split()
residueName = Ressplit[3]
print("")
print("# Hello, PyMOLers. It should take around 1 minute per residue.")
print("# molecule: %s , chain: %s, residue: %s %s, pH: %s " % (molecule, chain, residueName, residue, pH))
# Determine the range of neighbour residues possible.
Maxresidues = cmd.count_atoms("/" + molecule + "//" + chain + " and name CA")
for i in range(NrMainchainNeighBours + 1):
if int(residue) - i >= 1:
Minresidue = int(residue) - i
else:
break
for i in range(NrMainchainNeighBours + 1):
if int(residue) + i <= Maxresidues:
Maxresidue = int(residue) + i
else:
break
# Get the position and the vector for the CA->CB bond.
dihedN = "/" + Cysmolecule + "//" + "/" + "/N"
dihedCA = "/" + Cysmolecule + "//" + "/" + "/CA"
dihedCB = "/" + Cysmolecule + "//" + "/" + "/CB"
dihedSG = "/" + Cysmolecule + "//" + "/" + "/SG"
dihedralPosCA = cmd.get_atom_coords(dihedCA)
dihedralPosSG = cmd.get_atom_coords(dihedSG)
dihedralVector = AtomVector(dihedCA, dihedCB)
# To compare with article, we can move the SGatom to a starting position. The rotation is still determined around the CA-CB bond.
if MoveSGatom == 'yes':
SGatom = [float(SGatom[1:-1].split(",")[0]), float(SGatom[1:-1].split(",")[1]), float(SGatom[1:-1].split(",")[2])]
Translate = [(SGatom[0] - dihedralPosSG[0]), (SGatom[1] - dihedralPosSG[1]), (SGatom[2] - dihedralPosSG[2])]
cmd.translate(Translate, dihedSG, state=0, camera=0)
dihedralPosSG = cmd.get_atom_coords(dihedSG)
# Create a pymol molecule, that in the end will hold and show all SG atoms. Gives the representation of the rotameric states.
SGName = str(molecule) + str(residue) + "SG"
cmd.create(SGName, "None")
# Create a pymol molecule, that in the end will hold and show all Amide protons. Gives a nice representation, and easy to delete.
AmideName = str(molecule) + str(residue) + "NH"
cmd.create(AmideName, "None")
# Check if there are any nearby SG atoms, which could make a SG-SG dimer formation. The
breakDimer = "no"
breakDimer = CheckDimer(dihedSG, molecule, chain, residue)
# Create a list for appending the calculated energies.
ListofEnergies = []
ListofRotamerDiscarded = []
# print "Angle before rotation", cmd.get_dihedral(dihedN,dihedCA,dihedCB,dihedSG)
# Enter into the loop of rotameric states
for i in range(int(math.floor(RotationRange / RotationDegree))):
Angle = i * RotationDegree
# Create pymol molecule/SG atom for which we will calculate for.
SGNameAngle = str(residue) + "SG" + str(Angle)
cmd.create(SGNameAngle, dihedSG)
# Calculate new coordinates for rotation around CA->CB bond. Then translate the created SG atom.
SGNewPos = fRotateAroundLine(dihedralPosSG, dihedralPosCA, dihedralVector, Angle)
Translate = [(SGNewPos[0] - dihedralPosSG[0]), (SGNewPos[1] - dihedralPosSG[1]), (SGNewPos[2] - dihedralPosSG[2])]
cmd.translate(Translate, SGNameAngle, state=0, camera=0)
# If one wants to "see it happen" while its making the states. But it will take extra computation time.
if SeeProgress == 'yes':
cmd.refresh()
# Calculate number of neighbours within 2.4 Angstrom. Amide hydrogens are not considered, and are actually not build yet.
nameselect = "(((/" + molecule + "//" + chain + " and not /" + molecule + "//" + chain + "/" + residue + ") or /" + molecule + "//" + chain + "/" + residue + "/N+CA+C+O) within " + str(NotPopuDist) + " of /" + SGNameAngle + "//" + "/" + "/SG) and not resn HOH"
# print nameselect
cmd.select("NotPop", nameselect)
NotPopNr = cmd.count_atoms("NotPop")
# print Angle, NotPopNr, cmd.get_dihedral(dihedN,dihedCA,dihedCB,SGNameAngle)
# If no neighbours, then proceed calculating
if NotPopNr == 0:
SumAllWMC = 0.0
# Now calculate the electric potential due to the side chains.
SumWSC = fSumWSC(molecule, SGNameAngle, chain, residue, DieElecSC, SCchargeASP, SCchargeGLU, SCchargeOXT, SCchargeARG, SCchargeHIS, SCchargeLYS, SCchargeMET1, printSC)
# Now we calculate for the flanking 5 peptide groups on each side of the Cysteine CA atom.
# For the first residue, only calculate for the tailing C,O atom in the peptide bond. No test for Proline.
SumWMCFirst = fSumWMCFirst(molecule, SGNameAngle, chain, residue, Minresidue, DieElecMC, MCchargeC, MCchargeO, printMC)
# For the residue itself, we dont test for PRO, since it should be a Cysteine.
SumWMCresidue = fSumWMCresidue(molecule, SGNameAngle, chain, residue, int(residue), DieElecMC, MCchargeC, MCchargeO, MCchargeN, MCchargeH, AmideName, printMC)
# For the last residue, we test for Proline. We only calculate for the N,H atom, or if Proline, N,CA and CD atom.
SumWMCLast = fSumWMCLast(molecule, SGNameAngle, chain, residue, Maxresidue, DieElecMC, MCchargeN, MCchargeH, MCchargeProCA, MCchargeProCD, MCchargeProN, AmideName, printMC)
# Then loop over rest of the residues in the chain.
for j in (list(range(Minresidue + 1, int(residue))) + list(range(int(residue) + 1, Maxresidue))):
MCNeighbour = j
# print "Looking at neighbour", j
SumWMC = fSumWMC(molecule, SGNameAngle, chain, residue, MCNeighbour, DieElecMC, MCchargeC, MCchargeO, MCchargeN, MCchargeH, MCchargeProCA, MCchargeProCD, MCchargeProN, AmideName, printMC)
SumAllWMC = SumAllWMC + SumWMC
# print "Rotation: %s Neighbour: %s " % (Angle, j)
# Since the SG atom is negative, we multiply with -1.
SumMCSC = -1 * (SumWSC + SumWMCFirst + SumWMCresidue + SumWMCLast + SumAllWMC)
# Makes the neighbour count. Everything in 'molecule" within 7 ang of aligned SG atom. Not counting 'residue'. Adding 5 for 'residue' N,CA,C,O,CB
ListNeighbourCount = fNeighbourCount(molecule, SGNameAngle, chain, residue, DieElecSpheDist)
# Calculate the weighted electric potential and alter the b factor for coloring. Then add the rotated SG into bucket of SG atoms.
SG_MCSC_Weight = fBoltzSingleState(SumMCSC, AvogadroR, Temp) * SumMCSC
cmd.alter(SGNameAngle, 'b="%s"' % SG_MCSC_Weight)
cmd.alter(SGNameAngle, 'name="S%s"' % Angle)
cmd.create(SGName, SGName + " + " + SGNameAngle)
# Then save the calculated values
ListofEnergies.append([Angle, SumMCSC, ListNeighbourCount, NotPopNr, SG_MCSC_Weight, cmd.get_atom_coords(SGNameAngle)])
cmd.delete(SGNameAngle)
else:
SumMCSCPenalty = PopEnergyPenalty
ListNeighbourCount = fNeighbourCount(molecule, SGNameAngle, chain, residue, DieElecSpheDist)
ListofRotamerDiscarded.append([Angle, SumMCSCPenalty, ListNeighbourCount, NotPopNr, 0, cmd.get_atom_coords(SGNameAngle)])
cmd.delete(SGNameAngle)
# Now show all the SG atoms as the available rotameric states.
cmd.show("nb_spheres", SGName)
cmd.delete("NotPop")
cmd.spectrum("b", selection=SGName)
AvailRotStates = len(ListofEnergies)
# print "Available Rotational States: ", AvailRotStates
# Do the calculations according to eq 5.
# Find the partition function
BoltzPartition = 0.0
for i in range(len(ListofEnergies)):
Boltz = fBoltzSingleState(ListofEnergies[i][1], AvogadroR, Temp)
BoltzPartition = BoltzPartition + Boltz
# Find the summed function
BoltzSumNi = 0.0
for i in range(len(ListofEnergies)):
BoltzNi = fBoltzSingleState(ListofEnergies[i][1], AvogadroR, Temp) * ListofEnergies[i][1]
BoltzSumNi = BoltzSumNi + BoltzNi
# Check if there was any possible rotamers
nostates = "no"
if len(ListofEnergies) == 0:
print("####################################################")
print("########### WARNING: No states available ###########")
print("########### Did you mutate a Glycine? ###########")
print("####################################################")
BoltzSumNi = 0
BoltzPartition = 0
BoltzMCSC = 0
DeltapKMCSC = 99
NeighbourCount = 0
nostates = "yes"
else:
# Final calculation
BoltzMCSC = (BoltzSumNi) / (BoltzPartition)
DeltapKMCSC = fDeltapK(BoltzMCSC, AvogadroR, Temp)
# Find average number of neighbours
NCSum = 0.0
NCWeightedSum = 0.0
for i in range(len(ListofEnergies)):
NCi = ListofEnergies[i][2]
NCSum = NCSum + NCi
NCWeightedi = fBoltzSingleState(ListofEnergies[i][1], AvogadroR, Temp) * ListofEnergies[i][2] / BoltzPartition
NCWeightedSum = NCWeightedSum + NCWeightedi
# print "Weighted neighbour", int(round(NCWeightedSum))
#NeighbourCount = int(round(NCSum/len(ListofEnergies)))
NeighbourCount = round(NCWeightedSum, 1)
# If we found dimers
if breakDimer == "yes":
print("####################################################")
print("########### WARNING: Dimer formation? ###########")
print("####################################################")
BoltzSumNi = 0
BoltzPartition = 0
BoltzMCSC = 0
DeltapKMCSC = 99
NeighbourCount = 0
# Calculate the BornPenalty based on the neighbour count. It's a wrapper script for equation 13, 12, 11.
EnergyBornPenalty = fEnergyBornPenalty(DieElecSpheDist, DieElecWaterDist, NeighbourCount, DieElecWater, DieElecCore, BornPenaltyB)
DeltapKB = fDeltapK(EnergyBornPenalty, AvogadroR, Temp)
# Do the calculations according to eq 3 and 9.
pKm1 = fpKm1(DeltapKMCSC, pK1)
pKm2 = fpKm2(DeltapKMCSC, DeltapKB, pK2)
FracCysm1 = fFracCys(pKm1, pH)
FracCysm2 = fFracCys(pKm2, pH)
# Lets make a result file, and write out the angle, the SumMCSC, and the number of neighbours for this state.
Currentdir = os.getcwd()
Newdir = os.path.join(os.getcwd(), "Results")
if not os.path.exists(Newdir):
os.makedirs(Newdir)
filename = os.path.join(".", "Results", "Result_" + molecule + "_" + chain + "_" + residue + ".txt")
filenamelog = os.path.join(".", "Results", "Result_log.log")
logfile = open(filenamelog, "a")
outfile = open(filename, "w")
timeforlog = strftime("%Y %b %d %a %H:%M:%S", localtime())
logfile.write("# " + timeforlog + "\n")
logfile.write("# molecule: %s , chain: %s, residue: %s %s, pH: %s " % (molecule, chain, residueName, residue, pH) + "\n")
logfile.write("# BoltzSumNi: BoltzPartition: BoltzMCSC" + "\n")
logfile.write(("# %.4f %.4f %.4f" + '\n') % (BoltzSumNi, BoltzPartition, BoltzMCSC))
logfile.write("# Res NC States pKmcsc pK1 pKB pK2 pKm1 pKm2 f(C-)m1 f(C-)m2" + "\n")
logfile.write(("; %s %s %s %s %.4f %s %.4f %s %.4f %.4f %.6f %.6f" + '\n') % (residueName, residue, NeighbourCount, AvailRotStates, DeltapKMCSC, pK1, DeltapKB, pK2, pKm1, pKm2, FracCysm1, FracCysm2))
if nostates == "yes":
logfile.write("##### ERROR; No states available ###" + "\n")
if breakDimer == "yes":
logfile.write("##### ERROR; Dimer formation ###" + "\n")
logfile.write('\n')
outfile.write("# molecule: %s , chain: %s, residue: %s %s, pH: %s " % (molecule, chain, residueName, residue, pH) + "\n")
outfile.write("# BoltzSumNi: BoltzPartition: BoltzMCSC" + "\n")
outfile.write(("# %.4f %.4f %.4f" + '\n') % (BoltzSumNi, BoltzPartition, BoltzMCSC))
outfile.write("# Res NC States pKmcsc pK1 pKB pK2 pKm1 pKm2 f(C-)m1 f(C-)m2" + "\n")
outfile.write(("; %s %s %s %s %.4f %s %.4f %s %.4f %.4f %.6f %.6f" + '\n') % (residueName, residue, NeighbourCount, AvailRotStates, DeltapKMCSC, pK1, DeltapKB, pK2, pKm1, pKm2, FracCysm1, FracCysm2))
if nostates == "yes":
outfile.write("##### ERROR; No states available ###" + "\n")
if breakDimer == "yes":
outfile.write("##### ERROR; Dimer formation ###" + "\n")
outfile.write('\n')
outfile.write("#Ang SumMCSC NC rNC MCSC_Weight SG[X,Y,Z]" + "\n")
for i in range(len(ListofEnergies)):
outfile.write("%4.1d %10.3f %2.1d %1.1d %10.3f [%8.3f, %8.3f, %8.3f]" % (ListofEnergies[i][0], ListofEnergies[i][1], ListofEnergies[i][2], ListofEnergies[i][3], ListofEnergies[i][4], ListofEnergies[i][5][0], ListofEnergies[i][5][1], ListofEnergies[i][5][2]) + '\n')
for i in range(len(ListofRotamerDiscarded)):
outfile.write("%4.1d %10.3f %2.1d %1.1d %10.3f [%8.3f, %8.3f, %8.3f]" % (ListofRotamerDiscarded[i][0], ListofRotamerDiscarded[i][1], ListofRotamerDiscarded[i][2], ListofRotamerDiscarded[i][3], ListofRotamerDiscarded[i][4], ListofRotamerDiscarded[i][5][0], ListofRotamerDiscarded[i][5][1], ListofRotamerDiscarded[i][5][2]) + '\n')
outfile.close()
# Now, we are done. Just print out. The ; is for a grep command to select these lines in the output.
print("# residue: %s %s. Average NeighbourCount NC= %s " % (residueName, residue, NeighbourCount))
print("# From residue %s to residue %s" % (Minresidue, Maxresidue))
print("# BoltzSumNi: BoltzPartition: BoltzMCSC")
print("# %.4f %.4f %.4f" % (BoltzSumNi, BoltzPartition, BoltzMCSC))
print("# Result written in file: %s" % (filename))
print("# Res NC States pKmcsc pK1 pKB pK2 pKm1 pKm2 f(C-)m1 f(C-)m2")
print("; %s %s %s %s %.4f %s %.4f %s %.4f %.4f %.6f %.6f" % (residueName, residue, NeighbourCount, AvailRotStates, DeltapKMCSC, pK1, DeltapKB, pK2, pKm1, pKm2, FracCysm1, FracCysm2))
if nostates == "yes":
print("##### ERROR; No states available ###")
if breakDimer == "yes":
print("##### ERROR; Dimer formation ###")
def Btn_Save_Clefts(self):
if self.TempBindingSite.Count_Cleft() > 0:
DefaultPath = os.path.join(self.top.CleftProject_Dir,self.LastdefaultOption.upper())
if not os.path.isdir(DefaultPath):
os.makedirs(DefaultPath)
SaveFile = tkFileDialog.asksaveasfilename(initialdir=DefaultPath, title='Choose the Cleft base filename',
initialfile=self.LastdefaultOption)
if SaveFile:
SaveFile = os.path.normpath(SaveFile)
if DefaultPath not in SaveFile:
self.DisplayMessage(" ERROR: The file can only be saved at its default location", 2)
return
if glob(SaveFile + "_sph_*.nrgclf"):
message = "The Cleft base filename you selected is already taken. " + \
"Are you sure you want to overwrite the files?\n" + \
"This may result in unexpected errors as the files may be used in saved session."
answer = tkMessageBox.askquestion("Question",
message=message,
icon='warning')
if str(answer) == 'no':
self.top.DisplayMessage(" The saving of clefts was cancelled.", 2)
return
self.Update_TempBindingSite()
self.top.Manage.save_Temp()
for CleftName in self.TempBindingSite.Get_SortedCleftNames():
Cleft = self.TempBindingSite.Get_CleftName(CleftName)
#CleftPath = os.path.join(self.top.CleftProject_Dir,Cleft.UTarget)
m = re.match('(\S+)(_sph_(\d+)(_pt)?)', CleftName)
if m:
CleftNamePrefix = m.group(1)
CleftNameSuffix = m.group(2)
else:
continue
#if not os.path.isdir(CleftPath):
# os.makedirs(CleftPath)
NewCleftNamePrefix = os.path.split(SaveFile)[1]
CleftSaveFile = SaveFile + CleftNameSuffix + '.nrgclf'
# rename cleft objects in pymol also if renamed
if NewCleftNamePrefix != CleftNamePrefix:
try:
cmd.set_name(CleftName, NewCleftNamePrefix + CleftNameSuffix)
except:
self.top.DisplayMessage(" ERROR: Failed to rename cleft '" + Cleft.CleftName + "'", 2)
continue
Cleft.CleftName = NewCleftNamePrefix + CleftNameSuffix
try:
out = open(CleftSaveFile, 'wb')
pickle.dump(Cleft, out)
out.close()
#self.top.DisplayMessage(" Successfully saved '" + CleftSaveFile + "'", 0)
except:
self.top.DisplayMessage(" ERROR: Could not save binding-site '" + CleftSaveFile + "'", 1)
continue
else:
self.top.DisplayMessage(" No clefts to save.", 2)
import pymol
from pymol import cmd
# Input variables
structure = '5VN3'
# Clear pymol, get structure, and remove non-Env chains
# gp41 = chain A, B, D
# gp120 = chain G, I, J
# CD4 = chains C, E, F
# 17b = chains H, K, M and L, N, O
cmd.delete('all')
cmd.fetch(structure) #, type='pdb1')
cmd.remove('c;C,E,F,H,K,M,L,N,O')
cmd.set_name(structure, '5VN3_trimer')
cmd.select('gp160', 'c;A,G')
cmd.create(structure, 'gp160')
# Read in RSA values from file
d = {}
with open('5VN3_RSA_and_SS.txt') as f:
for (i, line) in enumerate(f):
line = line.strip().split(',')
site = line[0]
RSA = line[3]
if i == 0:
assert site == 'site'
assert RSA == 'RSA'
else:
site = int(site)
def test_set_name(self):
cmd.pseudoatom('m1')
cmd.set_name('m1', 'm2')
self.assertEqual(['m2'], cmd.get_names())
def ce_align(self,
elements_to_align,
output_file_name=None,
use_seq_info=False):
"""
Actually performs the structural alignment.
"""
#----------------------------------------------------
# Run CE-alignment using the PyMOL built-in module. -
#----------------------------------------------------
retain_order = True
if retain_order:
cmd.set("retain_order", 1)
sel1 = elements_to_align[0].get_pymol_selector()
sel2 = elements_to_align[1].get_pymol_selector()
# Sets temporary names.
tsel1 = "t" + elements_to_align[0].get_unique_index_header()
tsel2 = "t" + elements_to_align[1].get_unique_index_header()
cmd.set_name(sel1, tsel1)
cmd.set_name(sel2, tsel2)
# Actually performs the alignment.
a = cmd.cealign(target=tsel1,
mobile=tsel2,
object="pymod_temp_cealign")
# cmd.center('%s and %s' % (tsel1, tsel2))
# cmd.zoom('%s and %s' % (tsel1, tsel2))
# Updates the names of the chains PDB files and saves these new files.
saved_file1 = sel1 + "_aligned.pdb"
saved_file2 = sel2 + "_aligned.pdb"
# elements_to_align[0].structure.chain_pdb_file_name = saved_file1
# elements_to_align[1].structure.chain_pdb_file_name = saved_file2
cmd.save(os.path.join(self.pymod.structures_dirpath, saved_file1),
tsel1)
cmd.save(os.path.join(self.pymod.structures_dirpath, saved_file2),
tsel2)
# Finally saves the structural alignment between the sequences.
cmd.save(
os.path.join(self.pymod.alignments_dirpath,
output_file_name + ".aln"), "pymod_temp_cealign")
cmd.delete("pymod_temp_cealign")
# Converts it in .aln format.
recs = SeqIO.parse(
os.path.join(self.pymod.alignments_dirpath,
output_file_name + ".aln"), "clustal")
new_recs = []
for rec, pymod_element in zip(
recs, (elements_to_align[0], elements_to_align[1])):
new_rec_id = "_".join(rec.id[1:].split("_")[0:3])
new_rec_seq = str(rec.seq).replace(
"?", "X") # Replaces modified residues.
new_recs.append(SeqRecord(Seq(new_rec_seq), id=new_rec_id))
SeqIO.write(
new_recs,
os.path.join(self.pymod.alignments_dirpath,
output_file_name + ".aln"), "clustal")
# Sets the names of the objects back to original ones.
cmd.set_name(tsel1, sel1)
cmd.set_name(tsel2, sel2)
if retain_order:
cmd.set("retain_order", 0)
def Btn_Save_Clefts(self):
if self.TempBindingSite.Count_Cleft() > 0:
DefaultPath = os.path.join(self.top.CleftProject_Dir,
self.LastdefaultOption.upper())
if not os.path.isdir(DefaultPath):
os.makedirs(DefaultPath)
SaveFile = tkFileDialog.asksaveasfilename(
initialdir=DefaultPath,
title='Choose the Cleft base filename',
initialfile=self.LastdefaultOption)
if SaveFile:
SaveFile = os.path.normpath(SaveFile)
if DefaultPath not in SaveFile:
self.DisplayMessage(
" ERROR: The file can only be saved at its default location",
2)
return
if glob(SaveFile + "_sph_*.nrgclf"):
message = "The Cleft base filename you selected is already taken. " + \
"Are you sure you want to overwrite the files?\n" + \
"This may result in unexpected errors as the files may be used in saved session."
answer = tkMessageBox.askquestion("Question",
message=message,
icon='warning')
if str(answer) == 'no':
self.top.DisplayMessage(
" The saving of clefts was cancelled.", 2)
return
self.Update_TempBindingSite()
self.top.Manage.save_Temp()
for CleftName in self.TempBindingSite.Get_SortedCleftNames():
Cleft = self.TempBindingSite.Get_CleftName(CleftName)
#CleftPath = os.path.join(self.top.CleftProject_Dir,Cleft.UTarget)
m = re.match('(\S+)(_sph_(\d+)(_pt)?)', CleftName)
if m:
CleftNamePrefix = m.group(1)
CleftNameSuffix = m.group(2)
else:
continue
#if not os.path.isdir(CleftPath):
# os.makedirs(CleftPath)
NewCleftNamePrefix = os.path.split(SaveFile)[1]
CleftSaveFile = SaveFile + CleftNameSuffix + '.nrgclf'
# rename cleft objects in pymol also if renamed
if NewCleftNamePrefix != CleftNamePrefix:
try:
cmd.set_name(CleftName,
NewCleftNamePrefix + CleftNameSuffix)
except:
self.top.DisplayMessage(
" ERROR: Failed to rename cleft '" +
Cleft.CleftName + "'", 2)
continue
Cleft.CleftName = NewCleftNamePrefix + CleftNameSuffix
try:
out = open(CleftSaveFile, 'wb')
pickle.dump(Cleft, out)
out.close()
#self.top.DisplayMessage(" Successfully saved '" + CleftSaveFile + "'", 0)
except:
self.top.DisplayMessage(
" ERROR: Could not save binding-site '" +
CleftSaveFile + "'", 1)
continue
else:
self.top.DisplayMessage(" No clefts to save.", 2)
from pymol import cmd
pymol.finish_launching()
if len(sys.argv) != 6:
print("Usage: %s pdb-file align-sele save-sele align-atoms frame-pdb")
sys.exit(1)
struct_path = sys.argv[1]
struct_name = os.path.splitext(os.path.basename(struct_path))[0]
cmd.load(struct_path, struct_name)
cmd.split_states(struct_name, 1, 1, "temp")
cmd.delete(struct_name)
# cmd.save('%s_debug.pse' % struct_name)
cmd.set_name("temp0001", struct_name)
frame_bname = "frame"
sys
# frame_path = './aa_frames/ile_frame.pdb'
frame_path = sys.argv[5]
cmd.load(frame_path, frame_bname)
# target_sele = 'resn asp'
target_sele = sys.argv[2]
# dist = 6
# dist = sys.argv[3]
user_sele = sys.argv[3]
# 1) find residue number of all residues in the selection
# 2) align residue to the frame
