def show_rep(tag):
try:
sel = glb.SELE
if tag == 'Lines':
cmd.show('lines', sel)
elif tag == 'Sticks':
cmd.show('sticks', sel)
elif tag == 'Ribbons':
cmd.show('ribbon', sel)
elif tag == 'Cartoon':
cmd.show('cartoon', sel)
elif tag == 'Dots':
cmd.show('dots', sel)
elif tag == 'Spheres':
cmd.show('spheres', sel)
elif tag == 'Mesh':
cmd.show('mesh', sel)
elif tag == 'Surface':
cmd.show('surface', sel)
elif tag == 'Water':
cmd.show('spheres', '(resn HOH)')
elif tag == 'Ball and Stick':
preset.ball_and_stick(sel)
elif tag == 'Polar Contacts':
cmd.dist(sel + "_polar_conts",
sel,
sel,
quiet=1,
mode=2,
label=0,
reset=1)
cmd.enable(sel + "1CHO_polar_conts")
except:
showinfo('Error', 'Update Selection!')
def do_select(self, name): # map selects into picks
from .selecting import select_sspick
if self.name not in cmd.get_names('selections', enabled_only=1):
self.name = cmd.get_unused_name('ss')
select_sspick(name, self.name, self.selection_mode)
cmd.enable(self.name)
cmd.refresh_wizard()
def show_rep(tag):
try:
sel = glb.SELE
if tag == 'Lines':
cmd.show('lines', sel)
elif tag == 'Sticks':
cmd.show('sticks', sel)
elif tag == 'Ribbons':
cmd.show('ribbon', sel)
elif tag == 'Cartoon':
cmd.show('cartoon', sel)
elif tag == 'Dots':
cmd.show('dots', sel)
elif tag == 'Spheres':
cmd.show('spheres', sel)
elif tag == 'Mesh':
cmd.show('mesh', sel)
elif tag == 'Surface':
cmd.show('surface', sel)
elif tag == 'Water':
cmd.show('spheres', '(resn HOH)')
elif tag == 'Ball and Stick':
preset.ball_and_stick(sel)
elif tag == 'Polar Contacts':
cmd.dist(sel+"_polar_conts", sel, sel, quiet = 1, mode = 2, label = 0,
reset = 1)
cmd.enable(sel+"1CHO_polar_conts")
except:
showinfo('Error', 'Update Selection!')
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 testMeasureBetweenStates(self):
cmd.load(self.datafile('1v5a-3models.cif'), 'm1')
# distance
d = cmd.distance('d1', '24/CZ', 'same', state1=2, state2=3)
self.assertAlmostEqual(d, 3.0, delta=1e-1)
# angle
a = cmd.angle('a1',
'24/CZ',
'same',
'same',
state1=2,
state2=3,
state3=1)
self.assertAlmostEqual(a, 73.5, delta=1e-1)
# visual test
cmd.viewport(100, 100)
cmd.set('dash_radius', 1.0)
self.ambientOnly()
for name in ['d1', 'a1']:
cmd.disable('*')
cmd.enable(name)
cmd.zoom(name)
self.assertImageHasColor('yellow')
def save_surface(arg1):
cmd.disable()
cmd.enable(arg1)
cmd.hide("everything", arg1)
cmd.show("surface", arg1)
cmd.save("%s.obj" % arg1, arg1)
cmd.enable()
def export_objects_to_png():
objects = cmd.get_object_list('all')
cmd.disable('all')
for pobj in objects:
cmd.enable(pobj)
cmd.png('{}.png'.format(pobj), width=2340, height=1239, ray=1)
cmd.disable(pobj)
def do_select(self, name): # map selects into picks
from .selecting import select_sspick
if self.name not in cmd.get_names('selections', enabled_only=1):
self.name = cmd.get_unused_name('ss')
select_sspick(name, self.name, self.selection_mode)
cmd.enable(self.name)
cmd.refresh_wizard()
def select_in_pymol(self, structure_obj, name="sele", distinguish_chains=None):
"""Creates PyMOL selection related to self."""
if distinguish_chains is None:
distinguish_chains = self._distinguish_chains # pylint: disable=protected-access
get_pdb_ind = lambda id_: str(id_.ind) + str(id_.icode) if id_.icode is not None else str(id_.ind)
cmd.select(name, "%s and (%s)" % (Registry.get(structure_obj, 'name'), " + ".join(["(chain " + id_.chain + " and resi " + get_pdb_ind(id_) + ")" for id_ in self.specify(structure_obj, distinguish_chains).ids])))
cmd.enable(name)
Registry.add(self, name, structure_obj, selection_flag=True)
def do_select(self,name):
# handle mouse selection callback
if not sele_name in cmd.get_names('selections'):
cmd.select(sele_name,'none')
cmd.enable(sele_name)
cmd.refresh_wizard()
def do_select(self, name):
# handle mouse selection callback
if not sele_name in cmd.get_names('selections'):
cmd.select(sele_name, 'none')
cmd.enable(sele_name)
cmd.refresh_wizard()
def propka(molecule="NIL",chain="*",resi="0",resn="NIL",method="upload",logtime=time.strftime("%m%d",time.localtime()),server_wait=3.0,version="v3.1",verbose="no",showresult="no",pkafile="NIL",makebonds="yes"):
Script_Version="20110823"
### First we have to be sure, we give reasonable arguments
if pkafile!="NIL":
method='file'
assert method in ['upload', 'file'], "'method' has to be either: method=upload or method=file"
### If molecule="all", then try to get the last molecule
##assert molecule not in ['NIL'], "You always have to provide molecule name. Example: molecule=4ins"
if molecule=="NIL":
assert len(cmd.get_names())!=0, "Did you forget to load a molecule? There are no objects in pymol."
molecule=cmd.get_names()[-1]
### To print out to screen for selected residues. Can be separated with "." or make ranges with "-". Example: resi="4-8.10"
if resi != "0": resi_range = ResiRange(resi)
else: resi_range=[]
### Also works for residue names. They are all converted to bigger letters. Example: resn="cys.Tyr"
if resn != "NIL": resn_range = ResnRange(resn)
else: resn_range = resn
### Make chain range, and upper case.
chain = ChainRange(chain)
### Make result directory. We also the absolut path to the new directory.
Newdir = createdirs()
if method=="upload":
### We try to load mechanize. If this fail, one can always get the .pka file manual and the run: method=file
try: from modules import mechanize; importedmechanize='yes'
except ImportError: print("Import error. Is a module missing?"); print(sys.exc_info()); print("Look if missing module is in your python path\n%s")%sys.path;importedmechanize='no'; import modules.mechanize as mechanize
### The name for the new molecule
newmolecule = "%s%s"%(molecule,logtime)
### Create the new molecule from original loaded and for the specified chains. Save it, and disable the old molecule.
cmd.create("%s"%newmolecule, "%s and chain %s"%(molecule,chain))
cmd.save("%s%s.pdb"%(Newdir,newmolecule), "%s"%newmolecule)
cmd.disable("%s"%molecule)
if molecule=="all": cmd.enable("%s"%molecule); cmd.show("cartoon", "%s"%molecule)
### Let the new molecule be shown in cartoon.
cmd.hide("everything", "%s"%newmolecule)
cmd.show("cartoon", "%s"%newmolecule)
### Make the absolut path to the newly created .pdb file.
PDB="%s%s.pdb"%(Newdir,newmolecule);source="upload"; PDBID=""
### Request server, and get the absolut path to the result file.
pkafile = getpropka(PDB,chain,resi,resn,source,PDBID,logtime,server_wait,version,verbose,showresult)
### Open the result file and put in into a handy list.
list_results,ligands_results = importpropkaresult(pkafile)
if method=="file":
assert pkafile not in ['NIL'], "You have to provide path to file. Example: pkafile=./Results_propka/4ins_2011.pka"
assert ".pka" in pkafile, 'The propka result file should end with ".pka" \nExample: pkafile=./Results_propka/4ins_2011.pka \npkafile=%s'%(pkafile)
### The name for the molecule we pass to the writing script of pymol commands
newmolecule = "%s"%molecule
cmd.hide("everything", "%s"%newmolecule)
cmd.show("cartoon", "%s"%newmolecule)
### We open the result file we have got in the manual way and put in into a handy list.
list_results,ligands_results = importpropkaresult(pkafile)
### Then we print the interesting residues to the screen.
printpropkaresult(list_results, resi, resi_range, resn, resn_range, showresult, ligands_results)
### Now create the pymol command file. This should label the protein. We get back the absolut path to the file, so we can execute it.
result_pka_pymol_name = writepymolcmd(newmolecule,pkafile,verbose,makebonds)
### Now run our command file. But only if we are running pymol.
if runningpymol=='yes': cmd.do("run %s"%result_pka_pymol_name)
##if runningpymol=='yes': cmd.do("@%s"%result_pka_pymol_name)
return(list_results)
def toggle_subgroup(subgroup, enable):
SEL = {
'1->2': 'mp_*.1to2.*',
'2->1': 'mp_*.2to1.*',
}
if enable:
cmd.enable(SEL[subgroup])
else:
cmd.disable(SEL[subgroup])
def _test_recall(self):
cmd.scene('s1', 'recall')
cmd.ray(1, 1) # force scene update
self.assertEqual(['m3'], cmd.get_object_list('(visible)'))
self.assertEqual(['m3'], cmd.get_object_list('(enabled)'))
cmd.enable('g1')
cmd.ray(1, 1) # force scene update
self.assertEqual(['m1', 'm3'], cmd.get_object_list('(visible)'))
self.assertEqual(['m1', 'm3'], cmd.get_object_list('(enabled)'))
def testEnable(self):
cmd.create('m1', 'none')
cmd.create('m2', 'none')
cmd.disable()
self.assertEqual(cmd.get_names('public_objects', 1), [])
cmd.enable('m1')
self.assertEqual(cmd.get_names('public_objects', 1), ['m1'])
cmd.enable()
self.assertEqual(cmd.get_names('public_objects', 1), ['m1', 'm2'])
def _test_recall(self):
cmd.scene('s1', 'recall')
cmd.ray(1, 1) # force scene update
self.assertEqual(['m3'], cmd.get_object_list('(visible)'))
self.assertEqual(['m3'], cmd.get_object_list('(enabled)'))
cmd.enable('g1')
cmd.ray(1, 1) # force scene update
self.assertEqual(['m1', 'm3'], cmd.get_object_list('(visible)'))
self.assertEqual(['m1', 'm3'], cmd.get_object_list('(enabled)'))
def toggle_subgroup(subgroup, enable):
SEL = {
'1->2': 'mp_*.1to2.*',
'2->1': 'mp_*.2to1.*',
}
if enable:
cmd.enable(SEL[subgroup])
else:
cmd.disable(SEL[subgroup])
def testEnable(self):
cmd.create('m1', 'none')
cmd.create('m2', 'none')
cmd.disable()
self.assertEqual(cmd.get_names('public_objects', 1), [])
cmd.enable('m1')
self.assertEqual(cmd.get_names('public_objects', 1), ['m1'])
cmd.enable()
self.assertEqual(cmd.get_names('public_objects', 1), ['m1', 'm2'])
def do_pick(self, bondFlag):
global dist_count
if bondFlag:
self.error = "Error: please select an atom, not a bond."
print(self.error)
else:
if self.mode == 'pairs':
if self.status == 0:
name = sele_prefix
cmd.select(name, "(pk1)")
self.status = 1
self.error = None
elif self.status == 1:
if ((self.object_mode == 'append') or (not dist_count)):
dist_count = dist_count + 1
else:
cmd.delete(dist_prefix + "%2d" % dist_count)
name = dist_prefix + "%02d" % dist_count
cmd.dist(name, sele_prefix, "(pk1)")
cmd.delete(sele_prefix)
cmd.unpick()
cmd.enable(name)
self.status = 0
elif self.mode in ['neigh', 'polar', 'heavy']:
if ((self.object_mode == 'append') or (not dist_count)):
dist_count = dist_count + 1
else:
cmd.delete(dist_prefix + "%2d" % dist_count)
name = dist_prefix + "%02d" % dist_count
cnt = 0
if self.mode == 'neigh':
cnt = cmd.select(
sele_prefix,
"(v. and (pk1 a; %f) and (not (nbr. pk1)) and (not (nbr. (nbr. pk1))) and (not (nbr. (nbr. (nbr. pk1)))))"
% self.__class__.cutoff)
elif self.mode == 'polar':
cnt = cmd.select(
sele_prefix,
"(v. and (pk1 a; %f) and (e. n,o) and (not (nbr. pk1)) and (not (nbr. (nbr. pk1))) and (not (nbr. (nbr. (nbr. pk1)))))"
% self.__class__.cutoff)
elif self.mode == 'heavy':
cnt = cmd.select(
sele_prefix,
"(v. and (pk1 a; %f) and (not h.) and (not (nbr. pk1)) and (not (nbr. (nbr. pk1))) and (not (nbr. (nbr. (nbr. pk1)))))"
% self.__class__.cutoff)
cmd.delete(name)
if cnt:
cmd.dist(name, "(pk1)", sele_prefix)
else:
print(" Wizard: No neighbors found.")
cmd.delete(sele_prefix)
cmd.unpick()
cmd.enable(name)
cmd.refresh_wizard()
def enable_kin(self, kin):
'''Enable an MPObject kinemage.
PARAMETERS
kin (str) The kinemage to be enabled. Possible values are
'flipkinNQ', 'flipkinH', or 'probe'.
'''
kin_group = self.get_kin_cgo_group(kin)
cmd.enable(kin_group)
def enable_pdb(self, pdb):
'''Enable an MPObject structure object.
PARAMETERS
pdb (str) The structure to be enabled. Possible values are
'reduce', 'flipkinNQ', 'flipkinH', 'userflips', or 'probe'.
'''
pdb_obj = self.pdb[pdb]
cmd.enable(pdb_obj)
def display_selected():
"""Display entries corresponding to selected rows"""
#TODO: multiple selection
selected_row = widget.tableDocked.selectedItems()
if selected_row:
row_n = selected_row[0].row()
object = widget.tableDocked.item(row_n, 1).text()
state = widget.tableDocked.item(row_n, 2).text()
cmd.set('state', state)
cmd.disable(" ".join(docked.objects))
cmd.enable(object)
def enable_pdb(self, pdb):
'''Enable an MPObject structure object.
PARAMETERS
pdb (str) The structure to be enabled. Possible values are
'reduce', 'flipkinNQ', 'flipkinH', 'userflips', or 'probe'.
'''
pdb_obj = self.pdb[pdb]
cmd.enable(pdb_obj)
def enable_kin(self, kin):
'''Enable an MPObject kinemage.
PARAMETERS
kin (str) The kinemage to be enabled. Possible values are
'flipkinNQ', 'flipkinH', or 'probe'.
'''
kin_group = self.get_kin_cgo_group(kin)
cmd.enable(kin_group)
def run(self):
print("FlexAID parsing thread has begun.")
# Set the auto_zoom to off
cmd.set("auto_zoom", 0)
cmd.delete("TOP_*__")
cmd.delete("RESULT_*")
cmd.refresh()
cmd.frame(1)
self.queue.put(lambda: self.top.InitStatus())
self.queue.put(lambda: self.top.progressBarHandler(0, self.NbTotalGen))
# send ready to simulate signal
print(' Signal sent to start simulation')
self.FlexAID.ParseState = 0
print(' Waiting for FlexAID to start')
# wait for FlexAID to start, to crash or to finish (if simulation is very short and quickly done)
while self.FlexAID.SimulateState < 0:
time.sleep(self.top.INTERVAL)
print(' Parsing the logfile of FlexAID')
while self.FlexAID.Run is not None: # and self.FlexAID.Run.poll() is None:
time.sleep(self.top.INTERVAL)
if self.ParseLines():
break
if not self.FlexAID.ParseState > 0:
self.ParseLines()
# Put back the auto_zoom to on
cmd.set("auto_zoom", self.auto_zoom)
# error in simulation or parsing?
if self.FlexAID.SimulateState > 0 or self.FlexAID.ParseState > 0:
self.queue.put(lambda: self.top.ErrorStatus(self.ErrorMsg))
else:
self.queue.put(lambda: self.top.SuccessStatus())
if self.top.Results:
cmd.enable("RESULT_*")
cmd.refresh()
cmd.disable("TOP_*__")
cmd.refresh()
cmd.frame(1)
self.FlexAID.ParseState = 10
print("FlexAID parsing thread has ended.")
def enable_selected():
selected = list(set([int(x.resi) for x in cmd.get_model("sele").atom]))
for name in cmd.get_names("objects"):
if (name.startswith("esto_res")):
cmd.disable(name)
for seqpos in selected:
name = "esto_res%i"%seqpos
cmd.enable(name)
cmd.delete("sele")
def run(self):
print("FlexAID parsing thread has begun.")
# Set the auto_zoom to off
cmd.set("auto_zoom", 0)
cmd.delete("TOP_*__")
cmd.delete("RESULT_*")
cmd.refresh()
cmd.frame(1)
self.queue.put(lambda: self.top.InitStatus())
self.queue.put(lambda: self.top.progressBarHandler(0, self.NbTotalGen))
# send ready to simulate signal
print(' Signal sent to start simulation')
self.FlexAID.ParseState = 0
print(' Waiting for FlexAID to start')
# wait for FlexAID to start, to crash or to finish (if simulation is very short and quickly done)
while self.FlexAID.SimulateState < 0:
time.sleep(self.top.INTERVAL)
print(' Parsing the logfile of FlexAID')
while self.FlexAID.Run is not None: # and self.FlexAID.Run.poll() is None:
time.sleep(self.top.INTERVAL)
if self.ParseLines():
break
if not self.FlexAID.ParseState > 0:
self.ParseLines()
# Put back the auto_zoom to on
cmd.set("auto_zoom", self.auto_zoom)
# error in simulation or parsing?
if self.FlexAID.SimulateState > 0 or self.FlexAID.ParseState > 0:
self.queue.put(lambda: self.top.ErrorStatus(self.ErrorMsg))
else:
self.queue.put(lambda: self.top.SuccessStatus())
if self.top.Results:
cmd.enable("RESULT_*")
cmd.refresh()
cmd.disable("TOP_*__")
cmd.refresh()
cmd.frame(1)
self.FlexAID.ParseState = 10
print("FlexAID parsing thread has ended.")
def move_up():
enabled_objs = cmd.get_names("objects", enabled_only=1)
all_objs = cmd.get_names("objects", enabled_only=0)
for obj in enabled_objs:
cmd.disable(obj)
last_obj = obj
for i in range(0, len(all_objs)):
if all_objs[i] == obj:
if i - 1 < 0:
cmd.enable(all_objs[-1])
else:
cmd.enable(all_objs[i - 1])
def batch_convert_modules(src_dir=None, dst_dir=None, ext='obj'):
"""Batch convert Elfin protein module PDBs.
Args:
- src_dir - input PDB directory (one that contains sub_dirs like singles,
doubles, hubs)
- dst_dir - output PDB directory
- ext - file extension supported by PyMol
"""
if src_dir is None or dst_dir is None:
print(batch_convert.__doc__)
else:
# Clear workspace
cmd.reinitialize()
sub_dirs = ['singles', 'doubles',
'hubs'] # don't think we need cappings
for sd in sub_dirs:
make_dir(dst_dir + '/' + sd)
files = [
f for flist in [
glob.glob(src_dir + '/{}/*.pdb'.format(sd))
for sd in sub_dirs
] for f in flist
]
cmd.set('auto_show_nonbonded', 'off')
cmd.set('auto_show_selections', 'off')
cmd.set('auto_show_spheres', 'off')
cmd.set('auto_show_classified', 'off')
cmd.set('auto_show_lines', 'off')
fn_info = []
for f in files:
cmd.load(f)
name = '.'.join((re.split(r'/|\\', f)[-1]).split('.')[:-1])
fn_info.append((f, name))
cmd.disable('all')
cmd.show('cartoon')
for (file_path, module_name) in fn_info:
cmd.enable(module_name)
cmd.save(
file_path.replace(src_dir,
dst_dir).replace('.pdb', '.' + ext))
cmd.disable(module_name)
# Clear workspace
cmd.delete('all')
def trans():
cmd.disable("all")
objs=[x for x in cmd.get_names("objects") if x.find("start")==0]
trans=float(1)/len(objs)
t=0
for x in objs:
t+=trans
cmd.enable(x)
print x,t
cmd.set("cartoon_transparency",t)
cmd.set("stick_transparency",t)
cmd.png("%s.png" %x,ray=1)
cmd.disable(x)
def interface_analyse_multi(dist=10):
cmd.disable('all')
all_objects = cmd.get_object_list()
for obj in all_objects:
print 'analysing', obj
interface_analyser(obj, dist, animate=False)
cmd.disable(obj)
cmd.disable(obj + '_h.bonds')
cmd.do('order *, yes')
cmd.zoom(all_objects[0], animate=-1)
cmd.orient(all_objects[0], animate=-1)
cmd.enable(all_objects[0])
cmd.enable(all_objects[0] + '_h.bonds')
def move_down():
enabled_objs = cmd.get_names("objects",enabled_only=1)
all_objs = cmd.get_names("objects",enabled_only=0)
for obj in enabled_objs:
cmd.disable(obj)
last_obj=obj
for i in range(0,len(all_objs)):
if all_objs[i] == obj:
if i+1 >= len(all_objs):
cmd.enable( all_objs[0] )
else:
cmd.enable( all_objs[i+1] )
cmd.orient
def move_up():
enabled_objs = cmd.get_names("object",enabled_only=1)
all_objs = cmd.get_names("object",enabled_only=0)
for obj in enabled_objs:
cmd.disable(obj)
last_obj=obj
for i in range(0,len(all_objs)):
if all_objs[i] == obj:
if i-1 < 0:
cmd.enable( all_objs[-1] )
else:
cmd.enable( all_objs[i-1] )
cmd.orient
def move_down():
enabled_objs = cmd.get_names("objects", enabled_only=1)
all_objs = cmd.get_names("objects", enabled_only=0)
for obj in enabled_objs:
cmd.disable(obj)
last_obj = obj
for i in range(0, len(all_objs)):
if all_objs[i] == obj:
if i + 1 >= len(all_objs):
cmd.enable(all_objs[0])
else:
cmd.enable(all_objs[i + 1])
cmd.orient
def interface_analyser(name, dist_cuoff=10, animate=True):
'''
DESCRIPTION
displays the chains in different colors, showas cavity surfaces, and h.bonds with an interface cutoff
of 10 (default)
'''
# cmd.hide("lines")
cmd.select("interface", "none")
alphabet = list(('abcdefghijklmnopqrstuvwxyz').upper())
for letter in alphabet:
chainname = "chain" + letter
cmd.select(
chainname,
"%s and chain %s and not hetatm and not symbol w" % (name, letter))
if cmd.count_atoms("chain%s" % (letter)) > 0:
interfacename = "interface" + letter
cmd.select(
"not_this_chain",
"%s and not hetatm and not symbol w and not %s" %
(name, chainname))
cmd.select(
interfacename,
"%s and byres %s and (not_this_chain around %s)" %
(name, chainname, str(dist_cuoff)))
cmd.select("interface", "interface or %s" % (interfacename))
cmd.delete("not_this_chain")
cmd.delete("interface" + letter)
cmd.delete("chain%s" % (letter))
else:
cmd.delete(chainname)
cmd.hide("lines", name)
cmd.show("lines", "interface")
cmd.show("cartoon")
cmd.dist(
"%s_h.bonds" % name,
"interface",
"interface",
quiet=1,
mode=2,
label=0,
reset=1,
)
cmd.enable("%s_h.bonds" % name)
cmd.show("surface", "all")
cmd.set('surface_cavity_mode', 1)
util.color_chains("(all and elem c)", _self=cmd)
if animate:
cmd.zoom("interface", animate=-1)
cmd.orient("interface", animate=-1)
cmd.delete("interface")
cmd.remove("(all) and hydro")
def save_sele_as_ligExp(selection='sele'):
([minX, minY, minZ], [maxX, maxY, maxZ]) = cmd.get_extent(selection)
pdb_base = cmd.get_object_list(selection)[0]
cmd.disable('*')
cmd.enable('pdb_base', 1)
replace_list = ['_aligned_rm_ion', '_aligned', '_rm', '_ion', '_preped']
pdb_base_short = pdb_base
for rep in replace_list:
pdb_base_short = pdb_base_short.replace(rep, '')
cmd.save('ligExp_' + pdb_base_short + ".sdf", 'sele', -1, 'sdf')
cmd.delete('sele')
#cmd.disable(pdb_base)
cmd.delete(pdb_base)
return
def rpcShow(objs):
""" shows (enables) an object (or objects)"""
if type(objs) not in (types.ListType, types.TupleType):
objs = (objs, )
for objName in objs:
try:
cmd.enable(objName)
except Exception:
res = 0
break
else:
res = 1
return res
def rpcShow(objs):
""" shows (enables) an object (or objects)"""
if type(objs) not in (types.ListType, types.TupleType):
objs = (objs, )
for objName in objs:
try:
cmd.enable(objName)
except:
res = 0
break
else:
res = 1
return res
def interface_analyser_with_surface(name='all',
chain_sur='A',
dist_cutoff=10,
animate=True):
cmd.select("interface", "none")
alphabet = list(('abcdefghijklmnopqrstuvwxyz').upper())
for letter in alphabet:
chainname = "chain" + letter
cmd.select(
chainname,
"%s and chain %s and not hetatm and not symbol w" % (name, letter))
if cmd.count_atoms("chain%s" % (letter)) > 0:
interfacename = "interface" + letter
cmd.select(
"not_this_chain",
"%s and not hetatm and not symbol w and not %s" %
(name, chainname))
cmd.select(
interfacename,
"%s and byres %s and (not_this_chain around %s)" %
(name, chainname, str(dist_cutoff)))
cmd.select("interface", "interface or %s" % (interfacename))
cmd.delete("not_this_chain")
cmd.delete("interface" + letter)
cmd.delete("chain%s" % (letter))
else:
cmd.delete(chainname)
cmd.hide("lines", name)
cmd.show("lines", "interface")
cmd.show("cartoon")
cmd.dist(
"%s_h.bonds" % name,
"interface",
"interface",
quiet=1,
mode=2,
label=0,
reset=1,
)
cmd.enable("%s_h.bonds" % name)
cmd.create("chain%s" % chain_sur,
name + " and chain %s" % chain_sur,
zoom=0)
cmd.show("surface", "chain%s" % chain_sur)
util.color_chains("(all and elem c)", _self=cmd)
if animate:
cmd.zoom("interface", animate=-1)
cmd.orient("interface", animate=-1)
cmd.delete("interface")
cmd.remove("(all) and hydro")
def update_dashes(self):
cmd.delete(dist_prefix + "*")
lst = self.get_sele_list()
c = 0
while 1:
if not len(lst): break
a = lst.pop()
if not len(lst): break
b = lst.pop()
name = dist_prefix + str(c)
cmd.dist(name, a, b, width=7, length=0.05, gap=0.05)
cmd.hide('label', name)
cmd.enable(name)
c = c + 1
def update_dashes(self):
cmd.delete(dist_prefix+"*")
lst = self.get_sele_list()
c = 0
while 1:
if not len(lst): break
a = lst.pop()
if not len(lst): break
b = lst.pop()
name = dist_prefix+str(c)
cmd.dist(name,a,b,width=7,length=0.05,gap=0.05)
cmd.hide('label',name)
cmd.enable(name)
c = c + 1
def series_resfile(color="orange"):
# Main PDB File Name
object = cmd.get_names()[0]
counter = 0
# Read Rosetta Resfile
for fname in glob.glob('*.resfile'):
counter += 1
if counter == 1:
fname_rem = fname
cmd.copy(fname, object)
for line in open(fname):
# Split Resfile Line by Tab
data = line.split('\t')
# Only Consider Lines that Start with Residue Numbers
if data[0].isdigit():
# Get Revalent Data
pos = data[0]
chain = data[1]
mut = data[3]
# Generate Mutation Label
label = mut
label_list = list(label)
label_list.insert(1, "%s" % (pos))
label = ''.join(label_list)
# PyMOL Color and Label
cmd.color(color,
"resi %s and chain %s and %s" % (pos, chain, fname))
cmd.label(
"resi %s and chain %s and name ca and %s" %
(pos, chain, fname), "\'%s\'" % (label))
# Output Comments to the Console
elif line[:1] == "#":
# Remove newline feeds
line.rstrip("\n")
print "\n%s" % (line)
cmd.disable('all')
cmd.enable(fname_rem)
cmd.orient
cmd.set_key('pgup', move_up)
cmd.set_key('pgdn', move_down)
def test(self):
cmd.pseudoatom('m1')
cmd.pseudoatom('m2')
cmd.pseudoatom('m3')
cmd.group('g1', 'm1')
cmd.disable('g1')
cmd.disable('m2')
cmd.ray(1, 1) # force scene update
cmd.scene('s1', 'store')
self._test_recall()
cmd.disable('*')
self._test_recall()
cmd.enable('*')
self._test_recall()
def test(self):
cmd.pseudoatom('m1')
cmd.pseudoatom('m2')
cmd.pseudoatom('m3')
cmd.group('g1', 'm1')
cmd.disable('g1')
cmd.disable('m2')
cmd.ray(1, 1) # force scene update
cmd.scene('s1', 'store')
self._test_recall()
cmd.disable('*')
self._test_recall()
cmd.enable('*')
self._test_recall()
def do_pick(self,bondFlag):
print("Picked!")
cmd=self.cmd
if bondFlag:
self.error = "Error: please select an atom, not a bond."
print(self.error)
else:
if self.status!=0:
cmd.delete(obj_name)
cmd.select(src_sele,"(byres pk1)")
cmd.unpick()
cmd.enable(src_sele)
self.status = 1
self.error = None
self.do_library()
cmd.refresh_wizard()
def do_pick(self,bondFlag):
print("Picked!")
cmd=self.cmd
if bondFlag:
self.error = "Error: please select an atom, not a bond."
print(self.error)
else:
if self.status!=0:
cmd.delete(obj_name)
cmd.select(src_sele,"(byres pk1)")
cmd.unpick()
cmd.enable(src_sele)
self.status = 1
self.error = None
self.do_library()
cmd.refresh_wizard()
def zn_interface():
cmd.show( 'cartoon' )
cmd.hide( 'lines', 'elem H' )
util.cbc("elem C")
cmd.show( 'sticks', 'resn znx')
cmd.set('cartoon_transparency','0.5')
cmd.hide( 'sticks', 'elem H' )
loaded_objs = cmd.get_names('objects')
print loaded_objs
for obj in loaded_objs :
cmd.dist( '"'+obj+'_polar_conts"','"'+obj+'"','"'+obj+'"',quiet=1,mode=2,label=0,reset=1)
cmd.enable("'"+obj+'_polar_conts"')
def save_images(title=1): cmd.set( 'ray_opaque_background', 0 ) for x in cmd.get_names( 'all' ): rg = rgyrate( x , 1 ) cmd.disable( 'all' ) cmd.enable( x ) cmd.zoom( x, buffer=0.0, state=0, complete=1 ) if title: cmd.set( 'label_size', 25 ) #cmd.set( 'label_position', (0,-25,0) ) cmd.set( 'label_position', (0,(-10-rg),0) ) cmd.pseudoatom( 'pa', label=x ) cmd.zoom( 'visible', buffer=5, state=0, complete=1 ) cmd.png( x+'.png', dpi=300, ray=1 ) cmd.delete( 'pa' )
def _check_optimzer_results_pairwise_5(self, exit_test_mode=False):
'''Creates groups for all pairs which are connected. And show them all in grid mode
:warning: only designed for pairwise restraints
'''
self.check_results_mode = 5
# 1) Check which molecule pairs have connections
pair_exists = {}
for i_m1 in range(len(self.pymol_molecule_objects)):
for i_m2 in range(len(self.pymol_molecule_objects)):
pair_exists.update({str(i_m1 + 1) + str(i_m2 + 1): False})
for r in self.logic_handler.selected_restraints:
pair_exists.update({str(r.atoms[0].resi) + str(r.atoms[1].resi): True})
mol_pairs = [(str(i_m1 + 1), str(i_m2 + 1)) for i_m1 in range(len(self.pymol_molecule_objects) - 1) for i_m2 in
range(i_m1, len(self.pymol_molecule_objects)) if
pair_exists[str(i_m1 + 1) + str(i_m2 + 1)] or pair_exists[str(i_m2 + 1) + str(i_m1 + 1)]]
print(mol_pairs, mv=1)
cmd.disable('all')
for p in mol_pairs:
m1, m2 = p[0], p[1]
m1_name = m1 + '-' + m2 + 'mol_' + m1
m2_name = m1 + '-' + m2 + 'mol_' + m2
cmd.copy(m1 + '-' + m2 + 'mol_' + m1, 'mol_' + m1)
cmd.copy(m1 + '-' + m2 + 'mol_' + m2, 'mol_' + m2)
group_expression = m1_name + ' ' + m2_name
cmd.group('pair_' + m1 + '_' + m2, group_expression)
cmd.enable(group_expression)
cmd.set('grid_mode', 1)
cmd.reset()
if (exit_test_mode):
self.check_results_mode = 0
for p in mol_pairs:
m1_name = m1 + '-' + m2 + 'mol_' + m1
m2_name = m1 + '-' + m2 + 'mol_' + m2
group_expression = m1_name + ' ' + m2_name
cmd.delete(m1_name)
cmd.delete(m2_name)
cmd.ungroup('group_expression')
cmd.set('grid_mode', 0)
cmd.enable('all')
def pickNextAtom(self, atom_name):
# transfer the click selection to a named selection
cmd.select(atom_name, "(pk1)")
# delete the click selection
cmd.unpick()
# using the magic of indicate, highlight stuff
indicate_selection = "_indicate" + self.object_prefix
cmd.select(indicate_selection, atom_name)
cmd.enable(indicate_selection)
self.pick_count += 1
self.error = None
# necessary to force update of the prompt
cmd.refresh_wizard()
def do_pick(self,bondFlag):
global dist_count
if bondFlag:
self.error = "Error: please select an atom, not a bond."
print self.error
else:
if self.mode == 'pairs':
if self.status==0:
name = sele_prefix
cmd.select(name,"(pk1)")
self.status = 1
self.error = None
elif self.status==1:
if ((self.object_mode=='append') or (not dist_count)):
dist_count = dist_count + 1
else:
cmd.delete(dist_prefix+"%2d"%dist_count)
name = dist_prefix + "%02d"%dist_count
cmd.dist(name,sele_prefix,"(pk1)")
cmd.delete(sele_prefix)
cmd.unpick()
cmd.enable(name)
self.status = 0
elif self.mode in ['neigh','polar','heavy']:
if ((self.object_mode=='append') or (not dist_count)):
dist_count = dist_count + 1
else:
cmd.delete(dist_prefix+"%2d"%dist_count)
name = dist_prefix + "%02d"%dist_count
cnt = 0
if self.mode == 'neigh':
cnt = cmd.select(sele_prefix,"(v. and (pk1 a; %f) and (not (nbr. pk1)) and (not (nbr. (nbr. pk1))) and (not (nbr. (nbr. (nbr. pk1)))))"%self.__class__.cutoff)
elif self.mode == 'polar':
cnt = cmd.select(sele_prefix,"(v. and (pk1 a; %f) and (e. n,o) and (not (nbr. pk1)) and (not (nbr. (nbr. pk1))) and (not (nbr. (nbr. (nbr. pk1)))))"%self.__class__.cutoff)
elif self.mode == 'heavy':
cnt = cmd.select(sele_prefix,"(v. and (pk1 a; %f) and (not h.) and (not (nbr. pk1)) and (not (nbr. (nbr. pk1))) and (not (nbr. (nbr. (nbr. pk1)))))"%self.__class__.cutoff)
cmd.delete(name)
if cnt:
cmd.dist(name,"(pk1)",sele_prefix)
else:
print " Wizard: No neighbors found."
cmd.delete(sele_prefix)
cmd.unpick()
cmd.enable(name)
cmd.refresh_wizard()
def esurf(*args):
delcrea()
try:
cmd.isosurface('map1','map', contour1.get())
except:
try:
cmd.set("suspend_updates",1,quiet=1)
cmd.remove("hydro")
cmd.enable('all')
cmd.map_new('map',"gaussian","0.75", 'all')
cmd.isosurface("map1", "map", 9999.0, 'all')
cmd.set("suspend_updates",0,quiet=1)
cmd.refresh()
cmd.isosurface('map1','map', contour1.get())
except:
showinfo("Error", 'No PDB is present')
interior.mainloop()
def enable_flipkin_group(self, group='reduce'):
'''Enable a flipkin kinemage group.
PARAMETERS
group (str) The group to be enabled. Possible values are
'reduce', 'flipNQ', 'flipH', or 'both'. (Default: both)
'''
if group in ['reduce', 'flipNQ', 'flipH']:
sel = '{}.*.{}'.format(self.mp_group, group)
else:
msg = 'not a typical flipkin group name: {}'.format(group)
logger.warning(msg)
sel = '{}.*.{}*'.format(self.mp_group, group)
logger.debug('enabling "{}"'.format(sel))
cmd.enable(sel)
def esurf1(event):
delcrea()
try:
cmd.isosurface('map1','map', contour1.get(), 'sele')
except:
try:
cmd.set("suspend_updates",1,quiet=1)
cmd.remove("hydro")
cmd.enable('all')
cmd.map_new('map',"gaussian","0.75", 'all')
cmd.isosurface("map1", "map", 9999.0, 'all')
cmd.set("suspend_updates",0,quiet=1)
cmd.refresh()
cmd.isosurface('map1','map', contour1.get(), 'sele')
except:
cmd.orient('all')
showinfo("Error", 'No PDB is present\nOr there is no selection ('"sele"')')
interior.mainloop()
def do_select(self,selection):
print("Selected!")
cmd=self.cmd
if (obj_name in cmd.get_names()):
if cmd.count_atoms("(%s) and (%s)"%(obj_name,selection)):
cmd.deselect()
return 1
if self.status!=0:
cmd.delete(obj_name)
cmd.select(src_sele,selection)
cmd.unpick()
cmd.enable(src_sele)
self.status = 1
self.error = None
self.do_library()
cmd.delete(selection)
cmd.refresh_wizard()
cmd.deselect()
return 1
def roving_density(self,cleanup=0):
if not cleanup:
try:
cmd.load("$PYMOL_DATA/demo/il2.pdb")
cmd.set("suspend_updates",1,quiet=1)
cmd.remove("hydro")
cmd.disable()
cmd.enable("il2")
cmd.map_new("map","gaussian","0.75","il2")
cmd.feedback("disable","objectmesh","actions")
cmd.set("ribbon_color","purple","il2")
cmd.set("roving_detail",1)
cmd.set("roving_origin",1)
cmd.set("stick_radius",0.12,"il2")
cmd.set("roving_sticks",0)
cmd.set("roving_polar_contacts",0)
cmd.set("line_width","3")
cmd.set("roving_map1_name","map")
cmd.isomesh("rov_m1","map",9999.0,"il2")
cmd.color("density","rov_m1")
cmd.set_view ((\
0.132852688, -0.729740858, 0.670686543,\
-0.228543565, 0.635894477, 0.737154961,\
-0.964425683, -0.251212329, -0.082298420,\
0.000062190, 0.000183226, -58.861488342,\
13.349151611, -1.565427899, 22.383148193,\
55.259441376, 63.259449005, 0.000000000 ))
finally:
cmd.set("suspend_updates",0,quiet=1)
cmd.refresh()
else:
cmd.set("roving_detail",0)
cmd.set("roving_map1_name","")
cmd.set("roving_polar_contacts",7)
cmd.set("roving_sticks",6)
cmd.delete("il2")
cmd.delete("map")
cmd.set("line_width",1.5)
cmd.refresh()
cmd.set("roving_detail",0)
cmd.delete("rov_*")
cmd.sync()
def emesh1(event):
delcrea()
try:
cmd.isomesh('map1','map', contour1.get(), 'sele')
except:
try:
cmd.remove("hydro")
cmd.enable('all')
cmd.map_new('map',"gaussian","0.75", 'all')
cmd.isomesh('map1','map', contour1.get(), 'sele')
except:
cmd.orient('all')
showinfo("Error", 'No PDB is present\nOr there is no selection ('"sele"')')
interior.mainloop()
def save_image(spath, name_maxlength, prefix = ''):
fname = os.path.splitext(os.path.basename(spath))[0]
image_name = prefix + image_filename(fname, name_maxlength)
if exists(image_name):
print 'Skip: ' + fname
else:
print 'Process: ' + fname
cmd.load(spath, fname)
cmd.disable('all')
cmd.enable(fname)
cmd.color('green', fname)
cmd.h_add('(all)')
cmd.show('surface')
cmd.rotate([-1, 0.5, 0.5], 60)
cmd.zoom(fname, -7.0, 0, 1)
cmd.png(image_name)
time.sleep(3) # wtf?!
cmd.delete('all')
def iter(self,by=1):
#enabled = cmd.get_names('objects',enabled_only=1)[0]
choices = self.choices()
l = len(choices)
assert self.current_index < l
next_object = (self.current_index + by) % l
cmd.disable(objname(choices[self.current_index]))
self.current_index = next_object
cmd.enable(objname(choices[self.current_index]))
if self.auto_zoom:
cmd.zoom(objname(choices[self.current_index]))
if self.onload_command:
logging.debug("onload_command: %s", self.onload_command)
cmd.do(self.onload_command)
cmd.replace_wizard('message',choices[self.current_index])
def test_scenes(self):
self._load_example()
cmd.scene('s1', 'store')
cmd.enable('g1')
cmd.scene('s2', 'store')
cmd.mset('1x4')
cmd.mview('store', 1, scene='s2')
cmd.mview('store', 4, scene='s1')
with testing.mkdtemp() as tempdir:
# export
prefix = os.path.join(tempdir, 'frame')
cmd.mpng(prefix, width=100, height=100)
img = self.get_imagearray(prefix + '0002.png')
self.assertImageHasColor('red', img)
self.assertImageHasColor('blue', img)
img = self.get_imagearray(prefix + '0003.png')
self.assertImageHasNotColor('red', img)
self.assertImageHasColor('blue', img)
