1221 lines
38 KiB
Python
1221 lines
38 KiB
Python
#A* -------------------------------------------------------------------
|
|
#B* This file contains source code for the PyMOL computer program
|
|
#C* Copyright (c) Schrodinger, LLC.
|
|
#D* -------------------------------------------------------------------
|
|
#E* It is unlawful to modify or remove this copyright notice.
|
|
#F* -------------------------------------------------------------------
|
|
#G* Please see the accompanying LICENSE file for further information.
|
|
#H* -------------------------------------------------------------------
|
|
#I* Additional authors of this source file include:
|
|
#-*
|
|
#-*
|
|
#-*
|
|
#Z* -------------------------------------------------------------------
|
|
|
|
import sys
|
|
|
|
cmd = __import__("sys").modules["pymol.cmd"]
|
|
import pymol
|
|
from pymol import movie
|
|
# legacy mappings, remove in PyMOL 2.0
|
|
|
|
mload = movie.load
|
|
mrock = movie.rock
|
|
mroll = movie.roll
|
|
|
|
# should match the list in layer1/Color.c:
|
|
_color_cycle = [
|
|
26 , # /* carbon */
|
|
5 , # /* cyan */
|
|
154 , # /* lightmagenta */
|
|
6 , # /* yellow */
|
|
9 , # /* salmon */
|
|
29 , # /* hydrogen */
|
|
11 , # /* slate */
|
|
13 , # /* orange */
|
|
10 , # /* lime */
|
|
5262 , # /* deepteal */
|
|
12 , # /* hotpink */
|
|
36 , # /* yelloworange */
|
|
5271 , # /* violetpurple */
|
|
124 , # /* grey70 */
|
|
17 , # /* marine */
|
|
18 , # /* olive */
|
|
5270 , # /* smudge */
|
|
20 , # /* teal */
|
|
5272 , # /* dirtyviolet */
|
|
52 , # /* wheat */
|
|
5258 , # /* deepsalmon */
|
|
5274 , # /* lightpink */
|
|
5257 , # /* aquamarine */
|
|
5256 , # /* paleyellow */
|
|
15 , # /* limegreen */
|
|
5277 , # /* skyblue */
|
|
5279 , # /* warmpink */
|
|
5276 , # /* limon */
|
|
53 , # /* violet */
|
|
5278 , # /* bluewhite */
|
|
5275 , # /* greencyan */
|
|
5269 , # /* sand */
|
|
22 , # /* forest */
|
|
5266 , # /* lightteal */
|
|
5280 , # /* darksalmon */
|
|
5267 , # /* splitpea */
|
|
5268 , # /* raspberry */
|
|
104 , # /* grey50 */
|
|
23 , # /* deepblue */
|
|
51 , # /* brown */
|
|
]
|
|
|
|
_color_cycle_len = len(_color_cycle)
|
|
|
|
class _verbose_cmd_proxy:
|
|
def __init__(self, cmd):
|
|
self.cmd = cmd
|
|
def __getattr__(self, name):
|
|
return getattr(self.cmd, name)
|
|
def set(self, name, value=1):
|
|
return self.cmd.set(name, value, quiet=0)
|
|
|
|
def color_by_area(sele, mode="molecular", state=0, palette='rainbow', _self=cmd):
|
|
"""
|
|
DESCRIPTION
|
|
|
|
Colors molecule by surface area
|
|
|
|
ARGUMENTS
|
|
|
|
sele = str: atom selection
|
|
|
|
mode = str: "molecular" {default} or "solvent"
|
|
"""
|
|
asa = 1 if mode=="solvent" else 0
|
|
|
|
tmpObj = _self.get_unused_name("_tmp")
|
|
tmpSel = _self.get_unused_name("_sel")
|
|
orgSel = _self.get_unused_name("_org")
|
|
|
|
orgN = _self.select(orgSel, sele, 0)
|
|
_self.create(tmpObj, "byobj ?%s & ! solvent" % (orgSel), zoom=0)
|
|
tmpN = _self.select(tmpSel, '?%s in ?%s' % (tmpObj, orgSel), 0)
|
|
|
|
try:
|
|
if orgN != tmpN:
|
|
raise pymol.CmdException('color_by_area failed')
|
|
|
|
_self.set("dot_solvent", asa, tmpObj)
|
|
_self.set("dot_density", 3, tmpObj)
|
|
|
|
l = []
|
|
_self.get_area(tmpSel, load_b=1)
|
|
_self.spectrum("b", palette, tmpSel)
|
|
_self.iterate(tmpSel, "l_a(color)", space={'l_a': l.append})
|
|
_self.alter(orgSel, "color=l_n()", space={'l_n': getattr(iter(l), '__next__')})
|
|
|
|
_self.recolor(orgSel)
|
|
finally:
|
|
_self.delete(tmpSel)
|
|
_self.delete(tmpObj)
|
|
_self.delete(orgSel)
|
|
|
|
def find_surface_residues(sele, name='', _self=cmd):
|
|
"""
|
|
DESCRIPTION
|
|
|
|
Finds those residues on the surface of a protein
|
|
that have at least 'surface_residue_cutoff' (setting)
|
|
exposed A**2 surface area.
|
|
|
|
Returns the name of the selection.
|
|
|
|
ARGUMENTS
|
|
|
|
sele = str: the object or selection in which to find exposed residues
|
|
|
|
name = str: name of selection to create {default: exposed??}
|
|
"""
|
|
from collections import defaultdict
|
|
|
|
tmpObj = _self.get_unused_name("__tmp")
|
|
selName = name or _self.get_unused_name("exposed")
|
|
|
|
_self.select(selName, sele)
|
|
_self.create(tmpObj, "(byobj ?%s) & ! solvent" % (selName), zoom=0)
|
|
_self.select(selName, '?%s in ?%s' % (tmpObj, selName))
|
|
|
|
_self.set("dot_solvent", 1, tmpObj);
|
|
_self.get_area(selName, load_b=1)
|
|
|
|
# threshold on what one considers an "exposed" atom (in A**2):
|
|
surface_residue_cutoff = _self.get_setting_float("surface_residue_cutoff")
|
|
|
|
res_area = defaultdict(int)
|
|
_self.iterate(selName, "res_area[segi, chain, resi] += b", space=locals())
|
|
|
|
_self.select(selName, 'none')
|
|
_self.delete(tmpObj)
|
|
|
|
for (k, v) in res_area.items():
|
|
if v < surface_residue_cutoff:
|
|
continue
|
|
_self.select(selName, 'segi %s & chain %s & resi %s' % k, merge=1)
|
|
|
|
return selName
|
|
|
|
|
|
def find_surface_atoms(sele, name='', cutoff=-1, _self=cmd):
|
|
"""
|
|
DESCRIPTION
|
|
|
|
Finds those atoms on the surface of a protein
|
|
that have at least 'cutoff' (argument) or 'surface_residue_cutoff'
|
|
(setting) exposed A**2 surface area.
|
|
|
|
Returns the name of the selection.
|
|
|
|
ARGUMENTS
|
|
|
|
sele = str: the object or selection in which to find exposed residues
|
|
|
|
name = str: name of selection to create {default: exposed??}
|
|
"""
|
|
tmpObj = _self.get_unused_name("_tmp")
|
|
tmpSel = _self.get_unused_name("_sel")
|
|
|
|
_self.select(tmpSel, sele, 0)
|
|
_self.create(tmpObj, "(byobj ?%s) & ! solvent" % (tmpSel), zoom=0)
|
|
|
|
selName = name or _self.get_unused_name("exposed")
|
|
_self.select(selName, '?%s in ?%s' % (tmpObj, tmpSel))
|
|
|
|
_self.set("dot_solvent", 1, tmpObj);
|
|
_self.get_area(selName, load_b=1)
|
|
|
|
cutoff = float(cutoff)
|
|
if cutoff < 0.0:
|
|
cutoff = _self.get_setting_float("surface_residue_cutoff")
|
|
|
|
_self.select(selName, '?%s in (?%s and b > %f)' % (tmpSel, selName, cutoff))
|
|
_self.delete(tmpObj)
|
|
_self.delete(tmpSel)
|
|
|
|
return selName
|
|
|
|
|
|
def get_area(sele, state=-1, dot_solvent=0, dot_density=5, quiet=1, _self=cmd):
|
|
'''
|
|
DESCRIPTION
|
|
|
|
Wrapper for cmd.get_area that works on a copy of the selected object
|
|
to set dot_solvent and dot_density.
|
|
|
|
SEE ALSO
|
|
|
|
get_area command, dot_solvent and dot_density settings
|
|
'''
|
|
state, dot_density, quiet = int(state), int(dot_density), int(quiet)
|
|
|
|
tmpSel = _self.get_unused_name("_sel")
|
|
_self.select(tmpSel, sele, 0)
|
|
|
|
if state < 1:
|
|
state = _self.get_selection_state(tmpSel)
|
|
|
|
tmpObj = _self.get_unused_name("_tmp")
|
|
_self.create(tmpObj, "(byobj ?%s) & ! solvent" % (tmpSel), state, zoom=0)
|
|
_self.select(tmpSel, '?%s in ?%s' % (tmpObj, tmpSel), 0)
|
|
|
|
_self.set("dot_solvent", dot_solvent, tmpObj);
|
|
if dot_density > -1:
|
|
_self.set('dot_density', dot_density, tmpObj)
|
|
|
|
r = _self.get_area(tmpSel, quiet=int(quiet))
|
|
|
|
_self.delete(tmpSel)
|
|
_self.delete(tmpObj)
|
|
|
|
return r
|
|
|
|
|
|
def get_sasa(sele, state=-1, dot_density=5, quiet=1, _self=cmd):
|
|
'''
|
|
DESCRIPTION
|
|
|
|
Get solvent accesible surface area
|
|
|
|
SEE ALSO
|
|
|
|
get_area command, dot_solvent and dot_density settings
|
|
'''
|
|
return get_area(sele, state, 1, dot_density, quiet, _self)
|
|
|
|
|
|
def mass_align(target,enabled_only=0,max_gap=50,_self=cmd):
|
|
cmd=_self
|
|
list = cmd.get_names("public_objects",int(enabled_only))
|
|
[x for x in list if cmd.get_type(x)!="object:molecule"]
|
|
if enabled_only:
|
|
aln_object = 'aln_enabled_to'+target
|
|
else:
|
|
aln_object = 'aln_all_to_'+target
|
|
cmd.delete(aln_object)
|
|
for name in list:
|
|
if name!=target:
|
|
if cmd.count_atoms("(%s) and (%s)"%(target,name))==0:
|
|
cmd.align('polymer and name CA and (%s)'%name,
|
|
'polymer and name CA and (%s)'%target,max_gap=max_gap,quiet=0,
|
|
object=aln_object)
|
|
|
|
def sum_formal_charges(selection="(all)",quiet=1,_self=cmd):
|
|
_util_sum_fc = [0]
|
|
_self.iterate(selection, "_util_sum_fc[0] += formal_charge", space=locals())
|
|
result = _util_sum_fc[0]
|
|
if not int(quiet):
|
|
print(" util.sum_formal_charges: %d" % result)
|
|
return result
|
|
|
|
def sum_partial_charges(selection="(all)",quiet=1,_self=cmd):
|
|
_util_sum_pc = [0.0]
|
|
_self.iterate(selection, "_util_sum_pc[0] += partial_charge", space=locals())
|
|
result = _util_sum_pc[0]
|
|
if not int(quiet):
|
|
print(" util.sum_partial_charges: sum = %0.4f"%result)
|
|
return result
|
|
|
|
def compute_mass(selection="(all)",state=-1,implicit=False,quiet=1,_self=cmd):
|
|
"""
|
|
DESCRIPTION
|
|
|
|
"compute_mass" calculates the atomic mass of a selection
|
|
(in atomic mass units).
|
|
|
|
USAGE
|
|
|
|
compute_mass [ selection [, state [, implicit [, quiet ]]]]
|
|
|
|
ARGUMENTS
|
|
|
|
selection = selection, defaults to '(all)'
|
|
|
|
state = object state, defaults to current state for each given
|
|
object. See notes.
|
|
|
|
implicit = if false then only calculate masses exactly as
|
|
in the objects; if true, then add hydrogens were
|
|
possible before calculating mass
|
|
|
|
EXAMPLES
|
|
|
|
print util.compute_mass("all")
|
|
|
|
m = util.compute_mass("organic",state=4,implicit=True)
|
|
|
|
NOTES
|
|
|
|
If the state argument is specified and an object does not exist
|
|
in that state, the 0 atoms will be counted for that object,
|
|
thus resulting in a zero mass for that object.
|
|
|
|
"""
|
|
result = 0.0
|
|
for obj in _self.get_object_list(selection):
|
|
if state==-1:
|
|
state = _self.get("state",obj)
|
|
m = _self.get_model(selection + " and " + obj,state)
|
|
if len(m.atom)==0:
|
|
print(" Warning: No atoms in state %d for object %s" % (state,obj))
|
|
if implicit!=False:
|
|
result += m.get_implicit_mass()
|
|
else:
|
|
result += m.get_mass()
|
|
if not quiet:
|
|
print(" util.compute_mass: mass = %0.4f u"%result)
|
|
return result
|
|
|
|
def protein_assign_charges_and_radii(obj_name,_self=cmd):
|
|
cmd=_self
|
|
|
|
from chempy.champ import assign
|
|
|
|
# apply a few kludges
|
|
|
|
# convent Seleno-methionine to methionine
|
|
|
|
cmd.alter(obj_name+"///MSE/SE","elem='S';name='SD'",quiet=1)
|
|
cmd.alter(obj_name+"///MSE/","resn='MET'",quiet=1)
|
|
cmd.flag("ignore",obj_name,"clear")
|
|
|
|
# remove alternate conformers
|
|
|
|
cmd.remove(obj_name+" and not alt ''+A")
|
|
cmd.alter(obj_name,"alt=''")
|
|
cmd.sort(obj_name)
|
|
cmd.fix_chemistry(obj_name,obj_name,1)
|
|
|
|
# make sure all atoms are included...
|
|
cmd.alter(obj_name,"q=1.0",quiet=1)
|
|
|
|
print(" Util: Fixing termini and assigning formal charges...")
|
|
|
|
assign.missing_c_termini(obj_name,quiet=1,_self=_self)
|
|
|
|
while not assign.formal_charges(obj_name,quiet=1,_self=_self):
|
|
print(" WARNING: unrecognized or incomplete residues are being deleted:")
|
|
cmd.iterate("(byres ("+obj_name+" and flag 23)) and flag 31",
|
|
'print(" "+model+"/"+segi+"/"+chain+"/"+resn+"`"+resi+"/")',quiet=1)
|
|
cmd.remove("byres ("+obj_name+" and flag 23)") # get rid of residues that weren't assigned
|
|
assign.missing_c_termini(obj_name,quiet=1,_self=_self)
|
|
|
|
print(" Util: Assigning Amber 99 charges and radii...")
|
|
|
|
cmd.h_add(obj_name)
|
|
if not assign.amber99(obj_name,quiet=1,_self=_self):
|
|
print(" WARNING: some unassigned atoms are being deleted:")
|
|
cmd.iterate("byres ("+obj_name+" and flag 23)",
|
|
'print(" "+model+"/"+segi+"/"+chain+"/"+resn+"`"+resi+"/"+name+"? ["+elem+"]")',quiet=1)
|
|
cmd.remove(obj_name+" and flag 23") # get rid of any atoms that weren't assigned
|
|
|
|
# show the user what the net charges are...
|
|
|
|
formal = sum_formal_charges(obj_name,quiet=0,_self=_self)
|
|
partial = sum_partial_charges(obj_name,quiet=0,_self=_self)
|
|
if round(formal)!=round(partial):
|
|
print(" WARNING: formal and partial charge sums don't match -- there is a problem!")
|
|
|
|
def protein_vacuum_esp(selection, mode=2, border=10.0, quiet = 1, _self=cmd):
|
|
cmd=_self
|
|
|
|
if (selection.split() != [selection] or
|
|
selection not in cmd.get_names('objects')):
|
|
print(" Error: must provide an object name")
|
|
raise cmd.QuietException
|
|
obj_name = selection + "_e_chg"
|
|
map_name = selection + "_e_map"
|
|
pot_name = selection + "_e_pot"
|
|
cmd.disable(selection)
|
|
cmd.delete(obj_name)
|
|
cmd.delete(map_name)
|
|
cmd.delete(pot_name)
|
|
cmd.create(obj_name,"((polymer and ("+selection+
|
|
") and (not resn A+C+T+G+U)) or ((bymol (polymer and ("+
|
|
selection+"))) and resn NME+NHE+ACE)) and (not hydro)")
|
|
# try to just get protein...
|
|
|
|
protein_assign_charges_and_radii(obj_name,_self=_self)
|
|
|
|
ext = cmd.get_extent(obj_name)
|
|
max_length = max(abs(ext[0][0] - ext[1][0]),abs(ext[0][1] - ext[1][1]),abs(ext[0][2]-ext[1][2])) + 2*border
|
|
|
|
# compute an grid with a maximum dimension of 50, with 10 A borders around molecule, and a 1.0 A minimum grid
|
|
|
|
sep = max_length/50.0
|
|
if sep<1.0: sep = 1.0
|
|
print(" Util: Calculating electrostatic potential...")
|
|
if mode==0: # absolute, no cutoff
|
|
cmd.map_new(map_name,"coulomb",sep,obj_name,border)
|
|
elif mode==1: # neutral, no cutoff
|
|
cmd.map_new(map_name,"coulomb_neutral",sep,obj_name,border)
|
|
else: # local, with cutoff
|
|
cmd.map_new(map_name,"coulomb_local",sep,obj_name,border)
|
|
|
|
cmd.ramp_new(pot_name, map_name, selection=obj_name,zero=1)
|
|
cmd.hide("everything",obj_name)
|
|
cmd.show("surface",obj_name)
|
|
cmd.set("surface_color",pot_name,obj_name)
|
|
cmd.set("surface_ramp_above_mode",1,obj_name)
|
|
|
|
def color_carbon(color,selection="(all)",_self=cmd):
|
|
cmd=_self
|
|
selection = str(selection)
|
|
cmd.color(color,"(%s) and elem C"%selection)
|
|
|
|
def cbss(selection="(all)",helix_color="red",sheet_color="yellow",loop_color="green",quiet=1,_self=cmd):
|
|
cmd=_self
|
|
sel = str(selection)
|
|
h = str(helix_color)
|
|
s = str(sheet_color)
|
|
l = str(loop_color)
|
|
cmd.color(h,"(ss H and ("+sel+"))",quiet=quiet)
|
|
cmd.color(s,"(ss S and ("+sel+"))",quiet=quiet)
|
|
cmd.color(l,"((not (ss S+H)) and ("+sel+"))",quiet=quiet)
|
|
|
|
def cbag(selection="(all)",quiet=1,_self=cmd):
|
|
'''Wrapper around "color atomic"'''
|
|
cmd=_self
|
|
s = str(selection)
|
|
cmd.color("atomic","(("+s+") and not elem C)",quiet=quiet)
|
|
cmd.color("carbon","(elem C and ("+s+"))",quiet=quiet)
|
|
|
|
def cbac(selection="(all)",quiet=1,_self=cmd):
|
|
'''Wrapper around "color atomic"'''
|
|
cmd=_self
|
|
s = str(selection)
|
|
cmd.color("atomic","(("+s+") and not elem C)",quiet=quiet)
|
|
cmd.color("cyan","(elem C and ("+s+"))",quiet=quiet)
|
|
|
|
def cbam(selection="(all)",quiet=1,_self=cmd):
|
|
'''Wrapper around "color atomic"'''
|
|
cmd=_self
|
|
s = str(selection)
|
|
cmd.color("atomic","(("+s+") and not elem C)",quiet=quiet)
|
|
cmd.color("lightmagenta","(elem C and ("+s+"))",quiet=quiet)
|
|
|
|
def cbay(selection="(all)",quiet=1,_self=cmd):
|
|
'''Wrapper around "color atomic"'''
|
|
cmd=_self
|
|
s = str(selection)
|
|
cmd.color("atomic","(("+s+") and not elem C)",quiet=quiet)
|
|
cmd.color("yellow","(elem C and ("+s+"))",quiet=quiet)
|
|
|
|
def cbas(selection="(all)",quiet=1,_self=cmd):
|
|
'''Wrapper around "color atomic"'''
|
|
cmd=_self
|
|
s = str(selection)
|
|
cmd.color("atomic","(("+s+") and not elem C)",quiet=quiet)
|
|
cmd.color("salmon","(elem C and ("+s+"))",quiet=quiet)
|
|
|
|
def cbaw(selection="(all)",quiet=1,_self=cmd):
|
|
'''Wrapper around "color atomic"'''
|
|
cmd=_self
|
|
s = str(selection)
|
|
cmd.color("atomic","(("+s+") and not elem C)",quiet=quiet)
|
|
cmd.color("hydrogen","(elem C and ("+s+"))",quiet=quiet)
|
|
|
|
def cbab(selection="(all)",quiet=1,_self=cmd):
|
|
'''Wrapper around "color atomic"'''
|
|
cmd=_self
|
|
s = str(selection)
|
|
cmd.color("atomic","(("+s+") and not elem C)",quiet=quiet)
|
|
cmd.color("slate","(elem C and ("+s+"))",quiet=quiet)
|
|
|
|
def cbao(selection="(all)",quiet=1,_self=cmd):
|
|
'''Wrapper around "color atomic"'''
|
|
cmd=_self
|
|
s = str(selection)
|
|
cmd.color("atomic","(("+s+") and not elem C)",quiet=quiet)
|
|
cmd.color("brightorange","(elem C and ("+s+"))",quiet=quiet)
|
|
|
|
def cbap(selection="(all)",quiet=1,_self=cmd):
|
|
'''Wrapper around "color atomic"'''
|
|
cmd=_self
|
|
s = str(selection)
|
|
cmd.color("atomic","(("+s+") and not elem C)",quiet=quiet)
|
|
cmd.color("purple","(elem C and ("+s+"))",quiet=quiet)
|
|
|
|
def cbak(selection="(all)",quiet=1,_self=cmd):
|
|
'''Wrapper around "color atomic"'''
|
|
cmd=_self
|
|
s = str(selection)
|
|
cmd.color("atomic","(("+s+") and not elem C)",quiet=quiet)
|
|
cmd.color("pink","(elem C and ("+s+"))",quiet=quiet)
|
|
|
|
def cnc(selection="(all)",quiet=1,_self=cmd):
|
|
'''Wrapper around "color atomic"'''
|
|
cmd=_self
|
|
s = str(selection)
|
|
cmd.color("atomic","(("+s+") and not elem C)",quiet=quiet)
|
|
|
|
def cba(color,selection="(all)",quiet=1,_self=cmd):
|
|
'''Wrapper around "color atomic"'''
|
|
cmd=_self
|
|
s = str(selection)
|
|
cmd.color("atomic","(("+s+") and not elem C)",quiet=quiet)
|
|
cmd.color(color,"(elem C and ("+s+"))",quiet=quiet)
|
|
cmd.color(color,s,flags=1,quiet=quiet)
|
|
|
|
def cbh(color,selection="(all)",quiet=1,_self=cmd):
|
|
'''Wrapper around "color atomic"'''
|
|
cmd=_self
|
|
s = str(selection)
|
|
cmd.color("atomic","(("+s+") and not elem H)",quiet=quiet)
|
|
cmd.color(color,"(elem H and ("+s+"))",quiet=quiet)
|
|
cmd.color(color,s,flags=1,quiet=quiet)
|
|
|
|
def enable_all_shaders(_self=cmd):
|
|
"""
|
|
Turns on shaders for all representations
|
|
"""
|
|
cmd=_self
|
|
cmd.set("use_shaders",1)
|
|
cmd.set("cartoon_use_shader",1)
|
|
cmd.set("cgo_use_shader",1)
|
|
cmd.set("dash_use_shader",1)
|
|
cmd.set("dot_use_shader",1)
|
|
cmd.set("line_use_shader",1)
|
|
cmd.set("mesh_use_shader",1)
|
|
cmd.set("nb_spheres_use_shader", 1)
|
|
cmd.set("nonbonded_use_shader",1)
|
|
cmd.set("ribbon_use_shader", 1)
|
|
cmd.set("sphere_use_shader", 1)
|
|
cmd.set("stick_use_shader",1)
|
|
cmd.set("surface_use_shader",1)
|
|
|
|
def modernize_rendering(mode,_self=cmd):
|
|
"""
|
|
Turns on shaders for all representations and
|
|
updates settings to improve rendering speed
|
|
and quality.
|
|
"""
|
|
cmd = _verbose_cmd_proxy(_self)
|
|
|
|
cmd.set("max_ups",0)
|
|
|
|
enable_all_shaders(cmd)
|
|
|
|
cmd.set("stick_ball", 0)
|
|
cmd.set("stick_as_cylinders", 1)
|
|
cmd.set("sphere_mode", 9)
|
|
|
|
cmd.do("_ rebuild")
|
|
|
|
def performance(mode,_self=cmd):
|
|
cmd = _verbose_cmd_proxy(_self)
|
|
mode = int(mode)
|
|
if mode==0: # maximum quality
|
|
cmd.set('line_smooth',1)
|
|
cmd.set('depth_cue',1)
|
|
cmd.set('specular',1)
|
|
cmd.set('surface_quality',1)
|
|
cmd.set('cartoon_sampling',14)
|
|
cmd.set('ribbon_sampling',10)
|
|
cmd.set('transparency_mode',2)
|
|
# new rendering
|
|
if cmd.get_setting_int("use_shaders")==1:
|
|
enable_all_shaders(cmd)
|
|
# as cylinderss
|
|
cmd.set("render_as_cylinders", 1)
|
|
cmd.set("alignment_as_cylinders", 1)
|
|
cmd.set("cartoon_nucleic_acid_as_cylinders", 1)
|
|
cmd.set("dash_as_cylinders", 1)
|
|
cmd.set("line_as_cylinders", 1)
|
|
cmd.set("mesh_as_cylinders", 1)
|
|
cmd.set("nonbonded_as_cylinders", 1)
|
|
cmd.set("ribbon_as_cylinders", 1)
|
|
cmd.set("stick_as_cylinders", 1)
|
|
# as spheres
|
|
cmd.set("dot_as_spheres", 1)
|
|
|
|
# special settings
|
|
# sticks
|
|
cmd.set("stick_ball", 0)
|
|
# spheres
|
|
cmd.set("sphere_mode", 9)
|
|
# nb_spheres
|
|
cmd.set("nb_spheres_quality", 3)
|
|
|
|
# old rendering
|
|
if cmd.get_setting_int("use_shaders")==0:
|
|
cmd.set('stick_quality',15)
|
|
cmd.set('sphere_quality',2)
|
|
cmd.set('stick_ball',1)
|
|
elif mode==33:
|
|
cmd.set('line_smooth',1)
|
|
cmd.set('depth_cue',1)
|
|
cmd.set('specular',1)
|
|
cmd.set('surface_quality',0)
|
|
cmd.set('cartoon_sampling',7)
|
|
cmd.set('ribbon_sampling',1)
|
|
cmd.set('transparency_mode',2)
|
|
# new rendering
|
|
if cmd.get_setting_int("use_shaders")==1:
|
|
enable_all_shaders(cmd)
|
|
# as cylinderss
|
|
cmd.set("render_as_cylinders", 1)
|
|
cmd.set("alignment_as_cylinders", 1)
|
|
cmd.set("cartoon_nucleic_acid_as_cylinders", 1)
|
|
cmd.set("dash_as_cylinders", 1)
|
|
cmd.set("line_as_cylinders", 1)
|
|
cmd.set("mesh_as_cylinders", 1)
|
|
cmd.set("nonbonded_as_cylinders", 1)
|
|
cmd.set("ribbon_as_cylinders", 1)
|
|
cmd.set("stick_as_cylinders", 1)
|
|
# as spheres
|
|
cmd.set("dot_as_spheres", 1)
|
|
|
|
# special settings
|
|
# sticks
|
|
cmd.set("stick_ball", 0)
|
|
# spheres
|
|
cmd.set("sphere_mode", 9)
|
|
# nb_spheres
|
|
cmd.set("nb_spheres_quality", 3)
|
|
|
|
# old rendering
|
|
if cmd.get_setting_int("use_shaders")==0:
|
|
cmd.set('stick_quality',8)
|
|
cmd.set('sphere_quality',1)
|
|
cmd.set('stick_ball',1)
|
|
|
|
elif mode==66: # good perfomance
|
|
cmd.set('line_smooth',0)
|
|
cmd.set('depth_cue',0)
|
|
cmd.set('specular',1)
|
|
cmd.set('surface_quality',0)
|
|
cmd.set('cartoon_sampling',6)
|
|
cmd.set('ribbon_sampling',1)
|
|
cmd.set('transparency_mode',2)
|
|
# new rendering
|
|
if cmd.get_setting_int("use_shaders")==1:
|
|
enable_all_shaders(cmd)
|
|
# as cylinderss
|
|
cmd.set("render_as_cylinders", 1)
|
|
cmd.set("alignment_as_cylinders", 0)
|
|
cmd.set("cartoon_nucleic_acid_as_cylinders", 0)
|
|
cmd.set("dash_as_cylinders", 0)
|
|
cmd.set("line_as_cylinders", 0)
|
|
cmd.set("mesh_as_cylinders", 0)
|
|
cmd.set("nonbonded_as_cylinders", 0)
|
|
cmd.set("ribbon_as_cylinders", 0)
|
|
cmd.set("stick_as_cylinders", 1)
|
|
# as spheres
|
|
cmd.set("dot_as_spheres", 0)
|
|
|
|
# special settings
|
|
# sticks
|
|
cmd.set("stick_ball", 0)
|
|
# spheres
|
|
cmd.set("sphere_mode", 9)
|
|
# nb_spheres
|
|
cmd.set("nb_spheres_quality", 3)
|
|
# old rendering
|
|
if cmd.get_setting_int("use_shaders")==0:
|
|
cmd.set('stick_quality',8)
|
|
cmd.set('sphere_quality',1)
|
|
cmd.set('stick_ball',0)
|
|
|
|
else: # maximum performance
|
|
cmd.set('line_smooth',0)
|
|
cmd.set('depth_cue',0)
|
|
cmd.set('specular',0)
|
|
cmd.set('surface_quality',-1) # new
|
|
cmd.set('stick_quality',5)
|
|
cmd.set('sphere_quality',0)
|
|
cmd.set('ribbon_sampling',1)
|
|
cmd.set('cartoon_sampling',3)
|
|
cmd.set('transparency_mode',0)
|
|
cmd.set('max_ups',0)
|
|
# new rendering
|
|
if cmd.get_setting_int("use_shaders")==1:
|
|
enable_all_shaders(cmd)
|
|
# as cylinderss
|
|
cmd.set("render_as_cylinders", 1)
|
|
cmd.set("alignment_as_cylinders", 0)
|
|
cmd.set("cartoon_nucleic_acid_as_cylinders", 0)
|
|
cmd.set("dash_as_cylinders", 0)
|
|
cmd.set("line_as_cylinders", 0)
|
|
cmd.set("mesh_as_cylinders", 0)
|
|
cmd.set("nonbonded_as_cylinders", 0)
|
|
cmd.set("ribbon_as_cylinders", 0)
|
|
cmd.set("stick_as_cylinders", 1)
|
|
# as spheres
|
|
cmd.set("dot_as_spheres", 0)
|
|
# old rendering
|
|
if cmd.get_setting_int("use_shaders")==0:
|
|
cmd.set('stick_quality',5)
|
|
cmd.set('sphere_quality',0)
|
|
cmd.set('stick_ball',0)
|
|
|
|
cmd.do("rebuild")
|
|
|
|
|
|
def label_chains(sele="all",_self=cmd):
|
|
pymol=_self._pymol
|
|
cmd=_self
|
|
pymol.stored._cs = []
|
|
last = None
|
|
save = ()
|
|
list = []
|
|
cmd.iterate(sele,"stored._cs.append((model,chain,index))")
|
|
for a in pymol.stored._cs:
|
|
if (a[0:2]!=save):
|
|
list.append(last)
|
|
list.append(a)
|
|
save = a[0:2]
|
|
last = a
|
|
if len(list):
|
|
list.append(last)
|
|
list = [_f for _f in list if _f]
|
|
for a in list:
|
|
if(a[1]==''):
|
|
cmd.label("%s`%d"%(a[0],a[2]),'''"chain ''"''',quiet=1)
|
|
elif(a[1]==' '):
|
|
cmd.label("%s`%d"%(a[0],a[2]),'''"chain ' '"''',quiet=1)
|
|
else:
|
|
cmd.label("%s`%d"%(a[0],a[2]),"'chain '+chain",quiet=1)
|
|
|
|
def label_segments(sele="all",_self=cmd):
|
|
pymol=_self._pymol
|
|
cmd=_self
|
|
pymol.stored._cs = []
|
|
last = None
|
|
save = ()
|
|
list = []
|
|
cmd.iterate(sele,"stored._cs.append((model,segi,index))")
|
|
for a in pymol.stored._cs:
|
|
if (a[0:2]!=save):
|
|
list.append(last)
|
|
list.append(a)
|
|
save = a[0:2]
|
|
last = a
|
|
if len(list):
|
|
list.append(last)
|
|
list = [_f for _f in list if _f]
|
|
for a in list:
|
|
if(a[1]==''):
|
|
cmd.label("%s`%d"%(a[0],a[2]),'''"segi ''"''',quiet=1)
|
|
elif(a[1]==' '):
|
|
cmd.label("%s`%d"%(a[0],a[2]),'''"segi ' '"''',quiet=1)
|
|
else:
|
|
cmd.label("%s`%d"%(a[0],a[2]),"'segi '+segi",quiet=1)
|
|
|
|
def cbc(selection='(all)',first_color=7,quiet=1,legacy=0,_self=cmd):
|
|
'''
|
|
Color all chains a different color
|
|
'''
|
|
legacy = int(legacy)
|
|
for c, a in enumerate(_self.get_chains(selection)):
|
|
if len(a.split()) != 1:
|
|
a = '"' + a + '"'
|
|
if legacy:
|
|
color = c + int(first_color)
|
|
else:
|
|
color = _color_cycle[c % _color_cycle_len]
|
|
if not quiet:
|
|
print(" util.cbc: color %s, (chain %s)" % (color, a))
|
|
_self.color(color, "(chain %s and (%s))" % (a, selection), quiet=quiet)
|
|
|
|
def color_objs(selection='all', quiet=1, _self=cmd):
|
|
cmd=_self
|
|
'''
|
|
Color all objects a different color
|
|
'''
|
|
c = 0
|
|
for a in cmd.get_names('public_nongroup_objects',selection=selection):
|
|
if (selection!='all') and (selection!='(all)'):
|
|
cmd.set_object_color(a, _color_cycle[c])
|
|
cmd.color(_color_cycle[c],"(?%s and (%s))"%(a,selection),quiet=quiet)
|
|
else:
|
|
cmd.color(_color_cycle[c], a, quiet=quiet)
|
|
c = (c + 1) % _color_cycle_len
|
|
|
|
def color_deep(color, name='all', quiet=1, _self=cmd):
|
|
'''
|
|
Unset all object and atom level (not global) color settings and
|
|
apply given color.
|
|
'''
|
|
print(' util.color_deep: Deprecated, use cmd.color_deep() instead')
|
|
_self.color_deep(color, name, quiet)
|
|
|
|
def chainbow(selection='(all)', palette="rainbow", quiet=1, _self=cmd):
|
|
'''
|
|
Color all chains in rainbow
|
|
'''
|
|
for model in _self.get_object_list('(' + selection + ')'):
|
|
for a in _self.get_chains('model %s & (%s)' % (model, selection)) or ['']:
|
|
_self.spectrum('count', palette,
|
|
"(chain '%s' & model %s & (%s))" % (a, model, selection),
|
|
byres=1, quiet=quiet)
|
|
|
|
color_chains = cbc
|
|
|
|
def ray_shadows(mode,_self=cmd):
|
|
cmd = _verbose_cmd_proxy(_self)
|
|
# adjustment factors for new lighting model in 0.99
|
|
if mode=='none':
|
|
cmd.set('ray_shadow',0)
|
|
else:
|
|
cmd.set('ray_shadow',1)
|
|
if mode=='light':
|
|
cmd.set('light_count',2)
|
|
cmd.set("light","[-0.4,-0.4,-1.0]")
|
|
cmd.set('ambient',0.14)
|
|
cmd.set('direct',0.65)
|
|
cmd.set('reflect',0.25)
|
|
cmd.set('shininess',40)
|
|
cmd.set('power',1.0)
|
|
cmd.set('specular_intensity',0.5)
|
|
cmd.set('spec_direct',0)
|
|
cmd.set('spec_count',-1)
|
|
cmd.set('ray_shadow_decay_factor',0)
|
|
elif mode=='matte':
|
|
cmd.set('light_count',4)
|
|
cmd.set("light","[-0.4,-0.4,-1.0]")
|
|
cmd.set("light2","[-0.3,-0.4,-1.0]")
|
|
cmd.set("light3","[-0.3,-0.3,-1.0]")
|
|
cmd.set("light4","[-0.4,-0.3,-1.0]")
|
|
cmd.set('ambient',0.14)
|
|
cmd.set('direct',0.45)
|
|
cmd.set('reflect',0.45)
|
|
cmd.set('shininess',25)
|
|
cmd.set('power',1.25)
|
|
cmd.set('spec_count',-1)
|
|
cmd.set('specular_intensity',0.2)
|
|
cmd.set('spec_direct',0)
|
|
cmd.set('ray_shadow_decay_factor',0)
|
|
elif mode=='soft':
|
|
cmd.set('light_count',10)
|
|
cmd.set("light","[-0.4,-0.4,-1.0]")
|
|
cmd.set("light2","[-0.3,-0.4,-1.0]")
|
|
cmd.set("light3","[-0.3,-0.3,-1.0]")
|
|
cmd.set("light4","[-0.4,-0.3,-1.0]")
|
|
cmd.set("light5","[-0.4,-0.5,-1.0]")
|
|
cmd.set("light6","[-0.5,-0.5,-1.0]")
|
|
cmd.set("light7","[-0.5,-0.4,-1.0]")
|
|
cmd.set("light8","[-0.5,-0.3,-1.0]")
|
|
cmd.set("light9","[-0.3,-0.5,-1.0]")
|
|
cmd.set('ambient',0.14)
|
|
cmd.set('direct',0.40)
|
|
cmd.set('reflect',0.50)
|
|
cmd.set('specular_intensity',0.5)
|
|
cmd.set('spec_count',1)
|
|
cmd.set('shininess',55)
|
|
cmd.set('power',1.0)
|
|
cmd.set('spec_direct',0)
|
|
cmd.set('ray_shadow_decay_factor',0.1)
|
|
cmd.set('ray_shadow_decay_range',1.8)
|
|
elif mode=='occlusion':
|
|
cmd.set('light_count',9)
|
|
cmd.set("light" ,"[-0.2,-0.2,-1.0]")
|
|
cmd.set("light2","[-0.2, 0.0,-1.0]")
|
|
cmd.set("light3","[-0.2, 0.2,-1.0]")
|
|
cmd.set("light4","[ 0.0, 0.2,-1.0]")
|
|
cmd.set("light5","[ 0.2, 0.2,-1.0]")
|
|
cmd.set("light6","[ 0.2, 0.0,-1.0]")
|
|
cmd.set("light7","[ 0.2,-0.2,-1.0]")
|
|
cmd.set("light8","[ 0.0,-0.2,-1.0]")
|
|
cmd.set('ambient',0.18)
|
|
cmd.set('direct',0.10)
|
|
cmd.set('reflect',0.80)
|
|
cmd.set('shininess',10)
|
|
cmd.set('spec_count',-1)
|
|
cmd.set('power',1.0)
|
|
cmd.set('specular_intensity',0)
|
|
cmd.set('spec_direct',0.25)
|
|
cmd.set('ray_shadow_decay_factor',0.1)
|
|
cmd.set('ray_shadow_decay_range',5.0)
|
|
elif mode=="occlusion2":
|
|
cmd.set('light_count',2)
|
|
cmd.set("light","[-0.4,-0.4,-1.0]")
|
|
cmd.set('ambient',0.14)
|
|
cmd.set('direct',0.45)
|
|
cmd.set('reflect',0.45)
|
|
cmd.set('shininess',55)
|
|
cmd.set('spec_count',-1)
|
|
cmd.set('power',1.0)
|
|
cmd.set('specular_intensity',0.5)
|
|
cmd.set('spec_direct',0)
|
|
cmd.set('ray_shadow_decay_factor',0)
|
|
cmd.set('ambient_occlusion_mode', 1)
|
|
elif mode=='medium':
|
|
cmd.set('light_count',2)
|
|
cmd.set("light","[-0.4,-0.4,-1.0]")
|
|
cmd.set('ambient',0.14)
|
|
cmd.set('direct',0.45)
|
|
cmd.set('reflect',0.45)
|
|
cmd.set('shininess',55)
|
|
cmd.set('spec_count',-1)
|
|
cmd.set('power',1.0)
|
|
cmd.set('specular_intensity',0.5)
|
|
cmd.set('spec_direct',0)
|
|
cmd.set('ray_shadow_decay_factor',0)
|
|
elif mode=='heavy':
|
|
cmd.set('light_count',2)
|
|
cmd.set("light","[-0.4,-0.4,-1.0]")
|
|
cmd.set('ambient',0.05)
|
|
cmd.set('direct',0.20)
|
|
cmd.set('reflect',0.85)
|
|
cmd.set('spec_count',-1)
|
|
cmd.set('shininess',90)
|
|
cmd.set('power',1.0)
|
|
cmd.set('specular_intensity',0.5)
|
|
cmd.set('spec_direct',0)
|
|
cmd.set('ray_shadow_decay_factor',0)
|
|
elif mode=='black': # best for light backgrounds
|
|
cmd.set('light_count',2)
|
|
cmd.set("light","[-0.4,-0.4,-1.0]")
|
|
cmd.set('ambient',0.001)
|
|
cmd.set('direct',0.0)
|
|
cmd.set('reflect',1.1)
|
|
cmd.set('spec_count',-1)
|
|
cmd.set('power',1.0)
|
|
cmd.set('shininess',90)
|
|
cmd.set('specular_intensity',0.5)
|
|
cmd.set('spec_direct',0)
|
|
cmd.set('ray_shadow_decay_factor',0)
|
|
|
|
def ff_copy(src,dst,_self=cmd):
|
|
pymol=_self._pymol
|
|
cmd=_self # NOT THREAD SAFE
|
|
pymol._rcopy = pymol.Scratch_Storage()
|
|
pymol._rcopy.pc={}
|
|
pymol._rcopy.tt={}
|
|
cmd.iterate("(%s)"%src,"_rcopy.pc[name]=partial_charge")
|
|
cmd.alter("(%s)"%dst,"partial_charge=_rcopy.pc[name]")
|
|
cmd.iterate("(%s)"%src,"_rcopy.tt[name]=text_type")
|
|
cmd.alter("(%s)"%dst,"text_type=_rcopy.tt[name]")
|
|
del pymol._rcopy
|
|
|
|
def b2vdw(selection='all', _self=cmd):
|
|
# use B values to create RMS VDW spheres
|
|
# rms = sqrt(b/(8*(PI^2)))
|
|
_self.alter(selection, "vdw=(b/78.9568352087)**0.5")
|
|
|
|
def phipsi(selection="(pk1)",_self=cmd):
|
|
cmd=_self # NOT THREAD SAFE
|
|
n_sele = "((byres (%s)) & name N)"%selection
|
|
c_sele = "((byres (%s)) & name C)"%selection
|
|
ca_sele = "((byres (%s)) & name CA)"%selection
|
|
cm_sele = "((neighbor (%s)) and not (byres (%s)))"%(n_sele,n_sele)
|
|
np_sele = "((neighbor (%s)) and not (byres (%s)))"%(c_sele,c_sele)
|
|
cmd.feedback("push")
|
|
cmd.feedback("disable","selector","everythin")
|
|
cm_cnt = cmd.select("_pp_cm",cm_sele)
|
|
n_cnt = cmd.select("_pp_n",n_sele)
|
|
c_cnt = cmd.select("_pp_c",c_sele)
|
|
ca_cnt = cmd.select("_pp_ca",ca_sele)
|
|
np_cnt = cmd.select("_pp_np",np_sele)
|
|
if(cm_cnt and n_cnt and ca_cnt and c_cnt):
|
|
phi = cmd.get_dihedral("_pp_c","_pp_ca","_pp_n","_pp_cm")
|
|
else:
|
|
phi = None
|
|
if(n_cnt and ca_cnt and c_cnt and np_cnt):
|
|
psi = cmd.get_dihedral("_pp_np","_pp_c","_pp_ca","_pp_n")
|
|
else:
|
|
psi = None
|
|
cmd.feedback("pop")
|
|
cmd.delete("_pp_cm")
|
|
cmd.delete("_pp_n")
|
|
cmd.delete("_pp_c")
|
|
cmd.delete("_pp_ca")
|
|
cmd.delete("_pp_np")
|
|
return (phi,psi)
|
|
|
|
def rainbow(selection="(name CA and alt ''+A)",reverse=0,_self=cmd):
|
|
'''
|
|
Legacy spectrum coloring routine. Don't use.
|
|
|
|
Use instead: spectrum
|
|
'''
|
|
print(' util.rainbow: Deprecated, use cmd.spectrum() instead')
|
|
list = [
|
|
(0,0,255),
|
|
(0,0,255),
|
|
(0,128,255),
|
|
(0,255,255),
|
|
(0,255,128),
|
|
(0,255,0),
|
|
(128,255,0),
|
|
(255,255,0),
|
|
(255,128,0),
|
|
(255,0,0),
|
|
(255,0,0)
|
|
]
|
|
if reverse:
|
|
list.reverse()
|
|
list = ['0x%02x%02x%02x' % rgb for rgb in list]
|
|
_self.spectrum('count', ' '.join(list), selection)
|
|
|
|
|
|
def ss(selection="(name CA and alt '',A)",state=1,_self=cmd):
|
|
'''
|
|
Legacy secondary structure assignment routine. Don't use.
|
|
|
|
Use instead: dss
|
|
'''
|
|
print(' util.ss: Deprecated, use cmd.dss() instead')
|
|
_self.dss(selection, state)
|
|
|
|
|
|
def colors(scheme="",_self=cmd):
|
|
cmd=_self
|
|
if scheme=="jmol":
|
|
cmd.set("auto_color",0)
|
|
cmd.set_color("hydrogen",[1.000,1.000,1.000])
|
|
cmd.set_color("carbon",[0.567,0.567,0.567])
|
|
cmd.set_color("nitrogen",[0.189,0.315,0.976])
|
|
cmd.set_color("oxygen",[1.000,0.051,0.051])
|
|
cmd.set_color("fluorine",[0.567,0.882,0.314])
|
|
cmd.set_color("sulfur",[1.000,1.000,0.189])
|
|
cmd.color("carbon","elem C")
|
|
cmd.recolor()
|
|
|
|
|
|
def interchain_distances(name, selection, cutoff=None, mode=None, label=0, reset=1, _self=cmd):
|
|
'''
|
|
DESCRIPTION
|
|
|
|
Find distances between all chains in selection
|
|
'''
|
|
import itertools
|
|
|
|
if int(reset):
|
|
_self.distance(name, 'none', 'none', 1.0, reset=1)
|
|
|
|
chains = _self.get_chains(selection)
|
|
|
|
for c1, c2 in itertools.combinations(chains, 2):
|
|
s1 = '(%s) & chain "%s"' % (selection, c1)
|
|
s2 = '(%s) & chain "%s"' % (selection, c2)
|
|
_self.distance(name, s1, s2, cutoff, mode, label=label)
|
|
|
|
_self.enable(name)
|
|
|
|
|
|
def get_sasa_relative(selection='all',
|
|
state=1,
|
|
vis=-1,
|
|
var='b',
|
|
quiet=1,
|
|
outfile='',
|
|
*,
|
|
subsele='all',
|
|
_self=cmd):
|
|
'''
|
|
DESCRIPTION
|
|
|
|
Calculates the relative per-residue solvent accessible surface area
|
|
and optionally labels and colors residues. The value is relative to
|
|
full exposure of the residue, calculated by removing all other
|
|
residues except its two next neighbors, if present.
|
|
|
|
Loads a value beteween 0.0 (fully buried) and 1.0 (fully exposed)
|
|
into the b-factor property, available in "iterate", "alter" and
|
|
"label" as "b".
|
|
|
|
USAGE
|
|
|
|
get_sasa_relative [ selection [, state [, vis [, var ]]]]
|
|
|
|
ARGUMENTS
|
|
|
|
selection = str: atom selection {default: all}
|
|
|
|
state = int: object state {default: 1}
|
|
|
|
vis = 0/1: show labels and do color by exposure {default: !quiet}
|
|
|
|
var = str: name of property to assign {default: b}
|
|
|
|
quiet = 0/1: print results to log window
|
|
|
|
outfile = str: filename, write to file instead of log window {default: }
|
|
|
|
subsele = str: Sub-selection, e.g. "sidechain" {default: all}
|
|
|
|
EXAMPLE
|
|
|
|
fetch 1ubq, async=0
|
|
get_sasa_relative polymer
|
|
|
|
# side-chain exposure, excluding C-alpha atom
|
|
get_sasa_relative polymer, subsele=sidechain
|
|
|
|
# side-chain exposure, including C-alpha atom
|
|
get_sasa_relative polymer, subsele=sidechain guide
|
|
|
|
PYTHON API
|
|
|
|
cmd.get_sasa_relative(...) -> dict
|
|
|
|
SEE ALSO
|
|
|
|
get_area with "load_b=1" argument.
|
|
'''
|
|
import collections
|
|
|
|
state, vis, quiet = int(state), int(vis), int(quiet)
|
|
if vis == -1:
|
|
vis = not quiet
|
|
|
|
sele = _self.get_unused_name('_sele')
|
|
tripepname = _self.get_unused_name('_tripep')
|
|
|
|
_self.select(sele, selection, 0)
|
|
|
|
dot_solvent = _self.get_setting_boolean('dot_solvent')
|
|
_self.set('dot_solvent', 1, updates=0)
|
|
|
|
try:
|
|
for model in _self.get_object_list(sele):
|
|
_self.get_area('?%s & ?%s' % (sele, model), state, load_b=1)
|
|
|
|
resarea = collections.defaultdict(float)
|
|
_self.iterate(f"{sele} & ({subsele})",
|
|
'resarea[model,segi,chain,resi] += b',
|
|
space=locals())
|
|
|
|
for key in resarea:
|
|
_self.create(tripepname, 'byres (/%s/%s/%s/`%s extend 1)' % key, state, 1, zoom=0)
|
|
_self.get_area(tripepname, 1, load_b=1)
|
|
|
|
resarea_exposed = [0.0]
|
|
_self.iterate(f"/{tripepname}/{key[1]}/{key[2]}/`{key[3]} & ({subsele})",
|
|
'resarea_exposed[0] += b', space=locals())
|
|
_self.delete(tripepname)
|
|
|
|
if resarea_exposed[0] == 0.0:
|
|
continue
|
|
|
|
resarea[key] /= resarea_exposed[0]
|
|
|
|
_self.alter(sele,
|
|
var + ' = resarea[model,segi,chain,resi]', space=locals())
|
|
|
|
handle = open(outfile, 'w') if outfile else None
|
|
|
|
def callback(key, area):
|
|
w = len(key[0]) + 15
|
|
per10 = int(10 * area)
|
|
s = ('/%s/%s/%s/%s`%s ' % key).ljust(w)
|
|
s += '%3.0f' % (area * 100) + '% '
|
|
s += '|' + '=' * per10 + ' ' * (10 - per10) + '|'
|
|
print(s, file=handle)
|
|
|
|
if not quiet or outfile:
|
|
_self.iterate('?%s & guide' % sele,
|
|
'callback((model, segi, chain, resn, resi), ' + var + ')',
|
|
space=locals())
|
|
|
|
if outfile:
|
|
handle.close()
|
|
print(" Written results to %s" % (outfile))
|
|
|
|
if vis:
|
|
_self.label('?%s & guide' % (sele), '"%.1f" % ' + var)
|
|
_self.spectrum(var, 'white blue', sele, minimum=0., maximum=1.)
|
|
|
|
finally:
|
|
_self.set('dot_solvent', dot_solvent, updates=0)
|
|
_self.delete(sele)
|
|
|
|
return resarea
|
|
|
|
|
|
def ligand_zoom(step=1, _self=cmd):
|
|
'''
|
|
DESCRIPTION
|
|
|
|
Zoom to the next organic molecule (by residue identifier)
|
|
|
|
Bound to CTRL-L key.
|
|
'''
|
|
global _current_ligand
|
|
|
|
s = {'ligand_set': set()}
|
|
if _self.iterate('organic', 'ligand_set.add((model,segi,chain,resi))',
|
|
space=s) < 1:
|
|
return
|
|
|
|
ligands = sorted(s["ligand_set"])
|
|
|
|
try:
|
|
i = ligands.index(_current_ligand)
|
|
except (ValueError, NameError):
|
|
i = -1
|
|
|
|
i = (i + int(step)) % len(ligands)
|
|
_current_ligand = ligands[i]
|
|
|
|
# use "do" for feedback
|
|
_self.do('zoom /%s/%s/%s & resi %s, animate=1, buffer=2' % ligands[i])
|