def add_selected_positions(self, selection='sele'):
"""
Add any positions currently in the given selection to the list of
mutations to show (even if those positions are not in fact mutations).
"""
wt_obj = self.wildtype_obj
mut_obj = self.mutant_obj
if 'wt_env' in cmd.get_names('objects'):
wt_obj = '({}) or wt_env'.format(wt_obj)
if 'mut_env' in cmd.get_names('objects'):
mut_obj = '({}) or mut_env'.format(mut_obj)
wt_resis = get_residues('({}) and ({})'.format(selection, wt_obj))
mut_resis = get_residues('({}) and ({})'.format(selection, mut_obj))
for resi in wt_resis:
muti = self.aligned_resis[0].index(resi)
self.extra_positions.add(muti)
for resi in mut_resis:
muti = self.aligned_resis[1].index(resi)
self.extra_positions.add(muti)
self.update_mutation_list()
self.redraw()
def fisapt():
# Make it pretty
cmd.show("sticks", "all")
# Initialize pm molecule object
total_molecule = read_original_geometry()
allowed_classifications = ['A', 'B', 'C']
# Take in user border atoms
frag_names = cmd.get_names("all")[1:]
frags = {}
for name in frag_names:
classification = name.split('_')[-1].upper()
if classification not in allowed_classifications:
print("USAGE!")
sys.exit()
frags[name] = []
stored.list=[]
cmd.iterate("("+name+")","stored.list.append((name,rank))")
for atom in stored.list:
frags[name].append(atom[1])
# All C fragments are in "ISAPT_C"
if classification == 'C':
cmd.delete(name)
# Fill up with fragments and color the fragments
fragments = total_molecule.cut(frags)
# Should write input, fA, and fB outside of class, need info from above
total_molecule.write_input(fragments, fil_name = cmd.get_names("all")[0]+".in")
def drab(nlim=-2.0, plim=2.0):
#zero the indexes
#zero_residues("all", 1, 1)
#Read the values in
fileName = cmd.get_names()[0]
print fileName
fileName = fileName + ".dat"
cmd.alter("all", "b=0.0")
#file = open(fileName, 'r')
#table = [row.strip().split('\t') for row in file]
bVals = []
#print table
for line in file(fileName):
line = line.strip().split()
if (line[0][0] != "#"):
selection = "resi %s" % line[0]
#Normalize the values
bval = (float(line[1]) - nlim) / (plim - nlim)
#print bval
cmd.alter(selection, "b=%f" % bval)
print(selection, "b=%f" % bval)
bVals.append([selection, bval])
cmd.hide("all")
cmd.show("cartoon")
cmd.spectrum("b", "blue_white_red", "all", "0.0", "1.0", "1")
cmd.ramp_new("rawFac_ramp",
cmd.get_names()[0], [nlim, plim],
color="[blue, white, red ]")
cmd.recolor()
def load_alignment(filename, object1=None, object2=None, delimiter="_"):
"""DESCRIPTION
Structural comparison tools from the PDB website can save aligned
structures as a two-model structure. This function loads such a file and
splits the structures into two pymol objects for easy comparison.
USAGE
load_alignment filename[, object1, object2][, delimiter]
ARGUMENTS
filename Path to the PDB file
object1 What to name the first model from the file [optional]
object2 What to name the second model from the file [optional]
delimiter Delimiter which separates object1 and object2 in the filename.
See DETAILS. [default '_']
DETAILS
The input file must contain at least two states (MODEL lines in the PDB
file). Additional states are ignored.
If object1 and object2 are ommitted, the script will attempt to generate
them based on the filename. The extension is first removed from the
filename, then the name is split around the first instance of <delimiter>.
Thus, alignment files which follow the convention "object1_object2.pdb"
will be properly split without additional arguments.
EXAMPLES
# Results in objects '1AX8.A' and '3PIV.A'
load_alignment 1AX8.A_3PIV.A.pdb
# Results in objects 'query' and 'target'
load_alignment alignment.pdb, query, target
# Results in objects '1AX8.A' and '3PIV.A'
load_alignment 1AX8.A_vs_3PIV.A.pdb, delimiter="_vs_"
"""
# load the file, which should generate a new object
num_objects = len(cmd.get_names("objects"))
cmd.load(filename)
objects = cmd.get_names("objects")
if len(objects) != num_objects + 1:
# an error occured with loading
print ("Error loading file")
return
obj = objects[-1]
if cmd.count_states(obj) >= 2:
# split the object
split_alignment(obj, object1, object2, delimiter)
# clean up
cmd.delete(obj)
else:
print ("Error: Expected 2 models in %s, but found %d." % filename, cmd.count_states(obj))
return
def selectoption2(self):
self.file.toggle()
if (self.sv.get() == 0):
self.fv.set(0)
self.sv.set(1)
self.entry1.config(state=DISABLED)
self.browserButton.config(state=DISABLED)
self.lb1.config(state="normal")
self.lb1.delete(0, 'end')
objects = cmd.get_names("all")
objects.extend(["Pick object"])
for x in objects:
self.lb1.insert(END, x)
else:
self.sv.set(0)
self.fv.set(1)
self.entry1.config(state="normal")
self.browserButton.config(state="normal")
self.lb1.config(state=DISABLED)
# self.vsb.config(state="normal")
self.lb1.delete(0, 'end')
objects = cmd.get_names("all")
objects.extend(["Pick object"])
for x in objects:
self.lb1.insert(END, x)
def find_pdb_file(mut, flex):
"""
Find the pdb file of a pymol selection
This function checks the current working directory for a pdb file with the
same name as the selection model. This will ONLY work if the file is in the
cwd.
Args:
mut (str): PyMol selection name for the mutable design residues
flex(str): PyMol selection name for the flexible design residues
"""
mut_obj_list = cmd.get_names("objects", 0, mut)
flex_obj_list = cmd.get_names("objects", 0, flex)
assert len(mut_obj_list) == 1, "ERROR!: mut_obj_list has length %d, not 1." %len(mut_obj_list)
assert len(flex_obj_list) == 1, "ERROR!: flex_obj_list has length %d, not 1." %len(flex_obj_list)
mut_obj = mut_obj_list[0]
flex_obj = flex_obj_list[0]
assert mut_obj == flex_obj
pdb_rel = mut_obj+".pdb"
if os.path.isfile(pdb_rel):
# Return the absolute path to the pdb
return os.path.abspath(pdb_rel)
# Return the relative path to the pdb
# return pdb_rel
else:
print("WARNING! Could not find pdb file. Please set manually")
return "UNSET"
def testFetchLocal(self):
try:
import urllib.parse as urlparse
except ImportError:
import urlparse
# PyMOL 1.8.6 adds full URLs, remove them
import pymol
pdbpaths = pymol.importing.hostPaths['pdb']
pdbpaths[:] = [p for p in pdbpaths if '://' not in p]
with testing.mkdtemp() as fetch_path:
names = []
cmd.set('fetch_path', fetch_path)
cmd.set('fetch_host', urlparse.urlunsplit(['file', '',
self.datafile('pdb.mirror'), '', '']))
cmd.fetch('1avy', type='pdb')
names += ['1avy']
self.assertItemsEqual(cmd.get_names(), names)
cmd.fetch('1avyB', type='pdb')
names += ['1avyB']
self.assertItemsEqual(cmd.get_names(), names)
self.assertEqual(cmd.get_chains('1avyB'), ['B'])
cmd.fetch('1aq5', type='pdb', multiplex=1)
names += ['1aq5_%04d' % (i+1) for i in range(20)]
self.assertItemsEqual(cmd.get_names(), names)
def testFetchLocal(self):
try:
import urllib.parse as urlparse
except ImportError:
import urlparse
with testing.mkdtemp() as fetch_path:
names = []
cmd.set('fetch_path', fetch_path)
cmd.set(
'fetch_host',
urlparse.urlunsplit(
['file', '',
self.datafile('pdb.mirror'), '', '']))
cmd.fetch('1avy', type='pdb')
names += ['1avy']
self.assertItemsEqual(cmd.get_names(), names)
cmd.fetch('1avyB', type='pdb')
names += ['1avyB']
self.assertItemsEqual(cmd.get_names(), names)
self.assertEqual(cmd.get_chains('1avyB'), ['B'])
cmd.fetch('1aq5', type='pdb', multiplex=1)
names += ['1aq5_%04d' % (i + 1) for i in range(20)]
self.assertItemsEqual(cmd.get_names(), names)
def testDeselect(self):
cmd.load(self.datafile("1oky.pdb.gz"), "m1")
cmd.select("all")
self.assertEquals("sele" in cmd.get_names("all", enabled_only=1), True)
cmd.deselect()
self.assertEquals("sele" in cmd.get_names("all", enabled_only=1),
False)
def testFetchLocal(self):
try:
import urllib.parse as urlparse
except ImportError:
import urlparse
# PyMOL 1.8.6 adds full URLs, remove them
import pymol
pdbpaths = pymol.importing.hostPaths['pdb']
pdbpaths[:] = [p for p in pdbpaths if '://' not in p]
with testing.mkdtemp() as fetch_path:
names = []
cmd.set('fetch_path', fetch_path)
cmd.set(
'fetch_host',
urlparse.urlunsplit(
['file', '',
self.datafile('pdb.mirror'), '', '']))
cmd.fetch('1avy', type='pdb')
names += ['1avy']
self.assertItemsEqual(cmd.get_names(), names)
cmd.fetch('1avyB', type='pdb')
names += ['1avyB']
self.assertItemsEqual(cmd.get_names(), names)
self.assertEqual(cmd.get_chains('1avyB'), ['B'])
cmd.fetch('1aq5', type='pdb', multiplex=1)
names += ['1aq5_%04d' % (i + 1) for i in range(20)]
self.assertItemsEqual(cmd.get_names(), names)
def selectoption1(self):
self.sel.toggle()
if (self.fv.get() == 0):
self.fv.set(1)
self.sv.set(0)
self.entry1.config(state="normal")
self.browserButton.config(state="normal")
self.lb1.config(state=DISABLED)
self.lb1.delete(0, 'end')
objects = cmd.get_names("all")
objects.extend(["Pick object"])
for x in objects:
self.lb1.insert(END, x)
else:
self.fv.set(0)
self.sv.set(1)
self.entry1.config(state=DISABLED)
self.browserButton.config(state=DISABLED)
self.lb1.config(state="normal")
# self.vsb.config(state="normal")
self.lb1.delete(0, 'end')
if pymolenv: # if being loaded in pymol
objects = cmd.get_names("all")
objects.extend(["Pick object"])
else: # dummy arguments for dev mode
objects = ["anl5", "cbm"]
for x in objects:
self.lb1.insert(END, x)
def mytkdialog(parent):
root = tk.Tk()
root.geometry("500x200+100+80")
root.title("Dock Plugin")
root.iconbitmap('@idea.xbm')
receptors = cmd.get_names(selection='(all)')
combobox1 = ttk.Combobox(root,
values=receptors,
height=3,
state='readonly')
combobox1.set(u"Receptor")
combobox1.grid(column=0, row=0)
rec = receptors[combobox1.current()]
ligands = cmd.get_names(selection='(all)')
combobox2 = ttk.Combobox(root, values=ligands, height=3, state='readonly')
combobox2.set(u"Ligand")
combobox2.grid(column=1, row=0)
lig = ligands[combobox2.current()]
buttonDock = tk.Button(root,
text='Dock!',
width=6,
height=1,
bg='blue',
fg='white',
font='arial 14',
command=lambda: fmftpath(rec, lig))
buttonDock.grid(column=2, row=1)
def animate(self):
'''Toggle between 'reduce' and 'flip' flipkin kinemage groups.
The 'flip' group is either 'flipNQ' or 'flipH', depending on which
kinemage is enabled.
Note: Using this method is not recommended if you're using the GUI, as
it doesn't currently affect the state of the flipkin group checkboxes.
'''
# TODO integrate GUI animate button with this function.
# Check which flipkin kinemages are enabled.
logger.debug('checking which kinemages are enabled')
enabled_flipkins = []
for fk in ['flipkinNQ', 'flipkinH']:
kin_grp = self.get_kin_cgo_group(fk)
if kin_grp in cmd.get_names(enabled_only=1):
logger.debug(' {} flipkin is enabled.'.format(fk))
enabled_flipkins.append(fk)
continue
if not enabled_flipkins:
logger.debug(' no flipkin kinemages enabled...enabling flipkinNQ')
self.solo_kin('flipkinNQ')
self.animate()
return
# Regex to match `mp_myobj.*.reduce` (flipkin 'reduce' group)
reduce_group_regex = re.compile(
re.escape(self.mp_group) + r'\.[^\.]+\.reduce$')
# If at least one flipkin kinemage is enabled AND either the 'reduce'
# molecule or any 'reduce' kinemage CGO groups are enabled, solo the
# 'flipX' groups of both flipkin kinemages and the 'flip' molecule of
# whichever flipkin kinemages are enabled.
logger.debug(
'checking if any reduce molecule or kinemage is enabled...')
reduce_is_enabled = 0
for name in cmd.get_names(enabled_only=1):
logger.debug(' checking {} for reduce group match'.format(name))
if reduce_group_regex.match(name) or name == self.pdb['reduce']:
logger.debug(' match! {}')
reduce_is_enabled = 1
continue
if reduce_is_enabled:
logger.debug('reduce was enabled, switching to flips.')
self.disable_pdb('reduce')
# Enable the flipkin 'flip' groups
self.solo_flipkin_group('flip')
# And the molecules for each enabled flipkin.
for fk in enabled_flipkins:
self.enable_pdb(fk)
# If, on the other hand, no 'reduce' group or molecule is enabled, solo
# the 'reduce' groups for all kinemages and the 'reduce'
# coordinates for this MPObject.
else:
self.solo_pdb('reduce')
self.solo_flipkin_group('reduce')
def check_selections(queue):
""" Check if the selection made by the user changed """
global previous_mouse_mode
global myspace
while True:
# Check if the user changed the selection mode (atom/residue/chain/molecule)
logging.debug("Current mouse selection mode : %d" %
int(cmd.get("mouse_selection_mode")))
logging.debug("Number of selections: %d" %
len(cmd.get_names("selections")))
if int(cmd.get("mouse_selection_mode")) == 5 and len(
cmd.get_names("selections")) > 0:
#logging.debug(cmd.get_names("selections")[1])
nb_selected_objects = cmd.count_atoms('sele')
if nb_selected_objects > 0:
logging.info("--- Selection made by the user ---")
logging.info(nb_selected_objects)
cmd.iterate('(sele)', 'models.add(model)', space=myspace)
logging.info(myspace['models'])
tmp = set()
# Make the list with unique items
for i in myspace['models']:
if int(i) not in tmp:
tmp.add(int(i))
# Check if the selection has changed
if tmp != myspace['previous']:
myspace['previous'] = tmp
queue.put(tmp)
else:
time.sleep(1)
cmd.select('none')
elif int(cmd.get("mouse_selection_mode")) == 1 and len(
cmd.get_names("selections")) > 0:
#logging.debug(cmd.get_names("selections")[0])
nb_selected_objects = cmd.count_atoms('sele')
if nb_selected_objects > 0:
logging.info("--- Selection made by the user ---")
cmd.iterate('(sele)', 'residues.add(resv)', space=myspace)
logging.info(myspace['residues'])
tmp = set()
# Make the list with unique items
for i in myspace['residues']:
if int(i) not in tmp:
tmp.add(int(i))
# Check if the selection has changed
if tmp != myspace['previous']:
myspace['previous'] = tmp
queue.put(tmp)
#cmd.delete('lb')
else:
time.sleep(1)
cmd.select('none')
else:
# if len(cmd.get_names("selections", enabled_only=1)) == 0:
# queue.put(set())
#previous_mouse_mode = cmd.get("mouse_selection_mode")
time.sleep(0.5)
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 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 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 animate(self):
'''Toggle between 'reduce' and 'flip' flipkin kinemage groups.
The 'flip' group is either 'flipNQ' or 'flipH', depending on which
kinemage is enabled.
Note: Using this method is not recommended if you're using the GUI, as
it doesn't currently affect the state of the flipkin group checkboxes.
'''
# TODO integrate GUI animate button with this function.
# Check which flipkin kinemages are enabled.
logger.debug('checking which kinemages are enabled')
enabled_flipkins = []
for fk in ['flipkinNQ', 'flipkinH']:
kin_grp = self.get_kin_cgo_group(fk)
if kin_grp in cmd.get_names(enabled_only=1):
logger.debug(' {} flipkin is enabled.'.format(fk))
enabled_flipkins.append(fk)
continue
if not enabled_flipkins:
logger.debug(' no flipkin kinemages enabled...enabling flipkinNQ')
self.solo_kin('flipkinNQ')
self.animate()
return
# Regex to match `mp_myobj.*.reduce` (flipkin 'reduce' group)
reduce_group_regex = re.compile(re.escape(self.mp_group) + r'\.[^\.]+\.reduce$')
# If at least one flipkin kinemage is enabled AND either the 'reduce'
# molecule or any 'reduce' kinemage CGO groups are enabled, solo the
# 'flipX' groups of both flipkin kinemages and the 'flip' molecule of
# whichever flipkin kinemages are enabled.
logger.debug('checking if any reduce molecule or kinemage is enabled...')
reduce_is_enabled = 0
for name in cmd.get_names(enabled_only=1):
logger.debug(' checking {} for reduce group match'.format(name))
if reduce_group_regex.match(name) or name == self.pdb['reduce']:
logger.debug(' match! {}')
reduce_is_enabled = 1
continue
if reduce_is_enabled:
logger.debug('reduce was enabled, switching to flips.')
self.disable_pdb('reduce')
# Enable the flipkin 'flip' groups
self.solo_flipkin_group('flip')
# And the molecules for each enabled flipkin.
for fk in enabled_flipkins:
self.enable_pdb(fk)
# If, on the other hand, no 'reduce' group or molecule is enabled, solo
# the 'reduce' groups for all kinemages and the 'reduce'
# coordinates for this MPObject.
else:
self.solo_pdb('reduce')
self.solo_flipkin_group('reduce')
def surfaceatoms(molecule="NIL",show=True, verbose=True, cutoff=2.5):
"""
surfaceatoms
finds those residues on the surface of a protein
that have at least 'cutoff' exposed A**2 surface area.
PARAMS
molecule (string)
the object or selection in which to find
exposed residues
DEFAULT: (last molecule in pymol)
cutoff (float)
your cutoff of what is exposed or not.
DEFAULT: 2.5 Ang**2
RETURNS
(list: (chain, resv ) )
A Python list of residue numbers corresponding
to those residues w/more exposure than the cutoff.
"""
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]
tmpObj="__tmp"
cmd.create(tmpObj, "(%s and polymer) and not resn HOH"%molecule)
if verbose!=False:
print "WARNING: I'm setting dot_solvent. You may not care for this."
cmd.set("dot_solvent")
cmd.get_area(selection=tmpObj, load_b=1)
# threshold on what one considers an "exposed" atom (in A**2):
cmd.remove( tmpObj + " and b < " + str(cutoff) )
stored.tmp_dict = {}
cmd.iterate(tmpObj, "stored.tmp_dict[(chain,resv)]=1")
exposed = stored.tmp_dict.keys()
exposed.sort()
selName = "%s_atoms"%molecule
cmd.select(selName, molecule + " in " + tmpObj )
if verbose!=False:
print "Exposed residues are selected in: " + selName
selNameRes = "%s_resi"%molecule
cmd.select(selNameRes, "byres " + selName )
if show!=False:
cmd.hide("everything", molecule)
cmd.show("cartoon", "%s and not %s and not resn HOH"%(molecule,selNameRes))
cmd.show("sticks", "%s"%selNameRes)
cmd.util.cbaw(selNameRes)
cmd.disable(selNameRes)
#cmd.alter('%s'%(selName),'vdw=0.5') # affects repeated runs
cmd.set('sphere_scale','0.3','%s'%(selName)) # does not affect repeated runs
cmd.show("spheres", "%s"%selName)
cmd.util.cbao(selName)
cmd.disable(selName)
cmd.delete(tmpObj)
print(exposed)
return(exposed)
def test_gen(max_num_mut=6, target_num_mut=None, flex_only=False,
limit_seqspace=False):
"""Generate all reasonable designs from the current pdb
Args:
max_num_mut (int): The maximum number of mutations to allow
target_num_mut (int): Only return mutable sets of this size
flex_only (boolean): Allow mutations?
Raises:
CmdException: Error in a PyMol command
"""
# Generate all interfaces
# Note - this command seems to work well for picking only
# sidechain-sidechain contacts
interface(None,None,3,1)
try:
inter_list = cmd.get_names("selections", 0, "all")
except:
raise CmdException
inter_list = [ e for e in inter_list if e[0:3]=="int" ]
# Find potential mutable residues
mut_list = []
for inter in inter_list:
chains = cmd.get_chains(inter)
inter_1 = inter+' and chain '+chains[0]
inter_2 = inter+' and chain '+chains[1]
print(inter_1)
mut_list.extend(gen_mut(inter_1, max_num_mut, target_num_mut))
print(inter_2)
mut_list.extend(gen_mut(inter_2, max_num_mut, target_num_mut))
print('Generated '+str(len(mut_list))+' sets of mutations')
# For each mutable residue set, generate a flexible shell and print design
counter = 0
for mut in mut_list:
#Select muts
obj_name = cmd.get_names('objects',0,'all')[0]
resi_list = [ str(res.res_seq)+res.i_code for res in mut ]
chain = next(iter(mut)).chain_id
selection = "br. chain "+chain+" and resi "+'+'.join(resi_list)
cmd.select("mut", selection)
#gen_shell
gen_shell(1,0,"mut",5)
#print output
name = '_'.join([obj_name[:4], chain])+".cfs"
print_design("mut", "flex", name, flex_only, limit_seqspace)
counter = counter+1
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 testGetNames(self):
cmd.fragment('gly')
cmd.fragment('cys')
cmd.ramp_new('ramp1', 'none') # non-molecular object
cmd.select('foo', 'none')
self.assertEqual(cmd.get_names(), ['gly', 'cys', 'ramp1'])
self.assertEqual(cmd.get_names(selection="elem S"), ['cys'])
cmd.disable('gly')
cmd.disable('ramp1')
self.assertEqual(cmd.get_names(enabled_only=1), ['cys'])
self.assertEqual(cmd.get_names('selections'), ['foo'])
self.assertEqual(cmd.get_names('all'), ['gly', 'cys', 'ramp1', 'foo'])
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_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 test(self):
names_ungrouped = ['a0', 'a1', 'b0', 'b1', 'c0', 'c1', 'g1']
names_grouped = ['a0', 'a1', 'c0', 'c1', 'b0', 'g1', 'b1']
for name in names_ungrouped[:-1]:
cmd.pseudoatom(name)
cmd.group(names_ungrouped[-1])
self.assertEqual(cmd.get_names(), names_ungrouped)
cmd.group('g1', 'b*')
cmd.order('b0 g1', location="upper")
self.assertEqual(cmd.get_names(), names_grouped)
def testFetch(self):
with testing.mkdtemp() as fetch_path:
names = []
cmd.set('fetch_path', fetch_path)
cmd.set('fetch_host', 'pdb pdbe')
cmd.fetch('1avy', '1avy1', type='pdb1')
names += ['1avy1']
self.assertItemsEqual(cmd.get_names(), names)
self.assertEqual(cmd.count_states('1avy1'), 3)
cmd.fetch('1avy', type='2fofc')
names += ['1avy_2fofc']
self.assertItemsEqual(cmd.get_names(), names)
self.assertEqual(cmd.get_type('1avy_2fofc'), 'object:map')
def test_angle_between_helices():
cmd.reinitialize()
cmd.load(DATA_PATH / "1nmr-frag-nohydro.pdb", "m1")
angle = psico.orientation.angle_between_helices("resi 53-61",
"resi 63-79",
method="helix")
assert angle == approx(159.164, abs=0.01)
assert set(["oriVec01", "oriVec02", "angle01"]).issubset(cmd.get_names())
angle = psico.orientation.angle_between_helices("resi 53-61",
"resi 63-79",
method="cafit")
assert angle == approx(158.624, abs=0.01)
assert set(["oriVec03", "oriVec04", "angle02"]).issubset(cmd.get_names())
def testFetch(self):
with testing.mkdtemp() as fetch_path:
names = []
cmd.set('fetch_path', fetch_path)
cmd.set('fetch_host', 'pdb pdbe')
cmd.fetch('1avy', '1avy1', type='pdb1')
names += ['1avy1']
self.assertItemsEqual(cmd.get_names(), names)
self.assertEqual(cmd.count_states('1avy1'), 3)
cmd.fetch('1avy', type='2fofc')
names += ['1avy_2fofc']
self.assertItemsEqual(cmd.get_names(), names)
self.assertEqual(cmd.get_type('1avy_2fofc'), 'object:map')
def align_all( subset = [] ):
"""
Superimpose all open models onto the first one.
This may not work well with selections.
This function is probably taken from https://daslab.stanford.edu/site_data/docs_pymol_rhiju.pdf
"""
print("""This returns a list with 7 items:
RMSD after refinement
Number of aligned atoms after refinement
Number of refinement cycles
RMSD before refinement
Number of aligned atoms before refinement
Raw alignment score
Number of residues aligned """)
AllObj=cmd.get_names("all")
for x in AllObj[1:]:
#print(AllObj[0],x)
subset_tag = ''
if isinstance( subset, int ):
subset_tag = ' and resi %d' % subset
elif isinstance( subset, list ) and len( subset ) > 0:
subset_tag = ' and resi %d' % (subset[0])
for m in range( 1,len(subset)): subset_tag += '+%d' % subset[m]
elif isinstance( subset, str ) and len( subset ) > 0:
subset_tag = ' and %s' % subset
values = cmd.align(x+subset_tag,AllObj[0]+subset_tag)
print(AllObj[0], x, ' '.join([str(v) for v in values]), '-- RMSD', values[3], ' of ', values[6], 'residues')
cmd.zoom()
def na():
cmd.view('v', 'store');
object = cmd.get_names()[0]
pdbid = object[0:4]
chainid = object[4:5]
cmd.fetch(pdbid)
cmd.select("design_na","%s and chain %s"%(object,"B"))
cmd.select("native_na","%s and chain %s"%(pdbid,chainid))
cmd.select("other_na","%s and not chain %s"%(pdbid,chainid))
cmd.hide("everything","other")
cmd.hide('(resn HOH)')
cmd.super("design_na","native_na")
cmd.select("none")
cmd.orient(object)
cmd.system("rm %s.pdb"%(pdbid));
cmd.view('v', 'recall')
def na():
cmd.view('v', 'store');
object = cmd.get_names()[0]
if object[0] == 'd':
pdbid = object[1:5]
chainid = object[5:6]
else:
pdbid = object[0:4]
chainid = object[4:5]
cmd.fetch(pdbid)
cmd.select("design_na","%s and chain %s and not hydro"%(object,"B"))
cmd.select("native_na","%s and chain %s and not hydro"%(pdbid,chainid))
cmd.select("other_na","%s and not chain %s"%(pdbid,chainid))
cmd.hide("everything","other")
cmd.hide('(resn HOH)')
cmd.super("native_na","design_na")
cmd.hide("lines","all");
cmd.show("sticks","native_na");
cmd.show("cartoon","native_na");
cmd.select("none")
cmd.orient(object)
pdbid = pdbid.lower()
cmd.system("rm %s.pdb"%(pdbid));
cmd.view('v', 'recall')
def rs():
""" The function creates super-cool cartoon-like RNA and colors each structure as a rainbow.
Good to view aligned structures in a grid.
.. image:: ../../rna_tools/utils/PyMOL4RNA/doc/rs.png
"""
cmd.hide("sticks", "all")
cmd.hide("lines", "all")
cmd.show("cartoon", "all")
cmd.set("cartoon_ring_mode", 3)
cmd.set("cartoon_ring_finder", 2)
cmd.set("cartoon_ladder_mode", 2)
cmd.set("cartoon_ring_transparency", 0.30)
cmd.spectrum()
obj_list = cmd.get_names('objects')
colours = ['rainbow']
ncolours = len(colours)
# Loop over objects
i = 0
for obj in obj_list:
print(" ", obj, colours[i])
cmd.spectrum('count', colours[i], obj)
i = i + 1
if (i == ncolours):
i = 0
def launch_search(self):
"""
launches the search in the separate thread
does some basic checking and gets selection
"""
# gets the active selections from pymol
active_selections = cmd.get_names('selections', 1)
if len(active_selections) == 0:
self.status = 'no selection'
else:
selection = active_selections[0]
print "The active selections are " + str(selection)
pdbstr = cmd.get_pdbstr(selection)
print 'pdbstr is', pdbstr
self.stop_search()
self.searchThread = SearchThread(self,
self.rmsd_cutoff,
self.number_of_structures,
self.full_match,
self.database,
pdbstr,
self.url,
self.cmd,
self.dictionary)
self.searchThread.start()
self.status = 'search launched'
self.searchProgress = 0
self.cmd.refresh_wizard()
def testAppend(self):
cmd.set('auto_rename_duplicate_objects', 0)
self._load_session_twice()
v = cmd.get_names()
self.assertEqual(v, self.v_ref)
def all_vs_all(filename='rms_matrix.txt'):
AllObj=cmd.get_names("public_objects") # not temps created by alignment or selections
matrix = []
for x in AllObj:
x_to_all = []
for y in AllObj:
rmsd = cmd.rms( x, y, cutoff=10)#[0] # super-inclusive
x_to_all.append(rmsd)
matrix.append(x_to_all)
print matrix
outfile = open(filename,'w')
# No names 'on top' -- we can figure these out from the vertical ordering
# and they're way too long...
#for name in AllObj:
# outfile.write("\t%s" % name)
#outfile.write("\n")
maxlen = 0
for obj in AllObj:
if maxlen < len(obj):
maxlen = len(obj)
print_allobj = []
for obj in AllObj:
while len(obj) < maxlen:
obj += ' '
print_allobj.append(obj)
ni = 0
for x in matrix:
outfile.write(print_allobj[ni])
ni += 1
for y in x:
outfile.write("\t%0.2f" % y)
outfile.write("\n")
def __call__(self):
if self.name not in cmd.get_names('objects'):
import threading
threading.Thread(None, cmd.delete, args=(self.cb_name,)).start()
return
v = cmd.get_view()
if v == self.prev_v:
return
self.prev_v = v
t = v[12:15]
if self.corner:
vp = cmd.get_viewport()
R_mc = [v[0:3], v[3:6], v[6:9]]
off_c = [0.15 * v[11] * vp[0] / vp[1], 0.15 * v[11], 0.0]
if self.corner in [2,3]:
off_c[0] *= -1
if self.corner in [3,4]:
off_c[1] *= -1
off_m = cpv.transform(R_mc, off_c)
t = cpv.add(t, off_m)
z = -v[11] / 30.0
m = [z, 0, 0, t[0] / z, 0, z, 0, t[1] / z, 0, 0, z, t[2] / z, 0, 0, 0, 1]
cmd.set_object_ttt(self.name, m, homogenous=1)
def testPseSupport(self):
cmd.load_callback(callback.Callback(), 'c1')
with testing.mktemp('tmp.pse') as session_filename:
cmd.save(session_filename)
cmd.delete('*')
cmd.load(session_filename)
self.assertTrue('c1' in cmd.get_names())
def rcomp():
"""RNA like in papers ;-)
Similar to rc() but this time it colors each (and every) structure in different colour.
Great on viewing-comparing superimposed structures.
"""
cmd.hide("sticks", "all")
cmd.hide("lines", "all")
cmd.show("cartoon", "all")
cmd.set("cartoon_ring_mode", 3)
cmd.set("cartoon_ring_finder", 2)
cmd.set("cartoon_ladder_mode", 2)
cmd.set("cartoon_ring_transparency", 0.30)
obj_list = cmd.get_names('objects')
colours = ['red', 'green', 'blue', 'yellow', 'violet', 'cyan', \
'salmon', 'lime', 'pink', 'slate', 'magenta', 'orange', 'marine', \
'olive', 'purple', 'teal', 'forest', 'firebrick', 'chocolate', \
'wheat', 'white', 'grey' ]
ncolours = len(colours)
# Loop over objects
i = 0
for obj in obj_list:
print(" ", obj, colours[i])
cmd.color(colours[i], obj)
i = i+1
if(i == ncolours):
i = 0
def rs():
""" The function creates super-cool cartoon-like RNA and colors each structure as a rainbow.
Good to view aligned structures in a grid.
.. image:: ../../rna_tools/utils/PyMOL4RNA/doc/rs.png
"""
cmd.hide("sticks", "all")
cmd.hide("lines", "all")
cmd.show("cartoon", "all")
cmd.set("cartoon_ring_mode", 3)
cmd.set("cartoon_ring_finder", 2)
cmd.set("cartoon_ladder_mode", 2)
cmd.set("cartoon_ring_transparency", 0.30)
cmd.spectrum()
obj_list = cmd.get_names('objects')
colours = ['rainbow']
ncolours = len(colours)
# Loop over objects
i = 0
for obj in obj_list:
print(" ", obj, colours[i])
cmd.spectrum('count', colours[i], obj)
i = i+1
if(i == ncolours):
i = 0
def rd():
"""
rhiju's favorite coloring of proteins and generic molecules
side chains are all-heavy-atom and colored CPK, backbone is
rainbow cartoon from N to C terminus.
"""
cmd.bg_color( "white" )
AllObj=cmd.get_names("all")
for x in AllObj:
#print(AllObj[0],x)
print x
cmd.show( "cartoon", x )
cmd.hide( "line", x )
cmd.color( "white", x+" and elem C" )
cmd.color( "blue", x+" and elem N" )
cmd.color( "red", x+" and elem O" )
cmd.color( "yellow", x+" and elem S" )
cmd.spectrum( "resi", "rainbow", x+" and name CA+C" )
cmd.show( "sticks", x +" and not elem H and not name C+N+O" )
cmd.show( "sticks", x +" and resn PRO and name N" )
cmd.show( "sticks", x + " and name NR+CR+CS+CP+CQ" )
cmd.show( "sticks", x + " and not elem H and neighbor name NR+CQ+CR+CS+CP" )
cmd.show( "sticks", x + " and not elem H and neighbor neighbor name NR+CQ+CR+CS+CP" )
cmd.set( "cartoon_oval_width", 0.1 )
cmd.set( "cartoon_oval_length", 0.5 )
def rr():
"""
rhiju's favorite coloring of RNA
with 2' OH as spheres,
bases as filled rings, and backbone as cartoon
ribbons, rainbow colored from 5' to 3'. No hydrogens,
white background.
"""
cmd.bg_color( "white" )
cmd.hide( 'everything' )
cmd.show('sticks','not elem H')
cmd.color( 'red','resn rG+G+DG')
cmd.color( 'forest','resn rC+C+DC')
cmd.color( 'orange','resn rA+A+DA')
cmd.color( 'blue','resn rU+U+DT+BRU')
#cmd.set( 'cartoon_ring_color', 'red','resn rG+G+DG')
#cmd.set( 'cartoon_ring_color', 'forest','resn rC+C+DC')
#cmd.set( 'cartoon_ring_color', 'orange','resn rA+A+DA')
#cmd.set( 'cartoon_ring_color', 'blue','resn rU+U+DT+BRU')
#cmd.select('bases','name c2+c4+c5+c6+c8+n1+n2+n3+n4+n6+n7+n9+o2+o4+o6+n1p')
#cmd.select('backbone', 'name o1p+o2p+o3p+p+c1*+c2*+c3*+c5*+o2*+o3*+o4*+o5*')
#cmd.select('sugar', 'name c1*+c2*+c3*+c4*+o2*+o4*')
AllObj=cmd.get_names("all")
cmd.color( 'red','resn rG+G and name n1+c6+o6+c5+c4+n7+c8+n9+n3+c2+n1+n2')
cmd.color( 'forest','resn rC+C and name n1+c2+o2+n3+c4+n4+c5+c6')
cmd.color( 'orange','resn rA+A and name n1+c6+n6+c5+n7+c8+n9+c4+n3+c2')
cmd.color( 'blue','resn rU+U and name n3+c4+o4+c5+c6+n1+c2+o2')
cmd.select( 'backbone', " (name o1p+o2p+o3p+p+op1+op2+'c1*'+'c2*'+'c3*'+'c5*'+'o2*'+'o3*'+'o4*'+'o5*'+'c1*'+'c2*'+'c3*'+'c4*'+'o2*'+'o4*'+c1'+c2'+c3'+c5'+o2'+o3'+o4'+o5'+c1'+c2'+c3'+c4'+o2'+o4') and (not name c1+c2+c3+c4+c5+o2+o3+o4+o5) ")
for x in AllObj:
cmd.show( "cartoon", x )
cmd.spectrum( "count", "rainbow", x+" and backbone" )
#cmd.color( 'white', 'backbone' )
cmd.cartoon( "tube", "backbone" )
cmd.set( "cartoon_ring_mode", 3 )
cmd.set( "cartoon_ring_transparency", 0.0 )
cmd.set( "cartoon_tube_radius", 0.2 )
cmd.hide( "sticks", "backbone" )
cmd.delete('backbone')
cmd.alter( "name o2*","vdw=0.5" )
cmd.show( "spheres", "name o2'+'o2*' and not name o2" )
cmd.show( "sticks", "name 'o2*'+'c2*'a" )
cmd.show( "sticks", "resn hoh" )
cmd.alter( "resn mg", "vdw=1.0")
cmd.alter( "resn hoh", "vdw=0.5")
cmd.show( "spheres", "resn mg+sr+co+zn+hoh and not elem H")
def rx():
"""
rhiju's favorite coloring of proteins, more details --
no cartoon; heavy backbone
"""
cmd.bg_color( "white" )
AllObj=cmd.get_names("all")
for x in AllObj:
#print(AllObj[0],x)
print x
cmd.hide( "line", x )
cmd.color( "white", x+" and elem C" )
cmd.color( "blue", x+" and elem N" )
cmd.color( "red", x+" and elem O" )
cmd.color( "yellow", x+" and elem S" )
cmd.spectrum( "resi", "rainbow", x+" and name CA+C" )
#cmd.show( "sticks", x +" and not elem H and not name C+N+O" )
cmd.select('backbone','name o+c+ca+n')
cmd.show('sticks','not elem H')
if not x.count( 'BACKBONE' ):
cmd.create( x+"_BACKBONE", x+" and not element H and backbone" )
cmd.set('stick_radius', '0.5', "*BACKBONE" )
def getChains(): '''获取当前导入的PDB文件所含有的chains''' chains=[] for x in cmd.get_names(): for ch in cmd.get_chains(x): chains.append(ch) return chains
def rj():
"""
rhiju's residue-level favorite coloring of proteins
"""
cmd.bg_color( "white" )
AllObj=cmd.get_names("all")
for x in AllObj:
#print(AllObj[0],x)
print x
cmd.show( "cartoon", x )
#cmd.hide( "line", x )
cmd.show( "line", x )
cmd.color( "gray", x+" and resn trp+phe+ala+val+leu+ile+pro+met" )
cmd.color( "orange", x+" and resn gly" )
cmd.color( "red", x+" and resn asp+glu" )
cmd.color( "blue", x+" and resn lys+arg+his" )
cmd.color( "purple", x+" and resn cys" )
cmd.color( "forest", x+" and resn tyr+thr+ser+gln+asn" )
#cmd.spectrum( "resi", "rainbow", x+" and name CA" )
cmd.show( "sticks", x +" and not elem H and not name C+N+O" )
cmd.show( "sticks", x +" and resn PRO and name N" )
cmd.hide( "sticks", x + " and name NR+CR+CS+CP+CQ" )
cmd.show( "sticks", x + " and not elem H and neighbor name NR+CQ+CR+CS+CP" )
cmd.set( "cartoon_rect_length", 0.75 )
cmd.set( "cartoon_rect_width", 0.1 )
cmd.set( "cartoon_oval_length", 0.6 )
cmd.set( "cartoon_oval_width", 0.2 )
def launch_search(self):
"""
launches the search in the separate thread
does some basic checking and gets selection
"""
# gets the active selections from pymol
active_selections = cmd.get_names('selections', 1)
if len(active_selections) == 0:
cmd.get_wizard().set_status('no selection')
else:
selection = active_selections[0]
print "The active selections are " + str(selection)
pdbstr = cmd.get_pdbstr(selection)
print 'pdbstr is', pdbstr
self.stop_search()
# print cmd.get_wizard(), self.win.rmsd.get(), self.win.num_structs.get(), self.win.full_match, self.win.datab, pdbstr, self.win.serverURL, cmd.get_wizard().cmd, self.win.jobIDs
self.win.searchThread = SearchThread(cmd.get_wizard(),
self.win.rmsd.get(),
self.win.num_structs.get(),
self.win.full_match,
self.win.datab, pdbstr,
self.win.serverURL,
cmd.get_wizard().cmd,
self.win.jobIDs)
self.win.searchThread.start()
cmd.get_wizard().set_status('search launched')
cmd.get_wizard().searchProgress = 0
cmd.refresh_wizard()
def na():
cmd.view('v', 'store')
object = cmd.get_names()[0]
if object[0] == 'd':
pdbid = object[1:5]
chainid = object[5:6]
else:
pdbid = object[0:4]
chainid = object[4:5]
cmd.fetch(pdbid)
cmd.select("design_na", "%s and chain %s and not hydro" % (object, "B"))
cmd.select("native_na", "%s and chain %s and not hydro" % (pdbid, chainid))
cmd.select("other_na", "%s and not chain %s" % (pdbid, chainid))
cmd.hide("everything", "other")
cmd.hide('(resn HOH)')
cmd.super("native_na", "design_na")
cmd.hide("lines", "all")
cmd.show("sticks", "native_na")
cmd.show("cartoon", "native_na")
cmd.select("none")
cmd.orient(object)
pdbid = pdbid.lower()
cmd.system("rm %s.pdb" % (pdbid))
cmd.view('v', 'recall')
def rcomp():
"""RNA like in papers ;-)
Similar to rc() but this time it colors each (and every) structure in different colour.
Great on viewing-comparing superimposed structures.
"""
cmd.hide("sticks", "all")
cmd.hide("lines", "all")
cmd.show("cartoon", "all")
cmd.set("cartoon_ring_mode", 3)
cmd.set("cartoon_ring_finder", 2)
cmd.set("cartoon_ladder_mode", 2)
cmd.set("cartoon_ring_transparency", 0.30)
obj_list = cmd.get_names('objects')
colours = ['red', 'green', 'blue', 'yellow', 'violet', 'cyan', \
'salmon', 'lime', 'pink', 'slate', 'magenta', 'orange', 'marine', \
'olive', 'purple', 'teal', 'forest', 'firebrick', 'chocolate', \
'wheat', 'white', 'grey' ]
ncolours = len(colours)
# Loop over objects
i = 0
for obj in obj_list:
print(" ", obj, colours[i])
cmd.color(colours[i], obj)
i = i + 1
if (i == ncolours):
i = 0
def nat(pdbid,chainid):
cmd.view('v', 'store');
object = cmd.get_names()[0]
cmd.fetch(pdbid)
cmd.select("design_nat","%s and chain %s and not hydro"%(object,"B"))
cmd.select("native_nat","%s and chain %s and not hydro"%(pdbid,chainid))
cmd.select("other_nat","%s and not chain %s"%(pdbid,chainid))
cmd.hide("everything","other")
cmd.hide('(resn HOH)')
cmd.super("design_nat","native_nat")
cmd.select("none")
cmd.orient(object)
cmd.hide("lines","all");
cmd.show("sticks","native_nat");
cmd.show("cartoon","native_nat");
cmd.system("rm %s.pdb"%(pdbid));
cmd.view('v', 'recall')
def launch_search(self):
"""
launches the search in the separate thread
does some basic checking and gets selection
"""
# gets the active selections from pymol
active_selections = cmd.get_names('selections', 1)
if len(active_selections) == 0:
self.status = 'no selection'
else:
selection = active_selections[0]
print "The active selections are" + str(selection)
pdbstr = cmd.get_pdbstr(selection)
print 'pdbstr is', pdbstr
self.stop_search()
self.searchThread = SearchThread(self, self.rmsd_cutoff,
self.number_of_structures,
self.full_match, self.database,
pdbstr, self.url, self.cmd,
self.dictionary)
self.searchThread.start()
self.status = 'search launched'
self.searchProgress = 0
self.cmd.refresh_wizard()
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 nat(pdbid, chainid):
cmd.view('v', 'store')
object = cmd.get_names()[0]
cmd.fetch(pdbid)
cmd.select("design_nat", "%s and chain %s and not hydro" % (object, "B"))
cmd.select("native_nat",
"%s and chain %s and not hydro" % (pdbid, chainid))
cmd.select("other_nat", "%s and not chain %s" % (pdbid, chainid))
cmd.hide("everything", "other")
cmd.hide('(resn HOH)')
cmd.super("design_nat", "native_nat")
cmd.select("none")
cmd.orient(object)
cmd.hide("lines", "all")
cmd.show("sticks", "native_nat")
cmd.show("cartoon", "native_nat")
cmd.system("rm %s.pdb" % (pdbid))
cmd.view('v', 'recall')
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_dna_rna():
glb.update()
objects = cmd.get_names('all')
cmd.set('cartoon_ring_mode' , '1')
if 'dna' in objects or 'rna' in objects:
if 'protein' in objects:
cmd.show('cartoon', 'protein')
cmd.color('gray60', 'protein')
if 'ligands' in objects:
cmd.show('spheres', 'ligands')
cmd.set('sphere_transparency', '0.4', 'ligands')
cmd.set('sphere_scale', '0.4', 'ligands')
cmd.color('orange', 'ligands')
if 'dna' in objects:
cmd.show('cartoon', 'dna')
if 'rna' in objects:
cmd.show('cartoon', 'rna')
cmd.color('lightblue', 'resn a')
cmd.color('orange', 'resn c')
cmd.color('salmon', 'resn g')
cmd.color('palegreen', 'resn t')
cmd.color('paleyellow', 'resn u')
showinfo('Nucleic Acid Key',
'Adenine = light blue\nCytosine = orange\n'+
'Guanine = salmon red\nThymine = light green\n'+
'Uracil = light yellow')
else:
showinfo("Error", "There is no DNA or RNA in this molecule.")
def chain_contact():
def chain_contact_loop(c,skip,chainPullList):
d = 0
l = c + 1
while len(chainPullList) > l and (26-d) >= 0:
cmd.select('chain_contact','%s w. 5 of %s'%(chainPullList[d],chainPullList[c+1]),enable=0,quiet=1,merge=1)
cmd.select('chain_contact','%s w. 5 of %s'%(chainPullList[c+1],chainPullList[d]),enable=0,quiet=1,merge=1)
d += 1
l += 1
while d == (c+1) or d in skip:
d += 1
glb.update()
cmd.hide('everything')
cmd.show('mesh', 'all')
cmd.color('gray40', 'all')
objects = cmd.get_names('all')
chainPullList = []
for i in cmd.get_chains(quiet=1):
chainPullList.append('Chain-'+i)
if len(chainPullList) < 2:
showinfo('Notice','There needs to be two or more chains to run this functions.')
return False
c = 0
skip = []
while c < (len(chainPullList)-1) and c < 26:
skip.append(c+1)
chain_contact_loop(c,skip,chainPullList)
c += 1
glb.procolor('chain_contact','mesh','cpk',None)
cmd.delete('chain_contact')
return chainPullList
def __call__(self):
if self.name not in cmd.get_names('objects'):
import threading
threading.Thread(None, cmd.delete, args=(self.cb_name,)).start()
return
v = cmd.get_view()
if v == self.prev_v:
return
self.prev_v = v
t = v[12:15]
if self.corner:
vp = cmd.get_viewport()
R_mc = [v[0:3], v[3:6], v[6:9]]
off_c = [0.15 * v[11] * vp[0] / vp[1], 0.15 * v[11], 0.0]
if self.corner in [2,3]:
off_c[0] *= -1
if self.corner in [3,4]:
off_c[1] *= -1
off_m = cpv.transform(R_mc, off_c)
t = cpv.add(t, off_m)
z = -v[11] / 30.0
m = [z, 0, 0, 0, 0, z, 0, 0, 0, 0, z, 0, t[0] / z, t[1] / z, t[2] / z, 1]
cmd.set_object_ttt(self.name, m)
def testMMTFExportEmpty(self):
with testing.mktemp('.mmtf') as filename:
cmd.save(filename)
cmd.load(filename, 'm1')
self.assertEqual(cmd.count_atoms(), 0)
self.assertEqual(cmd.get_names(), ['m1'])
