def ligands(selection="(all)", _self=cmd):
cmd = _self
try:
s = tmp_sele
cmd.select(s, selection)
polar_contacts = _get_polar_contacts_name(s, _self)
_prepare(s, polar_contacts, _self=cmd)
host = "_preset_host"
solvent = "_preset_solvent"
near_solvent = "_preset_solvent"
lig = "_preset_lig"
cmd.select(host, s + " and " + prot_and_dna_sele)
cmd.select(solvent, s + " and " + solv_sele)
cmd.select(lig, s + " and " + lig_sele)
cmd.select(near_solvent,
s + " and (" + solvent + " within 4 of " + lig + ")")
util.chainbow(host, _self=cmd)
util.cbc(lig, _self=cmd)
util.cbac("((" + s + ") and not elem c)", _self=cmd)
cmd.hide("everything", s)
cmd.show("ribbon", host)
cmd.show(
"lines",
"(" + s + " and byres (" + host + " within 5 of " + lig + "))")
cmd.show("sticks", lig)
cmd.show("sticks", solvent + " and neighbor " + lig)
cmd.show("lines",
"(" + s + " and (rep lines extend 1) and " + lig + ")")
if cmd.count_atoms(lig):
cmd.dist(polar_contacts,
host + "|" + near_solvent,
lig + "|" + near_solvent,
mode=2,
quiet=1,
label=0,
reset=1) # hbonds
if polar_contacts in cmd.get_names():
cmd.enable(polar_contacts)
cmd.hide("labels", polar_contacts)
cmd.show("dashes", polar_contacts)
else:
cmd.delete(polar_contacts)
cmd.show("nonbonded", lig + "|" + host + "|" + near_solvent)
if cmd.count_atoms(lig):
cmd.zoom(lig, 3)
cmd.delete(host)
cmd.delete(solvent)
cmd.delete(near_solvent)
cmd.delete(lig)
except:
traceback.print_exc()
def ligand_sites(selection="(all)",_self=cmd):
cmd=_self
try:
s = tmp_sele
cmd.select(s,selection)
polar_contacts = _get_polar_contacts_name(s,_self)
_prepare(s,polar_contacts,_self=cmd)
host = "_preset_host"
solvent = "_preset_solvent"
near_solvent = "_preset_solvent"
lig = "_preset_lig"
cmd.select(host,s+" and "+prot_and_dna_sele)
cmd.select(solvent,s+" and "+solv_sele)
cmd.select(lig,s+" and "+lig_sele)
cmd.select(near_solvent,s+" and ("+solvent+" within 4 of "+lig+")")
cmd.flag("ignore",host,"clear")
cmd.flag("ignore",lig+"|"+solvent,"set")
util.chainbow(host,_self=cmd)
util.cbc(lig,_self=cmd)
util.cbac("(("+s+") and not elem c)",_self=cmd)
cmd.hide("everything",s)
cmd.show("ribbon",host)
cmd.show("lines","("+s+" and byres ("+host+" within 5 of "+lig+"))")
cmd.show("surface","("+s+" and ((rep lines expand 4) within 6 of "+lig+"))")
cmd.set("two_sided_lighting",1) # global setting
cmd.set("transparency",0,s)
cmd.set("surface_quality",0,s)
cmd.show("sticks",lig)
cmd.show("sticks",solvent+" and neighbor "+lig)
cmd.show("lines","("+s+" and (rep lines extend 1) and "+lig+")")
if cmd.count_atoms(lig):
cmd.dist(polar_contacts,host+"|"+near_solvent,lig+"|"+near_solvent,mode=2,quiet=1,label=0,reset=1) # hbonds
if polar_contacts in cmd.get_names():
cmd.enable(polar_contacts)
cmd.hide("labels",polar_contacts)
cmd.show("dashes",polar_contacts)
else:
cmd.delete(polar_contacts)
cmd.show("nb_spheres",lig+"|"+host+"|"+near_solvent)
if cmd.count_atoms(lig):
cmd.zoom(lig,3)
cmd.delete(host)
cmd.delete(solvent)
cmd.delete(near_solvent)
cmd.delete(lig)
except:
traceback.print_exc()
cmd.delete(s)
def simple(selection="(all)", _self=cmd):
cmd = _self
s = tmp_sele
cmd.select(s, selection)
_prepare(s, _self=cmd)
util.cbc(s, _self=cmd)
cmd.show("ribbon", s)
cmd.show(
"lines", "(byres ((" + s + " & r. CYS+CYX & n. SG) & bound_to (" + s +
" & r. CYS+CYX & n. SG))) & n. CA+CB+SG")
# try to show what covalent ligands are connected to...
cmd.show("sticks", "(" + lig_sele + " and (" + s + ")) extend 2")
cmd.show(
"sticks", "byres ((" + lig_sele + " and (" + s +
") and not resn ACE+NAC+NME+NH2) extend 1)")
cmd.hide("sticks", "(" + s + ") and ((not rep sticks) extend 1)")
cmd.show("sticks", "(" + lig_sele + " and (" + s + ")) extend 2")
# color by atom if lines or sticks are shown
util.cnc("(( rep lines or rep sticks or (" + lig_and_solv_sele +
")) and (" + s + "))",
_self=cmd)
cmd.show("nonbonded", "(" + lig_and_solv_sele + " and (" + s + "))")
cmd.show("lines", "(" + lig_and_solv_sele + " and (" + s + "))")
if cmd.count_atoms(s):
cmd.zoom(s)
cmd.delete(s)
def pretty_solv(selection="(all)", _self=cmd):
cmd = _self
s = tmp_sele
cmd.select(s, selection)
polar_contacts = _get_polar_contacts_name(s, _self)
_prepare(s, polar_contacts, _self=cmd)
cmd.dss(s, preserve=1)
cmd.cartoon("auto", s)
cmd.show("cartoon", s)
cmd.show("sticks", "(" + lig_sele + " and (" + s + "))")
cmd.show("nb_spheres",
"((" + lig_sele + "|resn hoh+wat+h2o) and (" + s + "))")
util.cbc("(" + lig_sele + " and (" + s + "))", _self=cmd)
util.cbac("(" + lig_sele + " and (" + s + ") and not elem c)", _self=cmd)
cmd.spectrum("count",
selection="(elem c and (" + s + ") and not " + lig_sele + ")")
cmd.set("cartoon_highlight_color", -1, selection)
cmd.set("cartoon_fancy_helices", 0, selection)
cmd.set("cartoon_smooth_loops", 0, selection)
cmd.set("cartoon_flat_sheets", 1, selection)
cmd.set("cartoon_side_chain_helper", 0, selection)
if polar_contacts in cmd.get_names():
cmd.disable(polar_contacts)
if cmd.count_atoms(s):
cmd.zoom(s)
def pub_solv(selection="(all)",_self=cmd):
cmd=_self
pretty_solv(selection,_self)
s = tmp_sele
cmd.select(s,selection)
cmd.set("cartoon_smooth_loops",1,selection)
cmd.set("cartoon_highlight_color","grey50",selection)
cmd.set("cartoon_fancy_helices",1,selection)
cmd.set("cartoon_flat_sheets",1,selection)
cmd.set("cartoon_side_chain_helper",0,selection)
if cmd.count_atoms(s):
cmd.zoom(s)
def pub_solv(selection="(all)", _self=cmd):
cmd = _self
pretty_solv(selection, _self)
s = tmp_sele
cmd.select(s, selection)
cmd.set("cartoon_smooth_loops", 1, selection)
cmd.set("cartoon_highlight_color", "grey50", selection)
cmd.set("cartoon_fancy_helices", 1, selection)
cmd.set("cartoon_flat_sheets", 1, selection)
cmd.set("cartoon_side_chain_helper", 0, selection)
if cmd.count_atoms(s):
cmd.zoom(s)
def mass_align(target,enabled_only=0,max_gap=50,_self=cmd):
pymol=_self._pymol
cmd=_self
list = cmd.get_names("public_objects",int(enabled_only))
filter(lambda x:cmd.get_type(x)!="object:molecule",list)
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 simple(selection="(all)",_self=cmd):
cmd=_self
s = tmp_sele
cmd.select(s,selection)
_prepare(s,_self=cmd)
util.cbc(s,_self=cmd)
cmd.show("ribbon",s)
cmd.show("lines","(byres (("+s+" & r. CYS+CYX & n. SG) & bound_to ("+s+" & r. CYS+CYX & n. SG))) & n. CA+CB+SG")
# try to show what covalent ligands are connected to...
cmd.show("sticks","("+lig_sele+" and ("+s+")) extend 2")
cmd.show("sticks","byres (("+lig_sele+" and ("+s+") and not resn ACE+NAC+NME+NH2) extend 1)")
cmd.hide("sticks","("+s+") and ((not rep sticks) extend 1)")
cmd.show("sticks","("+lig_sele+" and ("+s+")) extend 2")
# color by atom if lines or sticks are shown
util.cnc("(( rep lines or rep sticks or ("+lig_and_solv_sele+")) and ("+s+"))",_self=cmd)
cmd.show("nonbonded","("+lig_and_solv_sele+" and ("+s+"))")
cmd.show("lines","("+lig_and_solv_sele+" and ("+s+"))")
if cmd.count_atoms(s):
cmd.zoom(s)
cmd.delete(s)
def pretty_solv(selection="(all)",_self=cmd):
cmd=_self
s = tmp_sele
cmd.select(s,selection)
polar_contacts = _get_polar_contacts_name(s,_self)
_prepare(s,polar_contacts,_self=cmd)
cmd.dss(s,preserve=1)
cmd.cartoon("auto",s)
cmd.show("cartoon",s)
cmd.show("sticks","("+lig_sele+" and ("+s+"))")
cmd.show("nb_spheres","(("+lig_sele+"|resn hoh+wat+h2o) and ("+s+"))")
util.cbc("("+lig_sele+" and ("+s+"))",_self=cmd)
util.cbac("("+lig_sele+" and ("+s+") and not elem c)",_self=cmd)
cmd.spectrum("count",selection="(elem c and ("+s+") and not "+lig_sele+")")
cmd.set("cartoon_highlight_color",-1,selection)
cmd.set("cartoon_fancy_helices",0,selection)
cmd.set("cartoon_smooth_loops",0,selection)
cmd.set("cartoon_flat_sheets",1,selection)
cmd.set("cartoon_side_chain_helper",0,selection)
if polar_contacts in cmd.get_names():
cmd.disable(polar_contacts)
if cmd.count_atoms(s):
cmd.zoom(s)
def ss(selection="(name ca and alt '',A)",state=1,_self=cmd):
pymol=_self._pymol
cmd=_self # NOT THREAD SAFE
print ' util.ss: WARNING: This is not a "correct" secondary structure'
print ' util.ss: assignment algorithm! Please use only as a last resort.'
cmd.feedback("push")
cmd.feedback("disable","executive","actions")
ss_pref = "_sss"
sss1 = ss_pref+"1"
cnt = cmd.select(sss1,"((byres ("+selection+")) and name ca and not het)")
print " util.ss: initiating secondary structure assignment on %d residues."%cnt
cas = cmd.index(sss1)
if not len(cas):
return
# set cartoon mode to auto over the selection
cmd.cartoon("auto",sss1)
print " util.ss: extracting sequence and relationships..."
# get CA list
res_list = []
pymol._ss = pymol.Scratch_Storage()
pymol._ss.res_list = res_list
cmd.iterate(sss1,'_ss.res_list.append((model,index))')
# generate atom-to-residue conversion dictionaries
ca_dict = {}
n_dict = {}
o_dict = {}
scr_dict = {} # scr = segment,chain,resi
pymol._ss.n_dict = n_dict
pymol._ss.o_dict = o_dict
pymol._ss.scr_dict = scr_dict
pymol._ss.ca_dict = ca_dict
cmd.iterate(sss1,
'_ss.scr_dict[(model,index)]=(segi,chain,resi)') # CA's
cmd.iterate("((byres "+sss1+") and n;n)"
,'_ss.scr_dict[(model,index)]=(segi,chain,resi)') # N's
cmd.iterate("((byres "+sss1+") and n;o)",
'_ss.scr_dict[(model,index)]=(segi,chain,resi)') # O's
cmd.iterate(sss1,
'_ss.ca_dict[(segi,chain,resi)] = (model,index)')
cmd.iterate("((byres "+sss1+") and n;n)",
'_ss.n_dict[(segi,chain,resi)] = (model,index)')
cmd.iterate("((byres "+sss1+") and n;o)",
'_ss.o_dict[(segi,chain,resi)] = (model,index)')
scr_dict[None]=None
o_dict[None]=None
n_dict[None]=None
ca_dict[None]=None
# create special version of cas with gaps
gap = [None,None,None,None]
# gap large enough to distinguish i+4 interations from gaps
last = None
for a in res_list:
if last!=None:
if(cmd.count_atoms(
"((neighbor(neighbor(neighbor (%s`%d)))) and (%s`%d))"%
(last[0],last[1],a[0],a[1]),quiet=1)==0):
gap.extend([None,None,None,None])
gap.append(a)
last = a
gap.extend([None,None,None,None])
print " util.ss: analyzing phi/psi angles (slow)..."
# generate reverse-lookup for gap indices
ss = {}
c = 0
gap_idx = {}
for a in gap:
gap_idx[a] = c
c = c + 1
# secondary structure database...
ss = {}
ss[None]=None
# make decisions based on phi/psi
for a in cas:
ss[a] = 'L' # default
phipsi = cmd.get_phipsi(sss1,state)
for a in phipsi.keys():
(phi,psi) = phipsi[a]
# print scr_dict[a],(phi,psi)
if (phi!=None) and (psi!=None):
if ((phi<-45) and (phi>-160) and
(psi<-170) or (psi>10)): # beta?
ss[a] = 's'
elif ((phi<-45) and (phi>-160) and
(psi>-80) and (psi<-25)): # helix?
ss[a] = 'H'
print " util.ss: finding hydrogen bonds..."
# find all pairwise hydrogen bonds and make note of them in dict
hb = cmd.find_pairs("((byres "+sss1+") and n;n)",
"((byres "+sss1+") and n;o)",mode=1,
cutoff=3.7,angle=55,
state1=state,state2=state)
hb_dict = {} # [((N-atom) (O-atom))] = 1
n_hb_dict = {} # [(N-atom)] = [(O-atom),...]
o_hb_dict = {} # [(O-atom)] = [(N-atom),...]
for a in hb:
# cmd.dist("(%s`%d)"%a[0],"(%s`%d)"%a[1])
hb_dict[a] = 1
n = a[0]
o = a[1]
if not n_hb_dict.has_key(n): n_hb_dict[n]=[]
if not o_hb_dict.has_key(o): o_hb_dict[o]=[]
n_hb_dict[n].append(o)
o_hb_dict[o].append(n)
# check to insure that all helical residues have at least an i +/- 4
# hydrogen bond
for c in xrange(4,len(gap)-4):
a = gap[c]
if ss[a]=='H':
aN = n_dict[scr_dict[a]]
aO = o_dict[scr_dict[a]]
am4O = o_dict[scr_dict[gap[c-4]]]
ap4N = n_dict[scr_dict[gap[c+4]]]
if not hb_dict.has_key((aN,am4O)):
if not hb_dict.has_key((ap4N,aO)):
ss[a]='L'
print " util.ss: verifying beta sheets..."
# check to insure that all beta residues have proper interactions
rep_dict = {}
repeat = 1
while repeat:
repeat = 0
c = 4
cc = len(gap)-4
while c<cc:
a1 = gap[c]
if (ss[a1] in ['s','S']) and not rep_dict.has_key(a1):
rep_dict[a1] = 1
valid = 0
scr_a1 = scr_dict[a1]
# look for antiparallel 2:2 H-bonds (NH-O=C + C=O-HN)
n_a1_atom = n_dict[scr_a1]
o_a1_atom = o_dict[scr_a1]
if (n_hb_dict.has_key(n_a1_atom) and
o_hb_dict.has_key(o_a1_atom)):
for n_hb_atom in n_hb_dict[n_a1_atom]:
for o_hb_atom in o_hb_dict[o_a1_atom]:
n_hb_scr = scr_dict[n_hb_atom]
o_hb_scr = scr_dict[o_hb_atom]
if o_hb_scr == n_hb_scr:
b1 = ca_dict[o_hb_scr]
if abs(c-gap_idx[b1])>2:
ss[b1] = 'S'
ss[a1] = 'S'
valid = 1
# look for antiparallel offset HB (i,i+2,j,j-2)
a3 = gap[c+2]
if (a3!=None):
scr_a3 = scr_dict[a3]
o_a1_atom = o_dict[scr_a1]
n_a3_atom = n_dict[scr_a3]
if (n_hb_dict.has_key(n_a3_atom) and
o_hb_dict.has_key(o_a1_atom)):
for n_hb_atom in n_hb_dict[n_a3_atom]:
for o_hb_atom in o_hb_dict[o_a1_atom]:
n_hb_scr = scr_dict[n_hb_atom]
o_hb_scr = scr_dict[o_hb_atom]
b1 = ca_dict[o_hb_scr]
if b1!=None:
b1_i = gap_idx[b1]
if abs(c-b1_i)>2: # no turns!
b3 = gap[b1_i-2]
if b3!=None:
b3_scr = scr_dict[b3]
if b3_scr == n_hb_scr:
a2 = gap[c+1]
b2 = gap[gap_idx[b1]-1]
ss[b1] = 'S'
ss[b3] = 'S'
ss[a1] = 'S'
ss[a3] = 'S'
if ss[a2]=='L': ss[a2] = 's'
if ss[b2]=='L': ss[b2] = 's'
valid = 1
# look for antiparallel offset HB (i,i-2,j,j+2)
a3 = gap[c-2]
if (a3!=None):
scr_a3 = scr_dict[a3]
n_a1_atom = n_dict[scr_a1]
o_a3_atom = o_dict[scr_a3]
if (n_hb_dict.has_key(n_a1_atom) and
o_hb_dict.has_key(o_a3_atom)):
for n_hb_atom in n_hb_dict[n_a1_atom]:
for o_hb_atom in o_hb_dict[o_a3_atom]:
n_hb_scr = scr_dict[n_hb_atom]
o_hb_scr = scr_dict[o_hb_atom]
b1 = ca_dict[o_hb_scr]
if b1!=None:
b1_i = gap_idx[b1]
if abs(c-b1_i)>2: # no turns!
b3 = gap[b1_i-2]
if b3!=None:
b3_scr = scr_dict[b3]
if b3_scr == n_hb_scr:
a2 = gap[c-1]
b2 = gap[gap_idx[b1]-1]
ss[b1] = 'S'
ss[b3] = 'S'
ss[a1] = 'S'
ss[a3] = 'S'
if ss[a2]=='L': ss[a2] = 's'
if ss[b2]=='L': ss[b2] = 's'
valid = 1
# look for parallel 1:3 HB (i,j-1,j+1)
n_a1_atom = n_dict[scr_a1]
o_a1_atom = o_dict[scr_a1]
if (n_hb_dict.has_key(n_a1_atom) and
o_hb_dict.has_key(o_a1_atom)):
for n_hb_atom in n_hb_dict[n_a1_atom]:
for o_hb_atom in o_hb_dict[o_a1_atom]:
n_hb_scr = scr_dict[n_hb_atom]
o_hb_scr = scr_dict[o_hb_atom]
b0 = ca_dict[n_hb_scr]
if b0!=None:
b2 = gap[gap_idx[b0]+2]
if b2!=None:
b2_scr = scr_dict[b2]
if b2_scr == o_hb_scr:
b1 = gap[gap_idx[b0]+1]
ss[a1] = 'S'
ss[b0] = 'S'
if ss[b1]=='L': ss[b1]='s'
ss[b2] = 'S'
valid = 1
repeat = 1
if not valid:
ss[a1] = 'L'
c = c + 1
# automatically fill 1 residue gaps in helices and well-defined sheets
c = 4
cc = len(gap)-6
while c<cc:
a1 = gap[c]
a3 = gap[c+2]
ss_a1 = ss[a1]
ss_a3 = ss[a3]
if (ss_a1==ss_a3) and (ss_a1 in ['S','H']):
a2 = gap[c+1]
ss[a2] = ss_a1
c = c + 1
# remove singleton sheet residues
c = 4
cc = len(gap)-4
while c<cc:
a0 = gap[c-1]
a1 = gap[c]
a2 = gap[c+1]
if ss[a1] in ['s','S']:
if ((not ss[a0] in ['s','S']) and
(not ss[a2] in ['s','S'])):
ss[a1] = 'L'
c = c + 1
# remove sheet residues which aren't next to another sheet
c = 4
cc = len(gap)-4
while c<cc:
a1 = gap[c]
if ss[a1]=='S':
a1 = gap[c]
scr_a1 = scr_dict[a1]
# look for hydrogen bonds to another sheet
n_a1_atom = n_dict[scr_a1]
o_a1_atom = o_dict[scr_a1]
certain = 0
if n_hb_dict.has_key(n_a1_atom):
for n_hb_atom in n_hb_dict[n_a1_atom]:
n_hb_ca_atom=ca_dict[scr_dict[n_hb_atom]]
if ss[n_hb_ca_atom]=='S':
certain = 1
break
if o_hb_dict.has_key(o_a1_atom):
for o_hb_atom in o_hb_dict[o_a1_atom]:
o_hb_ca_atom=ca_dict[scr_dict[o_hb_atom]]
if ss[o_hb_ca_atom]=='S':
certain = 1
break
if not certain:
ss[a1] = 's'
c = c + 1
# remove questionable sheet residues
c = 4
cc = len(gap)-4
while c<cc:
a0 = gap[c-1]
a1 = gap[c]
a2 = gap[c+1]
if ss[a1]=='s':
if (not ((ss[a0]=='S') and (ss[a2]=='S'))):
ss[a1] = 'L'
c = c + 1
# extend helices if hydrogen bonding requirements are met
rep_dict = {}
repeat = 1
while repeat:
repeat = 0
c = 4
cc = len(gap)-4
while c<cc:
a = gap[c]
if not rep_dict.has_key(a):
if ss[gap[c+1]]=='H':
rep_dict[a] = 1
if ss[a]!='H': # N-terminal end
aO = o_dict[scr_dict[a]]
ap4N = n_dict[scr_dict[gap[c+4]]]
ap3N = n_dict[scr_dict[gap[c+3]]]
if hb_dict.has_key((ap4N,aO)) or hb_dict.has_key((ap3N,aO)):
ss[a]='H'
repeat = 1
c = c - 5
if c<4: c=4
if ss[gap[c-1]]=='H':
a = gap[c]
if ss[a]!='H': # C-terminal end
rep_dict[a] = 1
aN = n_dict[scr_dict[a]]
am4O = o_dict[scr_dict[gap[c-4]]]
am3O = o_dict[scr_dict[gap[c-3]]]
if hb_dict.has_key((aN,am4O)) or hb_dict.has_key((aN,am3O)):
ss[a]='H'
repeat = 1
c = c - 5
if c<4: c=4
c = c + 1
# remove doubleton helices
c = 4
cc = len(gap)-5
while c<cc:
a0 = gap[c-1]
a1 = gap[c]
a2 = gap[c+1]
a3 = gap[c+2]
ss_a0 = ss[gap[c-1]]
ss_a1 = ss[gap[c]]
ss_a2 = ss[gap[c+1]]
ss_a3 = ss[gap[c+2]]
if ss_a1=='H':
if (ss_a2==ss_a1) and (ss_a0!=ss_a2) and (ss_a2!=ss_a3):
ss[a1] = 'L'
ss[a2] = 'L'
c = c + 1
# remove totally unreasonable helix and sheet residues
c = 4
cc = len(gap)-5
while c<cc:
a1 = gap[c]
ss_a1 = ss[gap[c]]
if ss_a1=='H':
if phipsi.has_key(a1):
(phi,psi) = phipsi[a1]
if (phi>0) and (phi<150):
ss[a1] = 'L'
elif((psi<-120) or (psi>140)):
ss[a1] = 'L'
elif ss_a1 in ['S','s']:
if phipsi.has_key(a1):
(phi,psi) = phipsi[a1]
if (phi>45) and (phi<160):
ss[a1] = 'L'
# if (psi<-30) and (psi>-150):
if (psi<-65) and (psi>-150):
ss[a1] = 'L'
c = c + 1
for x in range(1,3):
# remove singleton sheet residues
c = 4
cc = len(gap)-4
while c<cc:
a0 = gap[c-1]
a1 = gap[c]
a2 = gap[c+1]
if ss[a1] in ['s','S']:
if ((not ss[a0] in ['s','S']) and
(not ss[a2] in ['s','S'])):
ss[a1] = 'L'
c = c + 1
# remove sheet residues which aren't next to another sheet
c = 4
cc = len(gap)-4
while c<cc:
a1 = gap[c]
if ss[a1]=='S':
a1 = gap[c]
scr_a1 = scr_dict[a1]
# look for hydrogen bonds to another sheet
n_a1_atom = n_dict[scr_a1]
o_a1_atom = o_dict[scr_a1]
certain = 0
if n_hb_dict.has_key(n_a1_atom):
for n_hb_atom in n_hb_dict[n_a1_atom]:
n_hb_ca_atom=ca_dict[scr_dict[n_hb_atom]]
if ss[n_hb_ca_atom]=='S':
certain = 1
break
if o_hb_dict.has_key(o_a1_atom):
for o_hb_atom in o_hb_dict[o_a1_atom]:
o_hb_ca_atom=ca_dict[scr_dict[o_hb_atom]]
if ss[o_hb_ca_atom]=='S':
certain = 1
break
if not certain:
ss[a1] = 's'
c = c + 1
# remove questionable sheet residues
c = 4
cc = len(gap)-4
while c<cc:
a0 = gap[c-1]
a1 = gap[c]
a2 = gap[c+1]
if ss[a1]=='s':
if (not ((ss[a0]=='S') and (ss[a2]=='S'))):
ss[a1] = 'L'
c = c + 1
# lst = ss.keys()
# lst.sort()
# for a in lst: print scr_dict[a],ss[a]
# assign protein
for a in cas:
if ss[a]=='s':
ss[a]='S'
cmd.alter(sss1,"ss ='L'")
for a in cas:
if ss[a]!='L':
cmd.alter("(%s`%d)"%a,"ss='%s'"%ss[a])
cmd.feedback("pop")
del pymol._ss # IMPORTANT
cmd.delete(sss1)
cmd.rebuild(selection,'cartoon')
#
# print conn_hash.keys()
print " util.ss: assignment complete."
def setup_alignment_contexts(context_info): # Author: Warren DeLano
(list,dict) = context_info[0:2]
doc_list = ['\888Legend:']
obj_name_dict = {}
for a in list:
sf = string.find(a,"_")
if sf>=0:
object_name = a[0:sf]
if not obj_name_dict.has_key(object_name):
obj_name_dict[object_name] = 1
col_index = cmd.get_object_color_index(object_name)
if col_index>=0:
col_tup = cmd.get_color_tuple(col_index)
if is_tuple(col_tup):
col_int = map(lambda x:int(x*9+0.49999),col_tup)
col_str = string.join(map(lambda x:chr(ord('0')+x),col_int),'')
doc_list.append("\\"+col_str+object_name+"\\---")
key_list = [
'F1','F2','F3','F4','F5','F6','F7','F8','F9','F10', #,'F11','F12',
'SHFT-F1','SHFT-F2','SHFT-F3','SHFT-F4','SHFT-F5','SHFT-F6','SHFT-F7',
'SHFT-F8','SHFT-F9','SHFT-F10']# ,'SHFT-F11','SHFT-F12']
doc_list.append("")
doc_list.append("\\888Toggles:")
zoom_context = 1
global labels,ligands,waters,sites,cgos,zooms,dashes
labels = 1
ligands = 1
waters = 1
sites = 1
cgos = 0
zooms = 0
dashes = 1
global m4x_sites,m4x_ligands,m4x_waters
m4x_sites = "m4x_sites"
m4x_ligands = "m4x_ligands"
m4x_waters = "m4x_waters"
cmd.select(m4x_sites,"none")
cmd.select(m4x_ligands,"none")
cmd.select(m4x_waters,"none")
if len(key_list):
key = key_list.pop(0)
cmd.set_key(key,toggle_zooms)
doc_list.append(key+": Zoom")
if len(key_list):
key = key_list.pop(0)
cmd.set_key(key,toggle_sites)
doc_list.append(key+": Sites")
if len(key_list):
key = key_list.pop(0)
cmd.set_key(key,toggle_waters)
doc_list.append(key+": Waters")
if len(key_list):
key = key_list.pop(0)
cmd.set_key(key,toggle_dashes)
doc_list.append(key+": H-Bonds")
if len(key_list):
key = key_list.pop(0)
cmd.set_key(key,toggle_cgos)
doc_list.append(key+": Fits")
if len(key_list):
key = key_list.pop(0)
cmd.set_key(key,toggle_ligands)
doc_list.append(key+": Ligands")
if len(key_list):
key = key_list.pop(0)
cmd.set_key(key,toggle_labels)
doc_list.append(key+": HB-Dists")
for a in list:
include_flag = 0
water = a+"_water"
ligand = a+"_ligand"
site = a+"_site"
hbond = a+"_hbond"
if cmd.count_atoms(site):
if cmd.count_atoms(site+" & m4x_aligned"):
include_flag = 1
if cmd.count_atoms(ligand):
if cmd.count_atoms(ligand+" & m4x_nearby"):
include_flag = 1
if include_flag:
name_list = dict[a]
if water in name_list:
cmd.select(m4x_waters,m4x_waters+"|"+water)
if ligand in name_list:
cmd.select(m4x_ligands,m4x_ligands+"|"+ligand)
if site in name_list:
cmd.select(m4x_sites,m4x_sites+"|"+site+
"|((byres (neighbor ("+site+" and name c))) and name n+ca)"+
"|((byres (neighbor ("+site+" and name n))) and name c+ca+o)")
cmd.wizard("fedora",doc_list)
toggle_cgos(1)
toggle_labels(0)
toggle_dashes(0)
toggle_ligands(1)
toggle_sites(0)
toggle_waters(0)
toggle_cgos(1)
cmd.deselect()
# cmd.feedback("enable","python","output")
cmd.feedback("enable","objectmolecule","results")
cmd.set("internal_feedback",1)
cmd.set("internal_prompt",0)
cmd.feedback("disable","selector","actions")
cmd.feedback("disable","scene","actions")
def setup_alignment_contexts(context_info): # Author: Warren DeLano
(list, dict) = context_info[0:2]
doc_list = ['\888Legend:']
obj_name_dict = {}
for a in list:
sf = string.find(a, "_")
if sf >= 0:
object_name = a[0:sf]
if not obj_name_dict.has_key(object_name):
obj_name_dict[object_name] = 1
col_index = cmd.get_object_color_index(object_name)
if col_index >= 0:
col_tup = cmd.get_color_tuple(col_index)
if is_tuple(col_tup):
col_int = map(lambda x: int(x * 9 + 0.49999), col_tup)
col_str = string.join(
map(lambda x: chr(ord('0') + x), col_int), '')
doc_list.append("\\" + col_str + object_name + "\\---")
key_list = [
'F1',
'F2',
'F3',
'F4',
'F5',
'F6',
'F7',
'F8',
'F9',
'F10', #,'F11','F12',
'SHFT-F1',
'SHFT-F2',
'SHFT-F3',
'SHFT-F4',
'SHFT-F5',
'SHFT-F6',
'SHFT-F7',
'SHFT-F8',
'SHFT-F9',
'SHFT-F10'
] # ,'SHFT-F11','SHFT-F12']
doc_list.append("")
doc_list.append("\\888Toggles:")
zoom_context = 1
global labels, ligands, waters, sites, cgos, zooms, dashes
labels = 1
ligands = 1
waters = 1
sites = 1
cgos = 0
zooms = 0
dashes = 1
global m4x_sites, m4x_ligands, m4x_waters
m4x_sites = "m4x_sites"
m4x_ligands = "m4x_ligands"
m4x_waters = "m4x_waters"
cmd.select(m4x_sites, "none")
cmd.select(m4x_ligands, "none")
cmd.select(m4x_waters, "none")
if len(key_list):
key = key_list.pop(0)
cmd.set_key(key, toggle_zooms)
doc_list.append(key + ": Zoom")
if len(key_list):
key = key_list.pop(0)
cmd.set_key(key, toggle_sites)
doc_list.append(key + ": Sites")
if len(key_list):
key = key_list.pop(0)
cmd.set_key(key, toggle_waters)
doc_list.append(key + ": Waters")
if len(key_list):
key = key_list.pop(0)
cmd.set_key(key, toggle_dashes)
doc_list.append(key + ": H-Bonds")
if len(key_list):
key = key_list.pop(0)
cmd.set_key(key, toggle_cgos)
doc_list.append(key + ": Fits")
if len(key_list):
key = key_list.pop(0)
cmd.set_key(key, toggle_ligands)
doc_list.append(key + ": Ligands")
if len(key_list):
key = key_list.pop(0)
cmd.set_key(key, toggle_labels)
doc_list.append(key + ": HB-Dists")
for a in list:
include_flag = 0
water = a + "_water"
ligand = a + "_ligand"
site = a + "_site"
hbond = a + "_hbond"
if cmd.count_atoms(site):
if cmd.count_atoms(site + " & m4x_aligned"):
include_flag = 1
if cmd.count_atoms(ligand):
if cmd.count_atoms(ligand + " & m4x_nearby"):
include_flag = 1
if include_flag:
name_list = dict[a]
if water in name_list:
cmd.select(m4x_waters, m4x_waters + "|" + water)
if ligand in name_list:
cmd.select(m4x_ligands, m4x_ligands + "|" + ligand)
if site in name_list:
cmd.select(
m4x_sites,
m4x_sites + "|" + site + "|((byres (neighbor (" + site +
" and name c))) and name n+ca)" + "|((byres (neighbor (" +
site + " and name n))) and name c+ca+o)")
cmd.wizard("fedora", doc_list)
toggle_cgos(1)
toggle_labels(0)
toggle_dashes(0)
toggle_ligands(1)
toggle_sites(0)
toggle_waters(0)
toggle_cgos(1)
cmd.deselect()
# cmd.feedback("enable","python","output")
cmd.feedback("enable", "objectmolecule", "results")
cmd.set("internal_feedback", 1)
cmd.set("internal_prompt", 0)
cmd.feedback("disable", "selector", "actions")
cmd.feedback("disable", "scene", "actions")