def sculpt(self, cleanup=0):
if not cleanup:
cmd.set("suspend_updates", 1, quiet=1)
cmd.disable()
cmd.delete("sculpt")
cmd.set("sphere_scale", "1.0")
cmd.set("sphere_mode", 5)
cmd.load("$PYMOL_DATA/demo/pept.pdb", "sculpt")
cmd.hide("lines", "sculpt")
# cmd.show("sticks","sculpt")
cmd.show("spheres", "sculpt")
# cmd.set("sphere_transparency","0.75","sculpt")
# cmd.set("sphere_color","grey","sculpt")
cmd.frame(1)
cmd.set("auto_sculpt", 1)
cmd.set("sculpting", 1)
cmd.sculpt_activate("sculpt")
cmd.set("sculpting_cycles", "100")
cmd.do("edit_mode")
cmd.set("valence", "0.05")
cmd.set("suspend_updates", 0, quiet=0)
cmd.sculpt_iterate("sculpt")
cmd.alter_state(1, "sculpt", "x=x*1.5;y=y*0.1;z=z*1.5")
cmd.zoom()
cmd.unpick()
else:
cmd.set("valence", "0")
cmd.set("sculpting", 0)
cmd.set("auto_sculpt", 0)
cmd.delete("sculpt")
cmd.mouse()
def sculpt(self,cleanup=0):
if not cleanup:
cmd.set("suspend_updates",1,quiet=1)
cmd.disable()
cmd.delete("sculpt")
cmd.set("sphere_scale","1.0")
cmd.set("sphere_mode",5)
cmd.load("$PYMOL_DATA/demo/pept.pdb","sculpt")
cmd.hide("lines","sculpt")
# cmd.show("sticks","sculpt")
cmd.show("spheres","sculpt")
# cmd.set("sphere_transparency","0.75","sculpt")
# cmd.set("sphere_color","grey","sculpt")
cmd.frame(1)
cmd.set("auto_sculpt",1)
cmd.set("sculpting",1)
cmd.sculpt_activate("sculpt")
cmd.set("sculpting_cycles","100")
cmd.do("edit_mode")
cmd.set("valence","0.05")
cmd.set("suspend_updates",0,quiet=0)
cmd.sculpt_iterate("sculpt")
cmd.alter_state(1,"sculpt","x=x*1.5;y=y*0.1;z=z*1.5")
cmd.zoom()
cmd.unpick()
else:
cmd.set("valence","0")
cmd.set("sculpting",0)
cmd.set("auto_sculpt",0)
cmd.delete("sculpt")
cmd.mouse()
def prepare_pymol():
cmd.clip("near", 100000)
cmd.clip("slab", 100000)
cmd.clip("far", -100000)
cmd.show("spheres")
cmd.unpick()
util.cbc()
def Refresh_DDL(widget, var, exc, fun):
try:
cmd.unpick()
list = cmd.get_names('all')
# Delete all entries in DDL
widget['menu'].delete(0, END)
if len(list) > 0:
list = [ str(item) for item in list if not re.match(RESERVED_NAMES, item) ]
for item in sorted(list, key=str.lower):
type = cmd.get_type(str(item))
if (type == 'object:molecule' or type == 'selection') and exc.count(str(item)) == 0:
if fun != None:
widget['menu'].add_command(label=item, command=lambda temp = item: fun(temp))
else:
widget['menu'].add_command(label=item, command=lambda temp = item: widget.setvar(widget.cget('textvariable'), value = temp))
var.set(item)
else:
# Dummy value
widget['menu'].add_command(label='', command=lambda temp = '': widget.setvar(widget.cget('textvariable'), value = ''))
var.set('')
except:
pass
def Quit_Wizard(self):
try:
General_cmd.unmask_Objects(self.exc)
cmd.set('mouse_selection_mode', self.selection_mode)
cmd.delete(self.LigDisplay)
cmd.refresh()
cmd.delete(self.SelFlexDisplay)
cmd.refresh()
cmd.delete(self.PossFlexDisplay)
cmd.refresh()
cmd.delete(self.AtomDisplay)
cmd.refresh()
cmd.deselect()
cmd.unpick()
except:
pass
if self.ErrorCode > 0:
self.FlexAID.WizardError = True
self.queue.put(lambda: self.top.FlexBondsRunning(False))
self.FlexAID.ActiveWizard = None
self.queue.put(lambda: self.FlexAID.root.deiconify())
self.queue.put(lambda: self.FlexAID.root.update())
cmd.set_wizard()
cmd.set_view(self.View)
cmd.refresh()
def extend_peptide(model):
objname = '__tmp{}'.format(random.randint(0, 100000))
minresi = min([a.resi_number for a in model.atom])
maxresi = max([a.resi_number for a in model.atom])
def is_beta_residue(model, r):
resn = getAtom(model, resi_number=r, name='N').resn
return resn.startswith('B2') or resn.startswith('B3')
# first planarize the atoms around C and N in the peptide bonds.
for r in range(minresi, maxresi + 1):
# now align the oxygens: CA, C, O and N must be planar
planarize_peptide_bond(model, (r, 'C'), (r, 'CA'), (r + 1, 'N'),
(r, 'O'))
if is_beta_residue(model, r):
# align the hydrogens: N, CB, C and H must be planar
planarize_peptide_bond(model, (r, 'N'), (r, 'CB'), (r - 1, 'C'),
(r, 'H'))
# try it with CB1
planarize_peptide_bond(model, (r, 'N'), (r, 'CB1'), (r - 1, 'C'),
(r, 'H'))
else:
planarize_peptide_bond(model, (r, 'N'), (r, 'CA'), (r - 1, 'C'),
(r, 'H'))
cmd.delete(objname)
cmd.load_model(model, objname)
# set all torsions to straight
for r in range(minresi, maxresi + 1):
# planarize the peptide bond
# print('Setting dihedrals of residue #{}'.format(r))
set_dihedral(objname, ('O', r - 1), ('C', r - 1), ('N', r), ('H', r),
180)
if is_beta_residue(model, r):
# the "phi" torsion angle
# print('This is a beta residue')
set_dihedral(objname, ('H', r), ('N', r), ('CB+CB1', r), ('CA', r),
0)
# the "theta" torsion angle
set_dihedral(objname, ('N', r), ('CB+CB1', r), ('CA', r), ('C', r),
180)
# the "psi" torsion angle
set_dihedral(objname, ('CB+CB1', r), ('CA', r), ('C', r), ('O', r),
0)
else:
# print('This is an alpha residue')
# the "phi" dihedral
set_dihedral(objname, ('H', r), ('N', r), ('CA', r), ('C', r), 0)
# the "psi" dihedral
set_dihedral(objname, ('N', r), ('CA', r), ('C', r), ('O', r), 0)
# fix the hydrogens
for atom in ['CA', 'CB', 'CB1']:
if cmd.count_atoms('model {} and resi {} and name {}'.format(
objname, r, atom)) == 1:
cmd.h_fix('model {} and resi {} and name {}'.format(
objname, r, atom))
cmd.unpick()
model = cmd.get_model(objname)
cmd.delete(objname)
return model
def find_beta_hbonds(selection,
mindist,
maxdist,
anglemin,
verbose: bool = False,
nitrogen_atomnames='N+NT',
oxygen_atomnames='O+OT1+OT2',
hydrogen_atomnames='H+HN+HT1+HT2+HT+H1+H2+H3'):
"""
Detect hydrogen bonds in beta peptides (and probably other peptides, too)
Inputs:
selection: a selection containing everything,
"""
donors = cmd.get_model('({}) and name {}'.format(selection,
nitrogen_atomnames))
acceptors = cmd.get_model('({}) and name {}'.format(
selection, oxygen_atomnames))
if verbose:
print('Finding hydrogen bonds in selection {}'.format(selection))
print('Donors: {}'.format(len(donors.atom)))
print('Acceptors: {}'.format(len(acceptors.atom)))
for d in donors.atom:
assert isinstance(d, chempy.Atom)
hydrogens = cmd.get_model(
'(neighbor (({}) and index {})) and name {}'.format(
selection, d.index, hydrogen_atomnames))
if verbose:
print('Looking at donor {}, having {} hydrogens'.format(
d.index, len(hydrogens.atom)))
for h in hydrogens.atom:
assert isinstance(h, chempy.Atom)
for a in acceptors.atom:
assert isinstance(a, chempy.Atom)
# check hydrogen-acceptor distance
dist = cmd.get_distance(
'({}) and name {} and index {}'.format(
selection, oxygen_atomnames, a.index),
'({}) and name {} and index {}'.format(
selection, hydrogen_atomnames, h.index))
cmd.unpick()
angle = cmd.get_angle(
'({}) and name {} and index {}'.format(
selection, oxygen_atomnames,
a.index), '({}) and name {} and index {}'.format(
selection, hydrogen_atomnames, h.index),
'({}) and name {} and index {}'.format(
selection, nitrogen_atomnames, d.index))
if verbose:
print('Distance between hydrogen {} and acceptor {}: {}'.
format(h.index, a.index, dist))
print(
'Angle between donor {}, hydrogen {} and acceptor {}: {}'
.format(d.index, h.index, a.index, angle))
if (dist <= float(maxdist)) and (dist >= float(mindist)) and (
angle >= float(anglemin)):
yield d.index, h.index, a.index, dist, angle
def __init__(self, _self=cmd):
cmd.unpick()
Wizard.__init__(self, _self)
self.status = 0 # 0 no atoms selections, 1 atom selected
self.error = None
self.object_name = None
# mode selection subsystem
self.mode = default_mode
self.modes = [
'polar',
'heavy',
'neigh',
'pairs',
]
self.mode_name = {
'polar': 'Polar Neighbors',
'heavy': 'Heavy Neighbors',
'neigh': 'Neighbors',
'pairs': 'Pairwise Distances',
}
smm = []
smm.append([2, 'Measurement Mode', ''])
for a in self.modes:
smm.append([
1, self.mode_name[a], 'cmd.get_wizard().set_mode("' + a + '")'
])
self.menu['mode'] = smm
# overwrite mode selection subsystem
self.object_mode = default_object_mode
self.object_modes = [
'overwr',
'append',
]
self.object_mode_name = {
'overwr': 'Replace Previous',
'append': 'Create New',
}
smm = []
smm.append([2, 'New Distances?', ''])
for a in self.object_modes:
smm.append([
1, self.object_mode_name[a],
'cmd.get_wizard().set_object_mode("' + a + '")'
])
self.menu['object_mode'] = smm
self.selection_mode = cmd.get_setting_int("mouse_selection_mode")
cmd.set("mouse_selection_mode", 0) # set selection mode to atomic
cmd.deselect() # disable the active selection (if any)
def do_select(self,name): # map selects into picks
cmd.unpick()
try:
cmd.edit(name + " and not " + sele_prefix + "*") # note, using new object name wildcards
cmd.delete(name)
self.do_pick(0)
except pymol.CmdException:
traceback.print_exc()
pass
def clear(self):
cmd.delete(sele_prefix+"*")
cmd.delete(dist_prefix+"*")
cmd.delete(indi_sele)
lst = cmd.get_names('selections')
self.n_pair = 0
self.status = 0
self.message = None
cmd.unpick()
cmd.refresh_wizard()
def clear(self):
cmd.delete(sele_prefix + "*")
cmd.delete(dist_prefix + "*")
cmd.delete(indi_sele)
lst = cmd.get_names('selections')
self.n_pair = 0
self.status = 0
self.message = None
cmd.unpick()
cmd.refresh_wizard()
def do_select(self, name): # map selects into picks
cmd.unpick()
try:
cmd.edit(name + " and not " + sele_prefix +
"*") # note, using new object name wildcards
cmd.delete(name)
self.do_pick(0)
except pymol.CmdException:
traceback.print_exc()
pass
def do_pick(self, bondFlag):
global dist_count
if bondFlag:
self.error = "Error: please select an atom, not a bond."
print(self.error)
else:
if self.mode == 'pairs':
if self.status == 0:
name = sele_prefix
cmd.select(name, "(pk1)")
self.status = 1
self.error = None
elif self.status == 1:
if ((self.object_mode == 'append') or (not dist_count)):
dist_count = dist_count + 1
else:
cmd.delete(dist_prefix + "%2d" % dist_count)
name = dist_prefix + "%02d" % dist_count
cmd.dist(name, sele_prefix, "(pk1)")
cmd.delete(sele_prefix)
cmd.unpick()
cmd.enable(name)
self.status = 0
elif self.mode in ['neigh', 'polar', 'heavy']:
if ((self.object_mode == 'append') or (not dist_count)):
dist_count = dist_count + 1
else:
cmd.delete(dist_prefix + "%2d" % dist_count)
name = dist_prefix + "%02d" % dist_count
cnt = 0
if self.mode == 'neigh':
cnt = cmd.select(
sele_prefix,
"(v. and (pk1 a; %f) and (not (nbr. pk1)) and (not (nbr. (nbr. pk1))) and (not (nbr. (nbr. (nbr. pk1)))))"
% self.__class__.cutoff)
elif self.mode == 'polar':
cnt = cmd.select(
sele_prefix,
"(v. and (pk1 a; %f) and (e. n,o) and (not (nbr. pk1)) and (not (nbr. (nbr. pk1))) and (not (nbr. (nbr. (nbr. pk1)))))"
% self.__class__.cutoff)
elif self.mode == 'heavy':
cnt = cmd.select(
sele_prefix,
"(v. and (pk1 a; %f) and (not h.) and (not (nbr. pk1)) and (not (nbr. (nbr. pk1))) and (not (nbr. (nbr. (nbr. pk1)))))"
% self.__class__.cutoff)
cmd.delete(name)
if cnt:
cmd.dist(name, "(pk1)", sele_prefix)
else:
print(" Wizard: No neighbors found.")
cmd.delete(sele_prefix)
cmd.unpick()
cmd.enable(name)
cmd.refresh_wizard()
def reset(self, reset=True):
if reset:
for par, ind in zip(self.params_str, self.indexes_list):
cmd.delete(par)
cmd.delete(ind)
cmd.delete(self.object_prefix + "*")
cmd.delete("sele*")
cmd.delete("_indicate*")
cmd.unpick()
self.pick_count = 0
cmd.refresh_wizard()
def set_dihedral(modelname, nameandresi1, nameandresi2, nameandresi3,
nameandresi4, value):
"""A safer version of cmd.set_dihedral(): doesn't choke on non-singleton selections"""
selections = [
'({}) and name {} and resi {}'.format(modelname, *nr)
for nr in [nameandresi1, nameandresi2, nameandresi3, nameandresi4]
]
if not all([cmd.count_atoms(s) == 1 for s in selections]):
return False
cmd.set_dihedral(*(selections + [value]))
cmd.unpick()
return True
def __init__(self,_self=cmd):
cmd.unpick();
Wizard.__init__(self,_self)
self.status = 0 # 0 no atoms selections, 1 atom selected
self.error = None
self.object_name = None
# mode selection subsystem
self.mode = default_mode
self.modes = [
'polar',
'heavy',
'neigh',
'pairs',
]
self.mode_name = {
'polar':'Polar Neighbors',
'heavy':'Heavy Neighbors',
'neigh':'Neighbors',
'pairs':'Pairwise Distances',
}
smm = []
smm.append([ 2, 'Measurement Mode', '' ])
for a in self.modes:
smm.append([ 1, self.mode_name[a], 'cmd.get_wizard().set_mode("'+a+'")'])
self.menu['mode']=smm
# overwrite mode selection subsystem
self.object_mode=default_object_mode
self.object_modes = [
'overwr',
'append',
]
self.object_mode_name = {
'overwr':'Replace Previous',
'append':'Create New',
}
smm = []
smm.append([ 2, 'New Distances?', '' ])
for a in self.object_modes:
smm.append([ 1, self.object_mode_name[a], 'cmd.get_wizard().set_object_mode("'+a+'")'])
self.menu['object_mode']=smm
self.selection_mode = cmd.get_setting_legacy("mouse_selection_mode")
cmd.set("mouse_selection_mode",0) # set selection mode to atomic
cmd.deselect() # disable the active selection (if any)
def apply(self):
'''
Permanently applies the mutation upon the selected residue
Overrides method from Wizard class
'''
cmd = self.cmd
if self._status == Status.NO_SELECTION:
return
#Remove all atoms that are not in the sugar/phosphate group
#Needed for non-canonical bases
cmd.select("_tmp_sele_invert", "(none)")
for a in self._sugar_phos_atoms:
cmd.select("_tmp_sele_invert",
"_tmp_sele_invert | (%s & name %s)" % (SRC_SELE, a))
cmd.select("_tmp_sele_invert",
"%s and not _tmp_sele_invert" % SRC_SELE)
cmd.remove("_tmp_sele_invert")
try:
new_name = cmd.get_object_list(SRC_SELE)[0]
except IndexError:
print(" Mutagenesis: object not found.")
return
frag_name_three = self._mode_labels[self.mode]
frag_name_one = self._base3_to_1[frag_name_three.lower()]
# FUSE
cmd.fuse(
"%s & name %s" % (FRAG_NAME, self._frag_N_atom_name),
"/%s/%s/%s/%s & name %s" %
(new_name, self._stored.identifiers[0],
self._stored.identifiers[1], self._stored.identifiers[2],
self._src_Cp_atom_name), 1)
#Check to see if DNA
dnaPrefix = ''
if cmd.count_atoms("%s & name O2'" % SRC_SELE) == 0:
dnaPrefix = 'D'
cmd.alter(
"/%s/%s/%s/%s" %
(new_name, self._stored.identifiers[0],
self._stored.identifiers[1], self._stored.identifiers[2]),
"(resn) = '%s%s'" % (dnaPrefix, frag_name_one.upper()),
space=self._space)
cmd.unpick()
self.clear()
def apply(self):
'''
Permanently applies the mutation upon the selected residue
Overrides method from Wizard class
'''
cmd = self.cmd
if self._status == Status.NO_SELECTION:
return
#Remove all atoms that are not in the sugar/phosphate group
#Needed for non-canonical bases
cmd.select("_tmp_sele_invert", "(none)")
for a in self._sugar_phos_atoms:
cmd.select("_tmp_sele_invert",
"_tmp_sele_invert | (%s & name %s)" % (SRC_SELE, a))
cmd.select("_tmp_sele_invert",
"%s and not _tmp_sele_invert" % SRC_SELE)
cmd.remove("_tmp_sele_invert")
try:
new_name = cmd.get_object_list(SRC_SELE)[0]
except IndexError:
print(" Mutagenesis: object not found.")
return
frag_name_three = self._mode_labels[self.mode]
frag_name_one = self._base3_to_1[frag_name_three.lower()]
# FUSE
cmd.fuse(
"%s & name %s" % (FRAG_NAME, self._frag_N_atom_name),
"/%s/%s/%s/%s & name %s" %
(new_name, self._stored.identifiers[0],
self._stored.identifiers[1], self._stored.identifiers[2],
self._src_Cp_atom_name), 1)
#Check to see if DNA
dnaPrefix = ''
if cmd.count_atoms("%s & name O2'" % SRC_SELE) == 0:
dnaPrefix = 'D'
cmd.alter(
"/%s/%s/%s/%s" %
(new_name, self._stored.identifiers[0],
self._stored.identifiers[1], self._stored.identifiers[2]),
"(resn) = '%s%s'" % (dnaPrefix, frag_name_one.upper()),
space=self._space)
cmd.unpick()
self.clear()
def Start(self):
self.queue.put(lambda: self.FlexAID.root.withdraw())
cmd.window('hide')
cmd.window('show')
# self.queue.put(lambda: cmd.window('show'))
cmd.refresh_wizard()
self.ErrorCode = 1
try:
#self.selection_mode = cmd.get_setting_legacy("mouse_selection_mode")
self.selection_mode = cmd.get("mouse_selection_mode")
cmd.set("mouse_selection_mode", 0) # set selection mode to atomic
# Mask objects
self.exc = [self.LigDisplay, self.PossFlexDisplay, self.SelFlexDisplay]
General_cmd.mask_Objects(self.exc)
self.ErrorCode = 0
except:
self.queue.put(lambda: self.top.DisplayMessage(" ERROR: Could not start the Flexible Bonds wizard", 1))
self.queue.put(lambda: self.top.DisplayMessage(" The wizard will abort prematurely", 1))
self.Quit_Wizard()
return
# Display the ligand from the PDB file
if self.DisplayLigand():
self.queue.put(lambda: self.top.DisplayMessage(" ERROR: Could not display the ligand", 1))
self.queue.put(lambda: self.top.DisplayMessage(" The wizard will abort prematurely", 1))
self.Quit_Wizard()
return
# Display all Possible Flexible Bonds
if self.show_FlexibleBonds():
self.queue.put(lambda: self.top.DisplayMessage(" ERROR: Could not display the flexible bonds", 1))
self.queue.put(lambda: self.top.DisplayMessage(" The wizard will abort prematurely", 1))
self.Quit_Wizard()
return
# Display all Selected Flexible Bonds
if self.show_SelectedBonds():
self.queue.put(lambda: self.top.DisplayMessage(" ERROR: Could not display the selected flexible bonds", 1))
self.queue.put(lambda: self.top.DisplayMessage(" The wizard will abort prematurely", 1))
self.Quit_Wizard()
return
# remove any possible selection before selecting atoms
cmd.deselect()
cmd.unpick()
def do_pick(self, picked_bond):
self.reset()
cmd.iterate("pk1", "setattr(cmd.get_wizard(),'pk1_st'," "'%s/%s/%s/%s/%s'%(model,segi,chain,resi,name))")
if picked_bond:
cmd.iterate("pk1", "setattr(cmd.get_wizard(),'pk2_st'," "'%s/%s/%s/%s/%s'%(model,segi,chain,resi,name))")
else:
# for single atom, also get 3D coordinates (EXAMPLE)
cmd.iterate_state(cmd.get_state(), "pk1", "setattr(cmd.get_wizard(),'pk1_xyz',(x,y,z))")
cmd.unpick()
cmd.refresh_wizard()
def flip_by_atoms(self, atmA, atmB, atmC, atmD):
from pymol import CmdException, cmd
sele = self.selector()
a, b, c, d = map(lambda a: '{}/{}'.format(sele, a),
[atmA, atmB, atmC, atmD])
try:
dh = cmd.get_dihedral(a, b, c, d)
except CmdException:
print "Error on '{}'.".format(self.selector())
pass
else:
cmd.set_dihedral(a, b, c, d, dh + 180)
cmd.unpick()
def do_pick(self,bondFlag):
print("Picked!")
cmd=self.cmd
if bondFlag:
self.error = "Error: please select an atom, not a bond."
print(self.error)
else:
if self.status!=0:
cmd.delete(obj_name)
cmd.select(src_sele,"(byres pk1)")
cmd.unpick()
cmd.enable(src_sele)
self.status = 1
self.error = None
self.do_library()
cmd.refresh_wizard()
def do_pick(self,bondFlag):
print("Picked!")
cmd=self.cmd
if bondFlag:
self.error = "Error: please select an atom, not a bond."
print(self.error)
else:
if self.status!=0:
cmd.delete(obj_name)
cmd.select(src_sele,"(byres pk1)")
cmd.unpick()
cmd.enable(src_sele)
self.status = 1
self.error = None
self.do_library()
cmd.refresh_wizard()
def do_pick(self,bondFlag):
self.obj_name = None
# if 'pk1' in cmd.get_names('selections'):
if cmd.count_atoms('pk1',1):
self.obj_name = cmd.identify('pk1',1)[0][0]
model = cmd.get_model("(pk1)")
self.atom = model.atom.pop()
if not self.labeling:
cmd.label("(pk1)", '""')
elif self.atom.name == 'CA':
cmd.label("(pk1)", '" %s %s" % (resn,resi)')
else:
cmd.label("(pk1)", '" %s %s" % (name,resi)')
cmd.unpick()
cmd.refresh_wizard()
def pickNextAtom(self, atom_name):
# transfer the click selection to a named selection
cmd.select(atom_name, "(pk1)")
# delete the click selection
cmd.unpick()
# using the magic of indicate, highlight stuff
indicate_selection = "_indicate" + self.object_prefix
cmd.select(indicate_selection, atom_name)
cmd.enable(indicate_selection)
self.pick_count += 1
self.error = None
# necessary to force update of the prompt
cmd.refresh_wizard()
def pickNextAtom(self, atom_name):
# transfer the click selection to a named selection
cmd.select(atom_name, "(pk1)")
# delete the click selection
cmd.unpick()
# using the magic of indicate, highlight stuff
indicate_selection = "_indicate" + self.object_prefix
cmd.select(indicate_selection, atom_name)
cmd.enable(indicate_selection)
self.pick_count += 1
self.error = None
# necessary to force update of the prompt
cmd.refresh_wizard()
def do_pick(self, bondFlag):
self.obj_name = None
# if 'pk1' in cmd.get_names('selections'):
if cmd.count_atoms('pk1', 1):
self.obj_name = cmd.identify('pk1', 1)[0][0]
model = cmd.get_model("(pk1)")
self.atom = model.atom.pop()
if not self.labeling:
cmd.label("(pk1)", '""')
elif self.atom.name == 'CA':
cmd.label("(pk1)", '" %s %s" % (resn,resi)')
else:
cmd.label("(pk1)", '" %s %s" % (name,resi)')
cmd.unpick()
cmd.refresh_wizard()
def do_pick(self,bondFlag):
global dist_count
if bondFlag:
self.error = "Error: please select an atom, not a bond."
print self.error
else:
if self.mode == 'pairs':
if self.status==0:
name = sele_prefix
cmd.select(name,"(pk1)")
self.status = 1
self.error = None
elif self.status==1:
if ((self.object_mode=='append') or (not dist_count)):
dist_count = dist_count + 1
else:
cmd.delete(dist_prefix+"%2d"%dist_count)
name = dist_prefix + "%02d"%dist_count
cmd.dist(name,sele_prefix,"(pk1)")
cmd.delete(sele_prefix)
cmd.unpick()
cmd.enable(name)
self.status = 0
elif self.mode in ['neigh','polar','heavy']:
if ((self.object_mode=='append') or (not dist_count)):
dist_count = dist_count + 1
else:
cmd.delete(dist_prefix+"%2d"%dist_count)
name = dist_prefix + "%02d"%dist_count
cnt = 0
if self.mode == 'neigh':
cnt = cmd.select(sele_prefix,"(v. and (pk1 a; %f) and (not (nbr. pk1)) and (not (nbr. (nbr. pk1))) and (not (nbr. (nbr. (nbr. pk1)))))"%self.__class__.cutoff)
elif self.mode == 'polar':
cnt = cmd.select(sele_prefix,"(v. and (pk1 a; %f) and (e. n,o) and (not (nbr. pk1)) and (not (nbr. (nbr. pk1))) and (not (nbr. (nbr. (nbr. pk1)))))"%self.__class__.cutoff)
elif self.mode == 'heavy':
cnt = cmd.select(sele_prefix,"(v. and (pk1 a; %f) and (not h.) and (not (nbr. pk1)) and (not (nbr. (nbr. pk1))) and (not (nbr. (nbr. (nbr. pk1)))))"%self.__class__.cutoff)
cmd.delete(name)
if cnt:
cmd.dist(name,"(pk1)",sele_prefix)
else:
print " Wizard: No neighbors found."
cmd.delete(sele_prefix)
cmd.unpick()
cmd.enable(name)
cmd.refresh_wizard()
def do_select(self, selection):
'''
Selection callback during wizard
Overrides method from Wizard class
:param selection: A PyMOL selection
:type selection: string
'''
cmd = self.cmd
cmd.select(SRC_SELE, selection)
cmd.unpick()
try:
self._do_mutation()
except pymol.wizarding.WizardError as e:
print(e)
cmd.delete(selection)
cmd.refresh_wizard()
cmd.deselect()
def do_select(self, selection):
'''
Selection callback during wizard
Overrides method from Wizard class
:param selection: A PyMOL selection
:type selection: string
'''
cmd = self.cmd
cmd.select(SRC_SELE, selection)
cmd.unpick()
try:
self._do_mutation()
except pymol.wizarding.WizardError as e:
print(e)
cmd.delete(selection)
cmd.refresh_wizard()
cmd.deselect()
def do_select(self,selection):
print("Selected!")
cmd=self.cmd
if (obj_name in cmd.get_names()):
if cmd.count_atoms("(%s) and (%s)"%(obj_name,selection)):
cmd.deselect()
return 1
if self.status!=0:
cmd.delete(obj_name)
cmd.select(src_sele,selection)
cmd.unpick()
cmd.enable(src_sele)
self.status = 1
self.error = None
self.do_library()
cmd.delete(selection)
cmd.refresh_wizard()
cmd.deselect()
return 1
def do_select(self,selection):
print("Selected!")
cmd=self.cmd
if (obj_name in cmd.get_names()):
if cmd.count_atoms("(%s) and (%s)"%(obj_name,selection)):
cmd.deselect()
return 1
if self.status!=0:
cmd.delete(obj_name)
cmd.select(src_sele,selection)
cmd.unpick()
cmd.enable(src_sele)
self.status = 1
self.error = None
self.do_library()
cmd.delete(selection)
cmd.refresh_wizard()
cmd.deselect()
return 1
def do_pick(self, picked_bond):
self.reset()
cmd.iterate(
"pk1", "setattr(cmd.get_wizard(),'pk1_st',"
"'%s/%s/%s/%s/%s'%(model,segi,chain,resi,name))")
if picked_bond:
cmd.iterate(
"pk1", "setattr(cmd.get_wizard(),'pk2_st',"
"'%s/%s/%s/%s/%s'%(model,segi,chain,resi,name))")
else:
# for single atom, also get 3D coordinates (EXAMPLE)
cmd.iterate_state(cmd.get_state(), "pk1",
"setattr(cmd.get_wizard(),'pk1_xyz',(x,y,z))")
cmd.unpick()
cmd.refresh_wizard()
def reset(self):
default_thoroughness = "thorough"
default_label = "R1"
default_cutoff = 3.4
default_clashes = 0
default_mode = "Search"
default_vdwRestraints = "tight"
internalClash_cutoff = 2.5
self.homoOligomerMode = False
self.running = False
self.toggleStatesCaption = "Toggle states: ON"
self.object_prefix = "mW-"
self.pickCount = 0
self.object_count = 0
self.vdwRestraints = "tight"
self.thoroughness = default_thoroughness
self.cutoff = default_cutoff
self.clashes = default_clashes
self.set_currentLabel(default_label)
self.residue1Name = None
self.residue2Name = None
self.pickedObject1 = None
self.pickedObject2 = None
self.numberOfLabel = 0
self.mode = default_mode
self.writeToFile = False
self.label = None
#create array for plots
try:
print stored.plots
except:
print "Created plots list."
stored.plots = []
cmd.set("mouse_selection_mode", 1) # set selection mode to residue
cmd.deselect()
cmd.unpick()
cmd.delete("sele*")
cmd.delete("_indicate*")
cmd.delete("pk*")
cmd.delete("*_tmp*")
cmd.refresh_wizard()
def do_pick(self,bondFlag):
if bondFlag:
self.message = "Error: please select an atom, not a bond."
print(self.message)
else:
if self.status==0:
lst = self.get_sele_list(mode='mobile')
if not self.check_same_object(lst,"(pk1)"):
self.message = "Error: must select an atom in the same object as before."
print(self.message)
else:
name = sele_prefix + "%02db"%self.n_pair # mobile end in 'b'
cmd.select(name,"(pk1)")
cmd.unpick()
cmd.select(indi_sele,name)
cmd.enable(indi_sele)
self.status = 1
self.message = None
elif self.status==1:
lst = self.get_sele_list(mode='target')
if not self.check_same_object(lst,"(pk1)"):
self.message = "Error: must select an atom in the same object as before."
print(self.message)
else:
lst = self.get_sele_list(mode='mobile')
if not self.check_different_object(lst,"(pk1)"):
self.message = "Error: target atom must be in a distinct object."
print(self.message)
else:
name = sele_prefix + "%02da"%self.n_pair # target end in 'a'
cmd.select(name,"(pk1)")
cmd.unpick()
cmd.select(indi_sele,name)
cmd.enable(indi_sele)
self.n_pair = self.n_pair + 1
self.status = 0
self.update_dashes()
cmd.refresh_wizard()
def missing_c_termini(selection="(all)",quiet=0,_self=cmd):
cmd=_self
# assumes that hydogens are not present!
sele_list = []
ch=Champ()
model = cmd.get_model(selection)
model_pat = ch.insert_model(model)
assn_pat = ch.insert_pattern_string("[N+0+1]C[C;D2]<0>(=O)")
ch.pattern_clear_tags(model_pat)
if ch.match_1v1_n(assn_pat,model_pat,10000,2)>0:
result = ch.pattern_get_ext_indices_with_tags(model_pat)
for atom_tag in result[0]: # just iterate over atom tags
if len(atom_tag[1])==1: # one and only one match
if atom_tag[1][0]==0:
sele_list.append(atom_tag[0])
cmd.select_list(tmp_sele1,selection,sele_list, mode='index')
while cmd.pop(tmp_sele2,tmp_sele1)>0: # complete the carboxy terminus
cmd.edit(tmp_sele2)
cmd.attach("O",1,1,"OXT",quiet=1)
cmd.unpick()
cmd.delete(tmp_sele1)
def do_pick(self, bondFlag):
if bondFlag:
self.message = "Error: please select an atom, not a bond."
print self.message
else:
if self.status == 0:
lst = self.get_sele_list(mode='mobile')
if not self.check_same_object(lst, "(pk1)"):
self.message = "Error: must select an atom in the same object as before."
print self.message
else:
name = sele_prefix + "%02db" % self.n_pair # mobile end in 'b'
cmd.select(name, "(pk1)")
cmd.unpick()
cmd.select(indi_sele, name)
cmd.enable(indi_sele)
self.status = 1
self.message = None
elif self.status == 1:
lst = self.get_sele_list(mode='target')
if not self.check_same_object(lst, "(pk1)"):
self.message = "Error: must select an atom in the same object as before."
print self.message
else:
lst = self.get_sele_list(mode='mobile')
if not self.check_different_object(lst, "(pk1)"):
self.message = "Error: target atom must be in a distinct object."
print self.message
else:
name = sele_prefix + "%02da" % self.n_pair # target end in 'a'
cmd.select(name, "(pk1)")
cmd.unpick()
cmd.select(indi_sele, name)
cmd.enable(indi_sele)
self.n_pair = self.n_pair + 1
self.status = 0
self.update_dashes()
cmd.refresh_wizard()
def missing_c_termini(selection="(all)", quiet=0, _self=cmd):
cmd = _self
# assumes that hydogens are not present!
sele_list = []
ch = Champ()
model = cmd.get_model(selection)
model_pat = ch.insert_model(model)
assn_pat = ch.insert_pattern_string("[N+0+1]C[C;D2]<0>(=O)")
ch.pattern_clear_tags(model_pat)
if ch.match_1v1_n(assn_pat, model_pat, 10000, 2) > 0:
result = ch.pattern_get_ext_indices_with_tags(model_pat)
for atom_tag in result[0]: # just iterate over atom tags
if len(atom_tag[1]) == 1: # one and only one match
if atom_tag[1][0] == 0:
sele_list.append(atom_tag[0])
cmd.select_list(tmp_sele1, selection, sele_list, mode='index')
while cmd.pop(tmp_sele2, tmp_sele1) > 0: # complete the carboxy terminus
cmd.edit(tmp_sele2)
cmd.attach("O", 1, 1, "OXT", quiet=1)
cmd.unpick()
cmd.delete(tmp_sele1)
def __init__(self, _self=cmd):
cmd.unpick();
Wizard.__init__(self, _self)
self.mouse_selection_mode = cmd.get_setting_int('mouse_selection_mode')
cmd.set('mouse_selection_mode',0) # set selection mode to atomic
cmd.deselect() # disable the active selection (if any)
self.error = None
self.selection_mode = 1 if self.mouse_selection_mode == 6 else 0
self.selection_modes = [
'Residues',
'C-alphas',
]
smm = []
smm.append([ 2, 'Selection Mode', '' ])
for i, label in enumerate(self.selection_modes):
smm.append([1, label, 'cmd.get_wizard().set_mode(%d)' % i])
self.menu['selection_mode'] = smm
self.name = None
def pickNextAtom(self, atom_name):
# transfer the click selection to a named selection
cmd.select(atom_name, "(pk1)")
# delete the click selection
cmd.unpick()
# using the magic of indicate, highlight stuff
indicate_selection = "_indicate" + self.object_prefix
cmd.select(indicate_selection, atom_name)
cmd.enable(indicate_selection)
view = cmd.get_view()
cmd.create(self.indexes_list[self.pick_count],
self.object_prefix + str(self.pick_count))
cmd.set_view(view)
cmd.set("sphere_scale", '0.3', self.indexes_list[self.pick_count])
cmd.show_as('spheres', self.indexes_list[self.pick_count])
if self.pick_count < 3:
cmd.color("red", self.indexes_list[self.pick_count])
else:
cmd.color("green", self.indexes_list[self.pick_count])
self.pick_count += 1
self.error = None
# necessary to force update of the prompt
cmd.refresh_wizard()
def __init__(self, _self=cmd):
cmd.unpick()
Wizard.__init__(self, _self)
self.mouse_selection_mode = cmd.get_setting_int('mouse_selection_mode')
cmd.set('mouse_selection_mode', 0) # set selection mode to atomic
cmd.deselect() # disable the active selection (if any)
self.error = None
self.selection_mode = 1 if self.mouse_selection_mode == 6 else 0
self.selection_modes = [
'Residues',
'C-alphas',
]
smm = []
smm.append([2, 'Selection Mode', ''])
for i, label in enumerate(self.selection_modes):
smm.append([1, label, 'cmd.get_wizard().set_mode(%d)' % i])
self.menu['selection_mode'] = smm
self.name = None
def mutate(selection, new_resn, inplace=0, sculpt=0, hydrogens='auto', mode=0, quiet=1):
'''
DESCRIPTION
Mutate a single residue. Does call the mutagenesis wizard non-interactively
and tries to select the best rotamer. Can do some sculpting in the end to
the best rotamer.
USAGE
mutate selection, new_resn [, inplace [, sculpt [, hydrogens]]]
ARGUMENTS
selection = string: atom selection of single residue
new_resn = string: new residue name (3-letter or 1-letter)
inplace = 0 or 1: work on copy of input object if 0 {default: 0}
sculpt = 0: no sculpting {default}
sculpt = 1: do sculpting on best rotamer
sculpt = 2: do sculpting with neighbors
hydrogens = string: keep, auto or none {default: auto}
mode = 0: select rotamer with best clash score {default}
mode = 1: take chi angles from original residue
mode = 2: first rotamer
EXAMPLE
fetch 2x19, async=0
select x, A/CYS`122/
zoom x
mutate x, LYS
'''
from pymol.wizard import mutagenesis
from . import three_letter
inplace, sculpt = int(inplace), int(sculpt)
mode = int(mode)
quiet = int(quiet)
org = cmd.get_object_list(selection)[0]
tmp = cmd.get_unused_name()
new_resn = new_resn.upper()
new_resn = three_letter.get(new_resn, new_resn)
if inplace:
cpy = org
else:
cpy = cmd.get_unused_name(org + '_cpy')
cmd.create(cpy, org, -1, 1, zoom=0)
scr = []
cmd.iterate('first (%s)' % selection, 'scr[:] = (segi,chain,resi,resn)', space={'scr': scr})
res = '/%s/%s/%s/%s' % tuple([cpy] + scr[:3])
if mode == 1:
old_resn = scr[3]
chi_atoms = {
'ALA': [],
'ARG': ['C','CA','CB','CG','CD','NE','CZ'],
'ASN': ['C','CA','CB','CG','OD1'],
'ASP': ['C','CA','CB','CG','OD1'],
'CYS': ['C','CA','CB','SG'],
'GLN': ['C','CA','CB','CG','CD','OE1'],
'GLU': ['C','CA','CB','CG','CD','OE1'],
'GLY': [],
'HIS': ['C','CA','CB','CG','ND1'],
'ILE': ['C','CA','CB','CG1','CD1'],
'LEU': ['C','CA','CB','CG','CD1'],
'LYS': ['C','CA','CB','CG','CD','CE','NZ'],
'MET': ['C','CA','CB','CG','SD','CE'],
'MSE': ['C','CA','CB','CG','SE','CE'],
'PHE': ['C','CA','CB','CG','CD1'],
'PRO': [],
'SER': ['C','CA','CB','OG'],
'THR': ['C','CA','CB','OG1'],
'TRP': ['C','CA','CB','CG','CD2'],
'TYR': ['C','CA','CB','CG','CD1'],
'VAL': ['C','CA','CB','CG2'],
}
atoms = [res + '/' + name for name in chi_atoms.get(old_resn, [])]
old_chi = []
for args in zip(atoms, atoms[1:], atoms[2:], atoms[3:]):
try:
old_chi.append(cmd.get_dihedral(*args))
except:
break
cmd.remove('%s and not name CA+C+N+O+OXT' % (res))
# start the wizard to count the number of rotamers for this residue
cmd.wizard("mutagenesis")
cmd.get_wizard().set_mode(new_resn)
cmd.get_wizard().set_hyd(hydrogens)
cmd.get_wizard().do_select("("+res+")")
def get_best_state_bump():
best_state = (1, 1e9)
cmd.create(tmp, '%s and not name CA+C+N+O or (%s within 8.0 of (%s and name CB))' % \
(mutagenesis.obj_name, cpy, mutagenesis.obj_name), zoom=0, singletons=1)
cmd.bond('name CB and %s in %s' % (tmp, mutagenesis.obj_name),
'name CA and %s in %s' % (tmp, res))
cmd.sculpt_activate(tmp)
for i in range(1, cmd.count_states(tmp)+1):
score = cmd.sculpt_iterate(tmp, state=i)
if not quiet:
print('Frame %d Score %.2f' % (i, score))
if score < best_state[1]:
best_state = (i, score)
cmd.delete(tmp)
if not quiet:
print(' Best: Frame %d Score %.2f' % best_state)
return best_state
if cmd.count_states(mutagenesis.obj_name) < 2 or mode > 0:
best_state = (1, -1.0)
else:
best_state = get_best_state_bump()
cmd.frame(best_state[0])
cmd.get_wizard().apply()
cmd.wizard()
if mode == 1:
atoms = [res + '/' + name for name in chi_atoms.get(new_resn, [])]
for args in zip(atoms, atoms[1:], atoms[2:], atoms[3:], old_chi):
cmd.set_dihedral(*args)
cmd.unpick()
if sculpt > 0:
sculpt_relax(res, 0, sculpt == 2, cpy)
return cpy
def reset(self):
cmd.delete(self.object_prefix + "*")
cmd.delete("sele*")
cmd.delete("_indicate*")
cmd.unpick()
cmd.refresh_wizard()
def mutate(selection, new_resn, inplace=0, sculpt=0, hydrogens='auto', mode=0, quiet=1):
'''
DESCRIPTION
Mutate a single residue. Does call the mutagenesis wizard non-interactively
and tries to select the best rotamer. Can do some sculpting in the end to
the best rotamer.
USAGE
mutate selection, new_resn [, inplace [, sculpt [, hydrogens]]]
ARGUMENTS
selection = string: atom selection of single residue
new_resn = string: new residue name (3-letter or 1-letter)
inplace = 0 or 1: work on copy of input object if 0 {default: 0}
sculpt = 0: no sculpting {default}
sculpt = 1: do sculpting on best rotamer
sculpt = 2: do sculpting with neighbors
hydrogens = string: keep, auto or none {default: auto}
mode = 0: select rotamer with best clash score {default}
mode = 1: take chi angles from original residue
mode = 2: first rotamer
EXAMPLE
fetch 2x19, async=0
select x, A/CYS`122/
zoom x
mutate x, LYS
'''
from pymol.wizard import mutagenesis
from . import three_letter
inplace, sculpt = int(inplace), int(sculpt)
mode = int(mode)
quiet = int(quiet)
org = cmd.get_object_list(selection)[0]
tmp = cmd.get_unused_name()
new_resn = new_resn.upper()
new_resn = three_letter.get(new_resn, new_resn)
if inplace:
cpy = org
else:
cpy = cmd.get_unused_name(org + '_cpy')
cmd.create(cpy, org, -1, 1, zoom=0)
scr = []
cmd.iterate('first (%s)' % selection, 'scr[:] = (segi,chain,resi,resn)', space={'scr': scr})
res = '/%s/%s/%s/%s' % tuple([cpy] + scr[:3])
if mode == 1:
old_resn = scr[3]
chi_atoms = {
'ALA': [],
'ARG': ['C','CA','CB','CG','CD','NE','CZ'],
'ASN': ['C','CA','CB','CG','OD1'],
'ASP': ['C','CA','CB','CG','OD1'],
'CYS': ['C','CA','CB','SG'],
'GLN': ['C','CA','CB','CG','CD','OE1'],
'GLU': ['C','CA','CB','CG','CD','OE1'],
'GLY': [],
'HIS': ['C','CA','CB','CG','ND1'],
'ILE': ['C','CA','CB','CG1','CD1'],
'LEU': ['C','CA','CB','CG','CD1'],
'LYS': ['C','CA','CB','CG','CD','CE','NZ'],
'MET': ['C','CA','CB','CG','SD','CE'],
'MSE': ['C','CA','CB','CG','SE','CE'],
'PHE': ['C','CA','CB','CG','CD1'],
'PRO': [],
'SER': ['C','CA','CB','OG'],
'THR': ['C','CA','CB','OG1'],
'TRP': ['C','CA','CB','CG','CD2'],
'TYR': ['C','CA','CB','CG','CD1'],
'VAL': ['C','CA','CB','CG2'],
}
atoms = [res + '/' + name for name in chi_atoms.get(old_resn, [])]
old_chi = []
for args in zip(atoms, atoms[1:], atoms[2:], atoms[3:]):
try:
old_chi.append(cmd.get_dihedral(*args))
except:
break
cmd.remove('%s and not name CA+C+N+O+OXT' % (res))
# start the wizard to count the number of rotamers for this residue
cmd.wizard("mutagenesis")
cmd.get_wizard().set_mode(new_resn)
cmd.get_wizard().set_hyd(hydrogens)
cmd.get_wizard().do_select("("+res+")")
def get_best_state_bump():
best_state = (1, 1e9)
cmd.create(tmp, '%s and not name CA+C+N+O or (%s within 8.0 of (%s and name CB))' % \
(mutagenesis.obj_name, cpy, mutagenesis.obj_name), zoom=0, singletons=1)
cmd.bond('name CB and %s in %s' % (tmp, mutagenesis.obj_name),
'name CA and %s in %s' % (tmp, res))
cmd.sculpt_activate(tmp)
for i in range(1, cmd.count_states(tmp)+1):
score = cmd.sculpt_iterate(tmp, state=i)
if not quiet:
print('Frame %d Score %.2f' % (i, score))
if score < best_state[1]:
best_state = (i, score)
cmd.delete(tmp)
if not quiet:
print(' Best: Frame %d Score %.2f' % best_state)
return best_state
if cmd.count_states(mutagenesis.obj_name) < 2 or mode > 0:
best_state = (1, -1.0)
else:
best_state = get_best_state_bump()
cmd.frame(best_state[0])
cmd.get_wizard().apply()
cmd.wizard()
if mode == 1:
atoms = [res + '/' + name for name in chi_atoms.get(new_resn, [])]
for args in zip(atoms, atoms[1:], atoms[2:], atoms[3:], old_chi):
cmd.set_dihedral(*args)
cmd.unpick()
if sculpt > 0:
sculpt_relax(res, 0, sculpt == 2, cpy)
return cpy
def add_missing_atoms(selection='all', cycles=200, quiet=1):
'''
DESCRIPTION
Mutate those residues to themselves which have missing atoms
SEE ALSO
stub2ala
'''
from collections import defaultdict
from chempy import fragments
cycles, quiet = int(cycles), int(quiet)
reference = {
'ALA': set(['CB']),
'ARG': set(['CB', 'CG', 'NE', 'CZ', 'NH1', 'NH2', 'CD']),
'ASN': set(['CB', 'CG', 'OD1', 'ND2']),
'ASP': set(['CB', 'CG', 'OD1', 'OD2']),
'CYS': set(['CB', 'SG']),
'GLN': set(['CB', 'CG', 'CD', 'NE2', 'OE1']),
'GLU': set(['CB', 'CG', 'OE2', 'CD', 'OE1']),
'GLY': set([]),
'HIS': set(['CE1', 'CB', 'CG', 'CD2', 'ND1', 'NE2']),
'ILE': set(['CB', 'CD1', 'CG1', 'CG2']),
'LEU': set(['CB', 'CG', 'CD1', 'CD2']),
'LYS': set(['CB', 'CG', 'NZ', 'CE', 'CD']),
'MET': set(['CB', 'CG', 'CE', 'SD']),
'PHE': set(['CE1', 'CB', 'CG', 'CZ', 'CD1', 'CD2', 'CE2']),
'PRO': set(['CB', 'CG', 'CD']),
'SER': set(['OG', 'CB']),
'THR': set(['CB', 'OG1', 'CG2']),
'TRP': set(['CZ2', 'CB', 'CG', 'CH2', 'CE3', 'CD1', 'CD2', 'CZ3', 'NE1', 'CE2']),
'TYR': set(['CE1', 'OH', 'CB', 'CG', 'CZ', 'CD1', 'CD2', 'CE2']),
'VAL': set(['CB', 'CG1', 'CG2']),
}
namedsele = cmd.get_unused_name('_')
cmd.select(namedsele, selection, 0)
namelists = defaultdict(list)
cmd.iterate('(%s) and polymer' % namedsele,
'namelists[model,segi,chain,resn,resi,resv].append(name)',
space=locals())
sele_dict = defaultdict(list)
tmp_name = cmd.get_unused_name('_')
for key, namelist in namelists.items():
resn = key[3]
if resn not in reference:
if not quiet:
print(' Unknown residue:', resn)
continue
if not reference[resn].issubset(namelist):
try:
frag = fragments.get(resn.lower())
for a in frag.atom:
a.segi = key[1]
a.chain = key[2]
a.resi = key[4]
a.resi_number = key[5]
cmd.load_model(frag, tmp_name, 1, zoom=0)
skey = '/%s/%s/%s/%s`%s' % key[:5]
cmd.remove(skey + ' and not name N+C+O+OXT+CA')
cmd.align(tmp_name, skey + ' and name N+C+CA', cycles=0)
cmd.remove(tmp_name + ' and (name N+C+O+CA or hydro)')
cmd.fuse('name CB and ' + tmp_name, 'name CA and ' + skey, move=0)
if resn == 'PRO':
cmd.bond(skey + '/N', skey + '/CD')
cmd.unpick()
cmd.delete(tmp_name)
sele_dict[key[0]].append(skey)
if not quiet:
print(' Mutated ', skey)
except:
print(' Mutating', skey, 'failed')
for model in sele_dict:
cmd.sort(model)
sculpt_relax(' '.join(sele_dict[model]), 0, 0, model, cycles)
cmd.delete(namedsele)
def reset(self):
cmd.delete(self.object_prefix + "*")
cmd.delete("sele*")
cmd.delete("_indicate*")
cmd.unpick()
cmd.refresh_wizard()
def do_pick(self, bondFlag):
self.do_select('(pk1)')
cmd.unpick()
def __init__(self,_self=cmd):
Wizard.__init__(self,_self)
cmd=self.cmd
if self.cmd.get_movie_length() > 0:
raise pymol.wizarding.WizardError('Mutagenesis Wizard cannot be used with Movie')
cmd.unpick()
self.stored = pymol.Scratch_Storage()
self.space = {'stored': self.stored}
self.bump_scores = []
self.dep = default_dep
self.ind_library = io.pkl.fromFile(os.environ['PYMOL_DATA']+
"/chempy/sidechains/sc_bb_ind.pkl")
self.load_library()
self.status = 0 # 0 no selection, 1 mutagenizing
self.bump_check = 1
self.auto_center = 1
self.error = None
self.object_name = None
self.modes = [
'current'
]
self.mode = default_mode
self.rep = default_rep
self.hyd = default_hyd
self.n_cap = default_n_cap
self.c_cap = default_c_cap
residues = list(self.ind_library.keys())
# could extent with additional fragments manually as below
residues.extend(['GLY','ALA'])
residues.extend(['HID','HIE','HIP'])
residues.extend(['ARGN','LYSN','ASPH','GLUH'])
residues.sort()
res_copy = deepcopy(residues)
for a in res_copy:
residues.append('NT_'+a)
residues.append('CT_'+a)
self.modes.extend(residues)
self.mode_label={}
for a in self.modes:
self.mode_label[a] = ""+a
self.mode_label['current']="No Mutant"
self.selection_mode = cmd.get_setting_int("mouse_selection_mode")
cmd.set("mouse_selection_mode",1)
smm = []
smm.append([ 2, 'Mutant', '' ])
smm.append([ 1, 'No change', 'cmd.get_wizard().set_mode("current")' ])
# smm.append([ 1, 'N-Term', [] ])
# smm.append([ 1, 'C-Term', [] ])
smm.append([ 0, '', '' ])
for a in self.modes:
if a == 'current':
pass
elif a[0:3]=='NT_':
pass
# smm[2][2].append([ 1, self.mode_label[a[3:]], 'cmd.get_wizard().set_mode("'+a+'")'])
elif a[0:3]=='CT_':
pass
# smm[3][2].append([ 1, self.mode_label[a[3:]], 'cmd.get_wizard().set_mode("'+a+'")'])
else:
smm.append([ 1, self.mode_label[a], 'cmd.get_wizard().set_mode("'+a+'")'])
# group arg, lys, his, glu, asp
for lst in [ smm ]: # [ smm, smm[2][2], smm[3][2] ]:
for a in 'ARG','LYS','HID','GLU','ASP':
ix = 0
start = 0
stop = 0
for b in lst:
if start==0:
if b[1][0:]==a:
start = ix
stop = ix + 1
elif b[1][0:3]==a[0:3] or ( b[1][0:2]==a[0:2] and a[0:2]=='HI' ):
stop = ix + 1
ix = ix + 1
if start!=0 and stop!=0:
slice = lst[start:stop]
if a != 'HID':
slice2 = [slice[0] ] + [ [0,'',''] ] + slice[1:]
lst[start:stop] = [ [1, self.mode_label[a] + "... " , slice2 ] ]
else:
slice2 = [ slice[3] ] + [ [0,'',''] ] + slice[0:3]
lst[start:stop] = [ [1, self.mode_label['HIS']+ "... ", slice2 ] ]
self.menu['mode']=smm
self.reps = [
'lines',
'sticks',
'spheres',
'dots'
]
self.rep_name = {
'lines' : "Show Lines",
'sticks' : "Show Sticks",
'spheres' : "Show Spheres",
'dots' : "Show Dots",
}
self.dep_name = {
'dep' : "Backbone Depen. Rotamers",
'ind' : "Backbone Indep. Rotamers"
}
self.hyd_name = {
'auto' : "Hydrogens: Current",
'keep' : "Hydrogens: Add & Retain",
# 'polar' : "Polar Hydrogens",
'none' : "Hydrogens: Remove",
}
self.hyds = [ 'auto', 'keep', 'none' ]
self.n_cap_name = {
'none' : 'Open',
'posi' : 'NH3+',
'acet' : 'Acetyl',
}
self.n_caps = [ 'none', 'posi', 'acet' ]
self.c_cap_name = {
'none' : 'Open',
'nega' : 'COO-',
'amin' : 'Amine',
'nmet' : 'N-methyl',
}
self.c_caps = [ 'none', 'nega', 'amin', 'nmet' ]
smm = []
smm.append([ 2, 'N-Cap', '' ])
for a in self.n_caps:
smm.append([ 1, self.n_cap_name[a], 'cmd.get_wizard().set_n_cap("'+a+'")'])
self.menu['n_cap']=smm
smm = []
smm.append([ 2, 'C-Cap', '' ])
for a in self.c_caps:
smm.append([ 1, self.c_cap_name[a], 'cmd.get_wizard().set_c_cap("'+a+'")'])
self.menu['c_cap']=smm
smm = []
smm.append([ 2, 'Hydrogens', '' ])
for a in self.hyds:
smm.append([ 1, self.hyd_name[a], 'cmd.get_wizard().set_hyd("'+a+'")'])
self.menu['hyd']=smm
smm = []
smm.append([ 2, 'Representation', '' ])
for a in self.reps:
smm.append([ 1, self.rep_name[a], 'cmd.get_wizard().set_rep("'+a+'")'])
self.menu['rep']=smm
self.deps = [ 'dep', 'ind' ]
smm = []
smm.append([ 2, 'Rotamers', '' ])
for a in self.deps:
smm.append([ 1, self.dep_name[a], 'cmd.get_wizard().set_dep("'+a+'")'])
self.menu['dep']=smm
if 'pk1' in cmd.get_names('selections'):
cmd.select(src_sele,"(byres pk1)")
cmd.unpick()
cmd.enable(src_sele)
self.status = 1
self.error = None
self.do_library()
cmd.refresh_wizard()
def do_library(self):
cmd=self.cmd
pymol=cmd._pymol
if not ((cmd.count_atoms("(%s) and name N"%src_sele)==1) and
(cmd.count_atoms("(%s) and name C"%src_sele)==1) and
(cmd.count_atoms("(%s) and name O"%src_sele)==1)):
self.clear()
return 1
cmd.feedback("push")
cmd.feedback("disable","selector","everythin")
cmd.feedback("disable","editor","actions")
self.prompt = [ 'Loading rotamers...']
self.bump_scores = []
state_best = 0
pymol.stored.name = 'residue'
cmd.iterate("first (%s)"%src_sele,'stored.name=model+"/"+segi+"/"+chain+"/"+resn+"`"+resi')
self.res_text = pymol.stored.name
cmd.select("_seeker_hilight",src_sele)
auto_zoom = cmd.get_setting_text('auto_zoom')
cmd.set('auto_zoom',"0",quiet=1)
cmd.frame(0)
cmd.delete(frag_name)
if self.auto_center:
cmd.center(src_sele,animate=-1)
self.lib_mode = self.mode
if self.lib_mode=="current":
pymol.stored.resn=""
cmd.iterate("(%s & name CA)"%src_sele,"stored.resn=resn")
rot_type = _rot_type_xref.get(pymol.stored.resn,pymol.stored.resn)
if (self.c_cap!='none') or (self.n_cap!='none') or (self.hyd != 'auto'):
self.lib_mode = rot_type # force fragment-based load
else:
cmd.create(frag_name,src_sele,1,1)
if self.c_cap=='open':
cmd.remove("%s and name OXT"%frag_name)
if self.lib_mode!='current':
rot_type = self.lib_mode
frag_type = self.lib_mode
if (self.n_cap == 'posi') and (frag_type[0:3]!='NT_'):
if not ( cmd.count_atoms(
"elem C & !(%s) & (bto. (name N & (%s))) &! resn ACE"%
(src_sele,src_sele))):
# use N-terminal fragment
frag_type ="NT_"+frag_type
if (self.c_cap == 'nega') and (frag_type[0:3]!='CT_'):
if not ( cmd.count_atoms("elem N & !(%s) & (bto. (name C & (%s))) & !resn NME+NHH"%
(src_sele,src_sele))):
# use C-terminal fragment
frag_type ="CT_"+frag_type
if rot_type[0:3] in [ 'NT_', 'CT_' ]:
rot_type = rot_type[3:]
rot_type = _rot_type_xref.get(rot_type, rot_type)
cmd.fragment(frag_type.lower(), frag_name, origin=0)
# trim off hydrogens
if (self.hyd == 'none'):
cmd.remove("("+frag_name+" and hydro)")
elif (self.hyd == 'auto'):
if cmd.count_atoms("("+src_sele+") and hydro")==0:
cmd.remove("("+frag_name+" and hydro)")
# copy identifying information
cmd.alter("?%s & name CA" % src_sele, "stored.identifiers = (segi, chain, resi, ss, color)", space=self.space)
cmd.alter("?%s" % frag_name, "(segi, chain, resi, ss) = stored.identifiers[:4]", space=self.space)
# move the fragment
if ((cmd.count_atoms("(%s & name CB)"%frag_name)==1) and
(cmd.count_atoms("(%s & name CB)"%src_sele)==1)):
cmd.pair_fit("(%s & name CA)"%frag_name,
"(%s & name CA)"%src_sele,
"(%s & name CB)"%frag_name,
"(%s & name CB)"%src_sele,
"(%s & name C)"%frag_name,
"(%s & name C)"%src_sele,
"(%s & name N)"%frag_name,
"(%s & name N)"%src_sele)
else:
cmd.pair_fit("(%s & name CA)"%frag_name,
"(%s & name CA)"%src_sele,
"(%s & name C)"%frag_name,
"(%s & name C)"%src_sele,
"(%s & name N)"%frag_name,
"(%s & name N)"%src_sele)
# fix the carbonyl position...
cmd.iterate_state(1,"(%s & name O)"%src_sele,"stored.list=[x,y,z]")
cmd.alter_state(1,"(%s & name O)"%frag_name,"(x,y,z)=stored.list")
if cmd.count_atoms("(%s & name OXT)"%src_sele):
cmd.iterate_state(1,"(%s & name OXT)"%src_sele,"stored.list=[x,y,z]")
cmd.alter_state(1,"(%s & name OXT)"%frag_name,"(x,y,z)=stored.list")
elif cmd.count_atoms("(%s & name OXT)"%frag_name): # place OXT if no template exists
angle = cmd.get_dihedral("(%s & name N)"%frag_name,
"(%s & name CA)"%frag_name,
"(%s & name C)"%frag_name,
"(%s & name O)"%frag_name)
cmd.protect("(%s & name O)"%frag_name)
cmd.set_dihedral("(%s & name N)"%frag_name,
"(%s & name CA)"%frag_name,
"(%s & name C)"%frag_name,
"(%s & name OXT)"%frag_name,180.0+angle)
cmd.deprotect(frag_name)
# fix the hydrogen position (if any)
if cmd.count_atoms("(hydro and bound_to (name N & (%s)))"%frag_name)==1:
if cmd.count_atoms("(hydro and bound_to (name N & (%s)))"%src_sele)==1:
cmd.iterate_state(1,"(hydro and bound_to (name N & (%s)))"%src_sele,
"stored.list=[x,y,z]")
cmd.alter_state(1,"(hydro and bound_to (name N & (%s)))"%frag_name,
"(x,y,z)=stored.list")
elif cmd.select(tmp_sele1,"(name C & bound_to (%s and elem N))"%src_sele)==1:
# position hydro based on location of the carbonyl
angle = cmd.get_dihedral("(%s & name C)"%frag_name,
"(%s & name CA)"%frag_name,
"(%s & name N)"%frag_name,
tmp_sele1)
cmd.set_dihedral("(%s & name C)"%frag_name,
"(%s & name CA)"%frag_name,
"(%s & name N)"%frag_name,
"(%s & name H)"%frag_name,180.0+angle)
cmd.delete(tmp_sele1)
# add c-cap (if appropriate)
if self.c_cap in [ 'amin', 'nmet' ]:
if not cmd.count_atoms("elem N & !(%s) & (bto. (name C & (%s))) & !resn NME+NHH"%
(src_sele,src_sele)):
if cmd.count_atoms("name C & (%s)"%(frag_name))==1:
if self.c_cap == 'amin':
editor.attach_amino_acid("name C & (%s)"%(frag_name), 'nhh')
elif self.c_cap == 'nmet':
editor.attach_amino_acid("name C & (%s)"%(frag_name), 'nme')
if cmd.count_atoms("hydro & bound_to (name N & bound_to (name C & (%s)))"%frag_name):
cmd.h_fix("name N & bound_to (name C & (%s))"%frag_name)
# trim hydrogens
if (self.hyd == 'none'):
cmd.remove("("+frag_name+" and hydro)")
elif (self.hyd == 'auto'):
if cmd.count_atoms("("+src_sele+") and hydro")==0:
cmd.remove("("+frag_name+" and hydro)")
# add n-cap (if appropriate)
if self.n_cap in [ 'acet' ]:
if not cmd.count_atoms("elem C & !(%s) & (bto. (name N & (%s))) & !resn ACE "%
(src_sele,src_sele)):
if cmd.count_atoms("name N & (%s)"%(frag_name))==1:
if self.n_cap == 'acet':
editor.attach_amino_acid("name N & (%s)"%(frag_name), 'ace')
if cmd.count_atoms("hydro & bound_to (name N & bound_to (name C & (%s)))"%frag_name):
cmd.h_fix("name N & (%s)"%frag_name)
# trim hydrogens
if (self.hyd == 'none'):
cmd.remove("("+frag_name+" and hydro)")
elif (self.hyd == 'auto'):
if cmd.count_atoms("("+src_sele+") and hydro")==0:
cmd.remove("("+frag_name+" and hydro)")
cartoon = (cmd.count_atoms("(%s & name CA & rep cartoon)"%src_sele)>0)
sticks = (cmd.count_atoms("(%s & name CA & rep sticks)"%src_sele)>0)
cmd.delete(obj_name)
key = rot_type
lib = None
if self.dep == 'dep':
try:
result = cmd.phi_psi("%s"%src_sele)
if len(result)==1:
(phi,psi) = list(result.values())[0]
(phi,psi) = (int(10*round(phi/10)),int(10*(round(psi/10))))
key = (rot_type,phi,psi)
if key not in self.dep_library:
(phi,psi) = (int(20*round(phi/20)),int(20*(round(psi/20))))
key = (rot_type,phi,psi)
if key not in self.dep_library:
(phi,psi) = (int(60*round(phi/60)),int(60*(round(psi/60))))
key = (rot_type,phi,psi)
lib = self.dep_library.get(key,None)
except:
pass
if lib is None:
key = rot_type
lib = self.ind_library.get(key,None)
if (lib is not None) and self.dep == 'dep':
print(' Mutagenesis: no phi/psi, using backbone-independent rotamers.')
if lib is not None:
state = 1
for a in lib:
cmd.create(obj_name,frag_name,1,state)
if state == 1:
cmd.select(mut_sele,"(byres (%s like %s))"%(obj_name,src_sele))
if rot_type=='PRO':
cmd.unbond("(%s & name N)"%mut_sele,"(%s & name CD)"%mut_sele)
for b in a.keys():
if b!='FREQ':
cmd.set_dihedral("(%s & n;%s)"%(mut_sele,b[0]),
"(%s & n;%s)"%(mut_sele,b[1]),
"(%s & n;%s)"%(mut_sele,b[2]),
"(%s & n;%s)"%(mut_sele,b[3]),
a[b],state=state)
else:
cmd.set_title(obj_name,state,"%1.1f%%"%(a[b]*100))
if rot_type=='PRO':
cmd.bond("(%s & name N)"%mut_sele,"(%s & name CD)"%mut_sele)
state = state + 1
cmd.delete(frag_name)
print(" Mutagenesis: %d rotamers loaded."%len(lib))
if self.bump_check:
cmd.delete(bump_name)
cmd.create(bump_name,
"(((byobj %s) within 6 of (%s and not name N+C+CA+O+H+HA)) and (not (%s)))|(%s)"%
(src_sele,mut_sele,src_sele,mut_sele),singletons=1)
cmd.color("gray50",bump_name+" and elem C")
cmd.set("seq_view",0,bump_name,quiet=1)
cmd.hide("everything",bump_name)
if ((cmd.select(tmp_sele1, "(name N & (%s in (neighbor %s)))"%
(bump_name,src_sele)) == 1) and
(cmd.select(tmp_sele2, "(name C & (%s in %s))"%
(bump_name,mut_sele)) == 1)):
cmd.bond(tmp_sele1,tmp_sele2)
if ((cmd.select(tmp_sele1,"(name C & (%s in (neighbor %s)))"%
(bump_name,src_sele)) == 1) and
(cmd.select(tmp_sele2,"(name N & (%s in %s))"%
(bump_name,mut_sele)) == 1)):
cmd.bond(tmp_sele1,tmp_sele2)
cmd.delete(tmp_sele1)
cmd.delete(tmp_sele2)
cmd.protect("%s and not (%s in (%s and not name N+C+CA+O+H+HA))"%
(bump_name,bump_name,mut_sele))
cmd.sculpt_activate(bump_name)
cmd.show("cgo",bump_name)
# draw the bumps
cmd.set("sculpt_vdw_vis_mode",1,bump_name)
state = 1
score_best = 1e6
for a in lib:
score = cmd.sculpt_iterate(bump_name, state, 1)
self.bump_scores.append(score)
if score < score_best:
state_best = state
score_best = score
state = state + 1
cmd.delete(mut_sele)
else:
cmd.create(obj_name,frag_name,1,1)
print(" Mutagenesis: no rotamers found in library.")
cmd.set("seq_view",0,obj_name,quiet=1)
pymol.util.cbaw(obj_name)
cmd.hide("("+obj_name+")")
cmd.show(self.rep,obj_name)
cmd.show('lines',obj_name) #neighbor always show lines
if cartoon:
cmd.show("cartoon",obj_name)
if sticks:
cmd.show("sticks",obj_name)
cmd.set('auto_zoom',auto_zoom,quiet=1)
cmd.delete(frag_name)
cmd.frame(state_best)
cmd.unpick()
cmd.feedback("pop")
def do_select(self,name): # map selects into picks
cmd.unpick()
cmd.edit(name)
cmd.delete(name)
self.do_pick(0)
def do_library(self):
cmd = self.cmd
pymol = cmd._pymol
if not (
(cmd.count_atoms("(%s) and name n" % src_sele) == 1)
and (cmd.count_atoms("(%s) and name c" % src_sele) == 1)
and (cmd.count_atoms("(%s) and name o" % src_sele) == 1)
):
self.clear()
return 1
cmd.feedback("push")
cmd.feedback("disable", "selector", "everythin")
cmd.feedback("disable", "editor", "actions")
self.prompt = ["Loading rotamers..."]
pymol.stored.name = "residue"
cmd.iterate("first (%s)" % src_sele, 'stored.name=model+"/"+segi+"/"+chain+"/"+resn+"`"+resi')
self.res_text = pymol.stored.name
cmd.select("_seeker_hilight", src_sele)
auto_zoom = cmd.get_setting_text("auto_zoom")
cmd.set("auto_zoom", "0", quiet=1)
cmd.frame(0)
cmd.delete(frag_name)
if self.auto_center:
cmd.center(src_sele, animate=-1)
self.lib_mode = self.mode
if self.lib_mode == "current":
pymol.stored.resn = ""
cmd.iterate("(%s and n;ca)" % src_sele, "stored.resn=resn")
rot_type = _rot_type_xref.get(pymol.stored.resn, pymol.stored.resn)
if (self.c_cap != "none") or (self.n_cap != "none") or (self.hyd != "auto"):
self.lib_mode = rot_type # force fragment-based load
else:
cmd.create(frag_name, src_sele, 1, 1)
if self.c_cap == "open":
cmd.remove("%s and name OXT" % frag_name)
if self.lib_mode != "current":
rot_type = self.lib_mode
frag_type = self.lib_mode
if (self.n_cap == "posi") and (frag_type[0:3] != "NT_"):
if not (cmd.count_atoms("elem c & !(%s) & (bto. (n;n & (%s))) &! r. ace" % (src_sele, src_sele))):
# use N-terminal fragment
frag_type = "NT_" + frag_type
if (self.c_cap == "nega") and (frag_type[0:3] != "CT_"):
if not (cmd.count_atoms("elem n & !(%s) & (bto. (n;c & (%s))) & !r. nme+nhh" % (src_sele, src_sele))):
# use C-terminal fragment
frag_type = "CT_" + frag_type
if rot_type[0:3] in ["NT_", "CT_"]:
rot_type = rot_type[3:]
rot_type = _rot_type_xref.get(rot_type, rot_type)
cmd.fragment(string.lower(frag_type), frag_name)
# trim off hydrogens
if self.hyd == "none":
cmd.remove("(" + frag_name + " and hydro)")
elif self.hyd == "auto":
if cmd.count_atoms("(" + src_sele + ") and hydro") == 0:
cmd.remove("(" + frag_name + " and hydro)")
# copy identifying information
cmd.iterate("(%s and n;ca)" % src_sele, "stored.chain=chain")
cmd.alter("(%s)" % frag_name, "chain=stored.chain")
cmd.iterate("(%s and n;ca)" % src_sele, "stored.resi=resi")
cmd.alter("(%s)" % frag_name, "resi=stored.resi")
cmd.iterate("(%s and n;ca)" % src_sele, "stored.segi=segi")
cmd.alter("(%s)" % frag_name, "segi=stored.segi")
cmd.iterate("(%s and n;ca)" % src_sele, "stored.ss=ss")
cmd.alter("(%s)" % frag_name, "ss=stored.ss")
# move the fragment
if (cmd.count_atoms("(%s and n;cb)" % frag_name) == 1) and (
cmd.count_atoms("(%s and n;cb)" % src_sele) == 1
):
cmd.pair_fit(
"(%s and n;ca)" % frag_name,
"(%s and n;ca)" % src_sele,
"(%s and n;cb)" % frag_name,
"(%s and n;cb)" % src_sele,
"(%s and n;c)" % frag_name,
"(%s and n;c)" % src_sele,
"(%s and n;n)" % frag_name,
"(%s and n;n)" % src_sele,
)
else:
cmd.pair_fit(
"(%s and n;ca)" % frag_name,
"(%s and n;ca)" % src_sele,
"(%s and n;c)" % frag_name,
"(%s and n;c)" % src_sele,
"(%s and n;n)" % frag_name,
"(%s and n;n)" % src_sele,
)
# fix the carbonyl position...
cmd.iterate_state(1, "(%s and n;o)" % src_sele, "stored.list=[x,y,z]")
cmd.alter_state(1, "(%s and n;o)" % frag_name, "(x,y,z)=stored.list")
if cmd.count_atoms("(%s and n;oxt)" % src_sele):
cmd.iterate_state(1, "(%s and n;oxt)" % src_sele, "stored.list=[x,y,z]")
cmd.alter_state(1, "(%s and n;oxt)" % frag_name, "(x,y,z)=stored.list")
elif cmd.count_atoms("(%s and n;oxt)" % frag_name): # place OXT if no template exists
angle = cmd.get_dihedral(
"(%s and n;n)" % frag_name,
"(%s and n;ca)" % frag_name,
"(%s and n;c)" % frag_name,
"(%s and n;o)" % frag_name,
)
cmd.protect("(%s and n;o)" % frag_name)
cmd.set_dihedral(
"(%s and n;n)" % frag_name,
"(%s and n;ca)" % frag_name,
"(%s and n;c)" % frag_name,
"(%s and n;oxt)" % frag_name,
180.0 + angle,
)
cmd.deprotect(frag_name)
# fix the hydrogen position (if any)
if cmd.count_atoms("(elem h and bound_to (n;n and (%s)))" % frag_name) == 1:
if cmd.count_atoms("(elem h and bound_to (n;n and (%s)))" % src_sele) == 1:
cmd.iterate_state(1, "(elem h and bound_to (n;n and (%s)))" % src_sele, "stored.list=[x,y,z]")
cmd.alter_state(1, "(elem h and bound_to (n;n and (%s)))" % frag_name, "(x,y,z)=stored.list")
elif cmd.select(tmp_sele1, "(n;c and bound_to (%s and e;n))" % src_sele) == 1:
# position hydro based on location of the carbonyl
angle = cmd.get_dihedral(
"(%s and n;c)" % frag_name, "(%s and n;ca)" % frag_name, "(%s and n;n)" % frag_name, tmp_sele1
)
cmd.set_dihedral(
"(%s and n;c)" % frag_name,
"(%s and n;ca)" % frag_name,
"(%s and n;n)" % frag_name,
"(%s and n;h)" % frag_name,
180.0 + angle,
)
cmd.delete(tmp_sele1)
# add c-cap (if appropriate)
if self.c_cap in ["amin", "nmet"]:
if not cmd.count_atoms("elem n & !(%s) & (bto. (n;c & (%s))) & !r. nme+nhh" % (src_sele, src_sele)):
if cmd.count_atoms("n;c & (%s)" % (frag_name)) == 1:
if self.c_cap == "amin":
editor.attach_amino_acid("n;c & (%s)" % (frag_name), "nhh")
elif self.c_cap == "nmet":
editor.attach_amino_acid("n;c & (%s)" % (frag_name), "nme")
if cmd.count_atoms("hydro & bound_to (n;n & bound_to (n;c & (%s)))" % frag_name):
cmd.h_fix("n;n & bound_to (n;c & (%s))" % frag_name)
# trim hydrogens
if self.hyd == "none":
cmd.remove("(" + frag_name + " and hydro)")
elif self.hyd == "auto":
if cmd.count_atoms("(" + src_sele + ") and hydro") == 0:
cmd.remove("(" + frag_name + " and hydro)")
# add n-cap (if appropriate)
if self.n_cap in ["acet"]:
if not cmd.count_atoms("elem c & !(%s) & (bto. (n;n & (%s))) & !r. ace " % (src_sele, src_sele)):
if cmd.count_atoms("n;n & (%s)" % (frag_name)) == 1:
if self.n_cap == "acet":
editor.attach_amino_acid("n;n & (%s)" % (frag_name), "ace")
if cmd.count_atoms("hydro & bound_to (n;n & bound_to (n;c & (%s)))" % frag_name):
cmd.h_fix("n;n & (%s)" % frag_name)
# trim hydrogens
if self.hyd == "none":
cmd.remove("(" + frag_name + " and hydro)")
elif self.hyd == "auto":
if cmd.count_atoms("(" + src_sele + ") and hydro") == 0:
cmd.remove("(" + frag_name + " and hydro)")
cartoon = cmd.count_atoms("(%s and n;ca and rep cartoon)" % src_sele) > 0
sticks = cmd.count_atoms("(%s and n;ca and rep sticks)" % src_sele) > 0
cmd.delete(obj_name)
key = rot_type
lib = None
if self.dep == "dep":
try:
result = cmd.phi_psi("%s" % src_sele)
if len(result) == 1:
(phi, psi) = result[result.keys()[0]]
(phi, psi) = (int(10 * round(phi / 10)), int(10 * (round(psi / 10))))
key = (rot_type, phi, psi)
if not self.dep_library.has_key(key):
(phi, psi) = (int(20 * round(phi / 20)), int(20 * (round(psi / 20))))
key = (rot_type, phi, psi)
if not self.dep_library.has_key(key):
(phi, psi) = (int(60 * round(phi / 60)), int(60 * (round(psi / 60))))
key = (rot_type, phi, psi)
lib = self.dep_library.get(key, None)
except:
pass
if lib == None:
key = rot_type
lib = self.ind_library.get(key, None)
if (lib != None) and self.dep == "dep":
print " Mutagenesis: no phi/psi, using backbone-independent rotamers."
if lib != None:
state = 1
for a in lib:
cmd.create(obj_name, frag_name, 1, state)
if state == 1:
cmd.select(mut_sele, "(byres (%s like %s))" % (obj_name, src_sele))
if rot_type == "PRO":
cmd.unbond("(%s & name N)" % mut_sele, "(%s & name CD)" % mut_sele)
for b in a.keys():
if b != "FREQ":
cmd.set_dihedral(
"(%s & n;%s)" % (mut_sele, b[0]),
"(%s & n;%s)" % (mut_sele, b[1]),
"(%s & n;%s)" % (mut_sele, b[2]),
"(%s & n;%s)" % (mut_sele, b[3]),
a[b],
state=state,
)
else:
cmd.set_title(obj_name, state, "%1.1f%%" % (a[b] * 100))
if rot_type == "PRO":
cmd.bond("(%s & name N)" % mut_sele, "(%s & name CD)" % mut_sele)
state = state + 1
cmd.delete(frag_name)
print " Mutagenesis: %d rotamers loaded." % len(lib)
if self.bump_check:
cmd.delete(bump_name)
cmd.create(
bump_name,
"(((byobj %s) within 6 of (%s and not name n+c+ca+o+h+ha)) and (not (%s)))|(%s)"
% (src_sele, mut_sele, src_sele, mut_sele),
singletons=1,
)
cmd.color("gray50", bump_name + " and elem c")
cmd.set("seq_view", 0, bump_name, quiet=1)
cmd.hide("everything", bump_name)
if (cmd.select(tmp_sele1, "(n;N and (%s in (neighbor %s)))" % (bump_name, src_sele)) == 1) and (
cmd.select(tmp_sele2, "(n;C and (%s in %s))" % (bump_name, mut_sele)) == 1
):
cmd.bond(tmp_sele1, tmp_sele2)
if (cmd.select(tmp_sele1, "(n;C and (%s in (neighbor %s)))" % (bump_name, src_sele)) == 1) and (
cmd.select(tmp_sele2, "(n;N and (%s in %s))" % (bump_name, mut_sele)) == 1
):
cmd.bond(tmp_sele1, tmp_sele2)
cmd.delete(tmp_sele1)
cmd.delete(tmp_sele2)
cmd.protect("%s and not (%s in (%s and not name n+c+ca+o+h+ha))" % (bump_name, bump_name, mut_sele))
cmd.sculpt_activate(bump_name)
cmd.show("cgo", bump_name)
# draw the bumps
cmd.set("sculpt_vdw_vis_mode", 1, bump_name)
state = 1
for a in lib:
cmd.sculpt_iterate(bump_name, state=state)
state = state + 1
cmd.delete(mut_sele)
else:
cmd.create(obj_name, frag_name, 1, 1)
print " Mutagenesis: no rotamers found in library."
cmd.set("seq_view", 0, obj_name, quiet=1)
pymol.util.cbaw(obj_name)
cmd.hide("(" + obj_name + ")")
cmd.show(self.rep, obj_name)
cmd.show("lines", obj_name) # neighbor always show lines
if cartoon:
cmd.show("cartoon", obj_name)
if sticks:
cmd.show("sticks", obj_name)
cmd.set("auto_zoom", auto_zoom, quiet=1)
cmd.delete(frag_name)
cmd.frame(0)
cmd.unpick()
cmd.feedback("pop")
def __init__(self, _self=cmd):
Wizard.__init__(self, _self)
cmd = self.cmd
pymol = cmd._pymol
cmd.unpick()
self.dep = default_dep
self.ind_library = io.pkl.fromFile(os.environ["PYMOL_PATH"] + "/data/chempy/sidechains/sc_bb_ind.pkl")
self.load_library()
self.status = 0 # 0 no selection, 1 mutagenizing
self.bump_check = 1
self.auto_center = 1
self.error = None
self.object_name = None
self.modes = ["current"]
self.mode = default_mode
self.rep = default_rep
self.hyd = default_hyd
self.n_cap = default_n_cap
self.c_cap = default_c_cap
residues = self.ind_library.keys()
# could extent with additional fragments manually as below
residues.extend(["GLY", "ALA"])
residues.extend(["HID", "HIE", "HIP"])
residues.extend(["ARGN", "LYSN", "ASPH", "GLUH"])
residues.sort()
res_copy = deepcopy(residues)
for a in res_copy:
residues.append("NT_" + a)
residues.append("CT_" + a)
self.modes.extend(residues)
self.mode_label = {}
for a in self.modes:
self.mode_label[a] = "" + a
self.mode_label["current"] = "No Mutant"
self.selection_mode = cmd.get_setting_legacy("mouse_selection_mode")
cmd.set("mouse_selection_mode", 1)
smm = []
smm.append([2, "Mutant", ""])
smm.append([1, "No change", 'cmd.get_wizard().set_mode("current")'])
# smm.append([ 1, 'N-Term', [] ])
# smm.append([ 1, 'C-Term', [] ])
smm.append([0, "", ""])
for a in self.modes:
if a == "current":
pass
elif a[0:3] == "NT_":
pass
# smm[2][2].append([ 1, self.mode_label[a[3:]], 'cmd.get_wizard().set_mode("'+a+'")'])
elif a[0:3] == "CT_":
pass
# smm[3][2].append([ 1, self.mode_label[a[3:]], 'cmd.get_wizard().set_mode("'+a+'")'])
else:
smm.append([1, self.mode_label[a], 'cmd.get_wizard().set_mode("' + a + '")'])
# group arg, lys, his, glu, asp
for lst in [smm]: # [ smm, smm[2][2], smm[3][2] ]:
for a in "ARG", "LYS", "HID", "GLU", "ASP":
ix = 0
start = 0
stop = 0
for b in lst:
if start == 0:
if b[1][0:] == a:
start = ix
stop = ix + 1
elif b[1][0:3] == a[0:3] or (b[1][0:2] == a[0:2] and a[0:2] == "HI"):
stop = ix + 1
ix = ix + 1
if start != 0 and stop != 0:
slice = lst[start:stop]
if a != "HID":
slice2 = [slice[0]] + [[0, "", ""]] + slice[1:]
lst[start:stop] = [[1, self.mode_label[a] + "... ", slice2]]
else:
slice2 = [slice[3]] + [[0, "", ""]] + slice[0:3]
lst[start:stop] = [[1, self.mode_label["HIS"] + "... ", slice2]]
self.menu["mode"] = smm
self.reps = ["lines", "sticks", "spheres", "dots"]
self.rep_name = {"lines": "Show Lines", "sticks": "Show Sticks", "spheres": "Show Spheres", "dots": "Show Dots"}
self.dep_name = {"dep": "Backbone Depen. Rotamers", "ind": "Backbone Indep. Rotamers"}
self.hyd_name = {
"auto": "Hydrogens: Current",
"keep": "Hydrogens: Add & Retain",
# 'polar' : "Polar Hydrogens",
"none": "Hydrogens: Remove",
}
self.hyds = ["auto", "keep", "none"]
self.n_cap_name = {"none": "Open", "posi": "NH3+", "acet": "Acetyl"}
self.n_caps = ["none", "posi", "acet"]
self.c_cap_name = {"none": "Open", "nega": "COO-", "amin": "Amine", "nmet": "N-methyl"}
self.c_caps = ["none", "nega", "amin", "nmet"]
smm = []
smm.append([2, "N-Cap", ""])
for a in self.n_caps:
smm.append([1, self.n_cap_name[a], 'cmd.get_wizard().set_n_cap("' + a + '")'])
self.menu["n_cap"] = smm
smm = []
smm.append([2, "C-Cap", ""])
for a in self.c_caps:
smm.append([1, self.c_cap_name[a], 'cmd.get_wizard().set_c_cap("' + a + '")'])
self.menu["c_cap"] = smm
smm = []
smm.append([2, "Hydrogens", ""])
for a in self.hyds:
smm.append([1, self.hyd_name[a], 'cmd.get_wizard().set_hyd("' + a + '")'])
self.menu["hyd"] = smm
smm = []
smm.append([2, "Representation", ""])
for a in self.reps:
smm.append([1, self.rep_name[a], 'cmd.get_wizard().set_rep("' + a + '")'])
self.menu["rep"] = smm
self.deps = ["dep", "ind"]
smm = []
smm.append([2, "Rotamers", ""])
for a in self.deps:
smm.append([1, self.dep_name[a], 'cmd.get_wizard().set_dep("' + a + '")'])
self.menu["dep"] = smm
if "pk1" in cmd.get_names("selections"):
cmd.select(src_sele, "(byres pk1)")
cmd.unpick()
cmd.enable(src_sele)
self.status = 1
self.error = None
self.do_library()
cmd.refresh_wizard()
def __init__(self,_self=cmd):
Wizard.__init__(self,_self)
cmd=self.cmd
if self.cmd.get_movie_length() > 0:
raise pymol.wizarding.WizardError('Mutagenesis Wizard cannot be used with Movie')
cmd.unpick()
self.stored = pymol.Scratch_Storage()
self.space = {'stored': self.stored}
self.bump_scores = []
self.dep = default_dep
self.ind_library = io.pkl.fromFile(os.environ['PYMOL_DATA']+
"/chempy/sidechains/sc_bb_ind.pkl")
self.load_library()
self.status = 0 # 0 no selection, 1 mutagenizing
self.bump_check = 1
self.auto_center = 1
self.error = None
self.object_name = None
self.modes = [
'current'
]
self.mode = default_mode
self.rep = default_rep
self.hyd = default_hyd
self.n_cap = default_n_cap
self.c_cap = default_c_cap
residues = list(self.ind_library.keys())
# could extent with additional fragments manually as below
residues.extend(['GLY','ALA'])
residues.extend(['HID','HIE','HIP'])
residues.extend(['ARGN','LYSN','ASPH','GLUH'])
residues.sort()
res_copy = deepcopy(residues)
for a in res_copy:
residues.append('NT_'+a)
residues.append('CT_'+a)
self.modes.extend(residues)
self.mode_label={}
for a in self.modes:
self.mode_label[a] = ""+a
self.mode_label['current']="No Mutant"
self.selection_mode = cmd.get_setting_int("mouse_selection_mode")
cmd.set("mouse_selection_mode",1)
smm = []
smm.append([ 2, 'Mutant', '' ])
smm.append([ 1, 'No change', 'cmd.get_wizard().set_mode("current")' ])
# smm.append([ 1, 'N-Term', [] ])
# smm.append([ 1, 'C-Term', [] ])
smm.append([ 0, '', '' ])
for a in self.modes:
if a == 'current':
pass
elif a[0:3]=='NT_':
pass
# smm[2][2].append([ 1, self.mode_label[a[3:]], 'cmd.get_wizard().set_mode("'+a+'")'])
elif a[0:3]=='CT_':
pass
# smm[3][2].append([ 1, self.mode_label[a[3:]], 'cmd.get_wizard().set_mode("'+a+'")'])
else:
smm.append([ 1, self.mode_label[a], 'cmd.get_wizard().set_mode("'+a+'")'])
# group arg, lys, his, glu, asp
for lst in [ smm ]: # [ smm, smm[2][2], smm[3][2] ]:
for a in 'ARG','LYS','HID','GLU','ASP':
ix = 0
start = 0
stop = 0
for b in lst:
if start==0:
if b[1][0:]==a:
start = ix
stop = ix + 1
elif b[1][0:3]==a[0:3] or ( b[1][0:2]==a[0:2] and a[0:2]=='HI' ):
stop = ix + 1
ix = ix + 1
if start!=0 and stop!=0:
slice = lst[start:stop]
if a != 'HID':
slice2 = [slice[0] ] + [ [0,'',''] ] + slice[1:]
lst[start:stop] = [ [1, self.mode_label[a] + "... " , slice2 ] ]
else:
slice2 = [ slice[3] ] + [ [0,'',''] ] + slice[0:3]
lst[start:stop] = [ [1, self.mode_label['HIS']+ "... ", slice2 ] ]
self.menu['mode']=smm
self.reps = [
'lines',
'sticks',
'spheres',
'dots'
]
self.rep_name = {
'lines' : "Show Lines",
'sticks' : "Show Sticks",
'spheres' : "Show Spheres",
'dots' : "Show Dots",
}
self.dep_name = {
'dep' : "Backbone Depen. Rotamers",
'ind' : "Backbone Indep. Rotamers"
}
self.hyd_name = {
'auto' : "Hydrogens: Current",
'keep' : "Hydrogens: Add & Retain",
# 'polar' : "Polar Hydrogens",
'none' : "Hydrogens: Remove",
}
self.hyds = [ 'auto', 'keep', 'none' ]
self.n_cap_name = {
'none' : 'Open',
'posi' : 'NH3+',
'acet' : 'Acetyl',
}
self.n_caps = [ 'none', 'posi', 'acet' ]
self.c_cap_name = {
'none' : 'Open',
'nega' : 'COO-',
'amin' : 'Amine',
'nmet' : 'N-methyl',
}
self.c_caps = [ 'none', 'nega', 'amin', 'nmet' ]
smm = []
smm.append([ 2, 'N-Cap', '' ])
for a in self.n_caps:
smm.append([ 1, self.n_cap_name[a], 'cmd.get_wizard().set_n_cap("'+a+'")'])
self.menu['n_cap']=smm
smm = []
smm.append([ 2, 'C-Cap', '' ])
for a in self.c_caps:
smm.append([ 1, self.c_cap_name[a], 'cmd.get_wizard().set_c_cap("'+a+'")'])
self.menu['c_cap']=smm
smm = []
smm.append([ 2, 'Hydrogens', '' ])
for a in self.hyds:
smm.append([ 1, self.hyd_name[a], 'cmd.get_wizard().set_hyd("'+a+'")'])
self.menu['hyd']=smm
smm = []
smm.append([ 2, 'Representation', '' ])
for a in self.reps:
smm.append([ 1, self.rep_name[a], 'cmd.get_wizard().set_rep("'+a+'")'])
self.menu['rep']=smm
self.deps = [ 'dep', 'ind' ]
smm = []
smm.append([ 2, 'Rotamers', '' ])
for a in self.deps:
smm.append([ 1, self.dep_name[a], 'cmd.get_wizard().set_dep("'+a+'")'])
self.menu['dep']=smm
if 'pk1' in cmd.get_names('selections'):
cmd.select(src_sele,"(byres pk1)")
cmd.unpick()
cmd.enable(src_sele)
self.status = 1
self.error = None
self.do_library()
cmd.refresh_wizard()
def do_pick(self, bondFlag):
if (bondFlag):
print " " # clear out misleading bond pick pk2 information...
cmd.unpick()
def do_library(self):
cmd=self.cmd
pymol=cmd._pymol
if not ((cmd.count_atoms("(%s) and name N"%src_sele)==1) and
(cmd.count_atoms("(%s) and name C"%src_sele)==1) and
(cmd.count_atoms("(%s) and name O"%src_sele)==1)):
self.clear()
return 1
cmd.feedback("push")
cmd.feedback("disable","selector","everythin")
cmd.feedback("disable","editor","actions")
self.prompt = [ 'Loading rotamers...']
self.bump_scores = []
state_best = 0
pymol.stored.name = 'residue'
cmd.iterate("first (%s)"%src_sele,'stored.name=model+"/"+segi+"/"+chain+"/"+resn+"`"+resi')
self.res_text = pymol.stored.name
cmd.select("_seeker_hilight",src_sele)
auto_zoom = cmd.get_setting_text('auto_zoom')
cmd.set('auto_zoom',"0",quiet=1)
cmd.frame(0)
cmd.delete(frag_name)
if self.auto_center:
cmd.center(src_sele,animate=-1)
self.lib_mode = self.mode
if self.lib_mode=="current":
pymol.stored.resn=""
cmd.iterate("(%s & name CA)"%src_sele,"stored.resn=resn")
rot_type = _rot_type_xref.get(pymol.stored.resn,pymol.stored.resn)
if (self.c_cap!='none') or (self.n_cap!='none') or (self.hyd != 'auto'):
self.lib_mode = rot_type # force fragment-based load
else:
cmd.create(frag_name,src_sele,1,1)
if self.c_cap=='open':
cmd.remove("%s and name OXT"%frag_name)
if self.lib_mode!='current':
rot_type = self.lib_mode
frag_type = self.lib_mode
if (self.n_cap == 'posi') and (frag_type[0:3]!='NT_'):
if not ( cmd.count_atoms(
"elem C & !(%s) & (bto. (name N & (%s))) &! resn ACE"%
(src_sele,src_sele))):
# use N-terminal fragment
frag_type ="NT_"+frag_type
if (self.c_cap == 'nega') and (frag_type[0:3]!='CT_'):
if not ( cmd.count_atoms("elem N & !(%s) & (bto. (name C & (%s))) & !resn NME+NHH"%
(src_sele,src_sele))):
# use C-terminal fragment
frag_type ="CT_"+frag_type
if rot_type[0:3] in [ 'NT_', 'CT_' ]:
rot_type = rot_type[3:]
rot_type = _rot_type_xref.get(rot_type, rot_type)
cmd.fragment(frag_type.lower(), frag_name, origin=0)
# trim off hydrogens
if (self.hyd == 'none'):
cmd.remove("("+frag_name+" and hydro)")
elif (self.hyd == 'auto'):
if cmd.count_atoms("("+src_sele+") and hydro")==0:
cmd.remove("("+frag_name+" and hydro)")
# copy identifying information
cmd.alter("?%s & name CA" % src_sele, "stored.identifiers = (segi, chain, resi, ss, color)", space=self.space)
cmd.alter("?%s" % frag_name, "(segi, chain, resi, ss) = stored.identifiers[:4]", space=self.space)
# move the fragment
if ((cmd.count_atoms("(%s & name CB)"%frag_name)==1) and
(cmd.count_atoms("(%s & name CB)"%src_sele)==1)):
cmd.pair_fit("(%s & name CA)"%frag_name,
"(%s & name CA)"%src_sele,
"(%s & name CB)"%frag_name,
"(%s & name CB)"%src_sele,
"(%s & name C)"%frag_name,
"(%s & name C)"%src_sele,
"(%s & name N)"%frag_name,
"(%s & name N)"%src_sele)
else:
cmd.pair_fit("(%s & name CA)"%frag_name,
"(%s & name CA)"%src_sele,
"(%s & name C)"%frag_name,
"(%s & name C)"%src_sele,
"(%s & name N)"%frag_name,
"(%s & name N)"%src_sele)
# fix the carbonyl position...
cmd.iterate_state(1,"(%s & name O)"%src_sele,"stored.list=[x,y,z]")
cmd.alter_state(1,"(%s & name O)"%frag_name,"(x,y,z)=stored.list")
if cmd.count_atoms("(%s & name OXT)"%src_sele):
cmd.iterate_state(1,"(%s & name OXT)"%src_sele,"stored.list=[x,y,z]")
cmd.alter_state(1,"(%s & name OXT)"%frag_name,"(x,y,z)=stored.list")
elif cmd.count_atoms("(%s & name OXT)"%frag_name): # place OXT if no template exists
angle = cmd.get_dihedral("(%s & name N)"%frag_name,
"(%s & name CA)"%frag_name,
"(%s & name C)"%frag_name,
"(%s & name O)"%frag_name)
cmd.protect("(%s & name O)"%frag_name)
cmd.set_dihedral("(%s & name N)"%frag_name,
"(%s & name CA)"%frag_name,
"(%s & name C)"%frag_name,
"(%s & name OXT)"%frag_name,180.0+angle)
cmd.deprotect(frag_name)
# fix the hydrogen position (if any)
if cmd.count_atoms("(hydro and bound_to (name N & (%s)))"%frag_name)==1:
if cmd.count_atoms("(hydro and bound_to (name N & (%s)))"%src_sele)==1:
cmd.iterate_state(1,"(hydro and bound_to (name N & (%s)))"%src_sele,
"stored.list=[x,y,z]")
cmd.alter_state(1,"(hydro and bound_to (name N & (%s)))"%frag_name,
"(x,y,z)=stored.list")
elif cmd.select(tmp_sele1,"(name C & bound_to (%s and elem N))"%src_sele)==1:
# position hydro based on location of the carbonyl
angle = cmd.get_dihedral("(%s & name C)"%frag_name,
"(%s & name CA)"%frag_name,
"(%s & name N)"%frag_name,
tmp_sele1)
cmd.set_dihedral("(%s & name C)"%frag_name,
"(%s & name CA)"%frag_name,
"(%s & name N)"%frag_name,
"(%s & name H)"%frag_name,180.0+angle)
cmd.delete(tmp_sele1)
# add c-cap (if appropriate)
if self.c_cap in [ 'amin', 'nmet' ]:
if not cmd.count_atoms("elem N & !(%s) & (bto. (name C & (%s))) & !resn NME+NHH"%
(src_sele,src_sele)):
if cmd.count_atoms("name C & (%s)"%(frag_name))==1:
if self.c_cap == 'amin':
editor.attach_amino_acid("name C & (%s)"%(frag_name), 'nhh')
elif self.c_cap == 'nmet':
editor.attach_amino_acid("name C & (%s)"%(frag_name), 'nme')
if cmd.count_atoms("hydro & bound_to (name N & bound_to (name C & (%s)))"%frag_name):
cmd.h_fix("name N & bound_to (name C & (%s))"%frag_name)
# trim hydrogens
if (self.hyd == 'none'):
cmd.remove("("+frag_name+" and hydro)")
elif (self.hyd == 'auto'):
if cmd.count_atoms("("+src_sele+") and hydro")==0:
cmd.remove("("+frag_name+" and hydro)")
# add n-cap (if appropriate)
if self.n_cap in [ 'acet' ]:
if not cmd.count_atoms("elem C & !(%s) & (bto. (name N & (%s))) & !resn ACE "%
(src_sele,src_sele)):
if cmd.count_atoms("name N & (%s)"%(frag_name))==1:
if self.n_cap == 'acet':
editor.attach_amino_acid("name N & (%s)"%(frag_name), 'ace')
if cmd.count_atoms("hydro & bound_to (name N & bound_to (name C & (%s)))"%frag_name):
cmd.h_fix("name N & (%s)"%frag_name)
# trim hydrogens
if (self.hyd == 'none'):
cmd.remove("("+frag_name+" and hydro)")
elif (self.hyd == 'auto'):
if cmd.count_atoms("("+src_sele+") and hydro")==0:
cmd.remove("("+frag_name+" and hydro)")
cartoon = (cmd.count_atoms("(%s & name CA & rep cartoon)"%src_sele)>0)
sticks = (cmd.count_atoms("(%s & name CA & rep sticks)"%src_sele)>0)
cmd.delete(obj_name)
key = rot_type
lib = None
if self.dep == 'dep':
try:
result = cmd.phi_psi("%s"%src_sele)
if len(result)==1:
(phi,psi) = list(result.values())[0]
(phi,psi) = (int(10*round(phi/10)),int(10*(round(psi/10))))
key = (rot_type,phi,psi)
if key not in self.dep_library:
(phi,psi) = (int(20*round(phi/20)),int(20*(round(psi/20))))
key = (rot_type,phi,psi)
if key not in self.dep_library:
(phi,psi) = (int(60*round(phi/60)),int(60*(round(psi/60))))
key = (rot_type,phi,psi)
lib = self.dep_library.get(key,None)
except:
pass
if lib == None:
key = rot_type
lib = self.ind_library.get(key,None)
if (lib!= None) and self.dep == 'dep':
print(' Mutagenesis: no phi/psi, using backbone-independent rotamers.')
if lib != None:
state = 1
for a in lib:
cmd.create(obj_name,frag_name,1,state)
if state == 1:
cmd.select(mut_sele,"(byres (%s like %s))"%(obj_name,src_sele))
if rot_type=='PRO':
cmd.unbond("(%s & name N)"%mut_sele,"(%s & name CD)"%mut_sele)
for b in a.keys():
if b!='FREQ':
cmd.set_dihedral("(%s & n;%s)"%(mut_sele,b[0]),
"(%s & n;%s)"%(mut_sele,b[1]),
"(%s & n;%s)"%(mut_sele,b[2]),
"(%s & n;%s)"%(mut_sele,b[3]),
a[b],state=state)
else:
cmd.set_title(obj_name,state,"%1.1f%%"%(a[b]*100))
if rot_type=='PRO':
cmd.bond("(%s & name N)"%mut_sele,"(%s & name CD)"%mut_sele)
state = state + 1
cmd.delete(frag_name)
print(" Mutagenesis: %d rotamers loaded."%len(lib))
if self.bump_check:
cmd.delete(bump_name)
cmd.create(bump_name,
"(((byobj %s) within 6 of (%s and not name N+C+CA+O+H+HA)) and (not (%s)))|(%s)"%
(src_sele,mut_sele,src_sele,mut_sele),singletons=1)
cmd.color("gray50",bump_name+" and elem C")
cmd.set("seq_view",0,bump_name,quiet=1)
cmd.hide("everything",bump_name)
if ((cmd.select(tmp_sele1, "(name N & (%s in (neighbor %s)))"%
(bump_name,src_sele)) == 1) and
(cmd.select(tmp_sele2, "(name C & (%s in %s))"%
(bump_name,mut_sele)) == 1)):
cmd.bond(tmp_sele1,tmp_sele2)
if ((cmd.select(tmp_sele1,"(name C & (%s in (neighbor %s)))"%
(bump_name,src_sele)) == 1) and
(cmd.select(tmp_sele2,"(name N & (%s in %s))"%
(bump_name,mut_sele)) == 1)):
cmd.bond(tmp_sele1,tmp_sele2)
cmd.delete(tmp_sele1)
cmd.delete(tmp_sele2)
cmd.protect("%s and not (%s in (%s and not name N+C+CA+O+H+HA))"%
(bump_name,bump_name,mut_sele))
cmd.sculpt_activate(bump_name)
cmd.show("cgo",bump_name)
# draw the bumps
cmd.set("sculpt_vdw_vis_mode",1,bump_name)
state = 1
score_best = 1e6
for a in lib:
score = cmd.sculpt_iterate(bump_name, state, 1)
self.bump_scores.append(score)
if score < score_best:
state_best = state
score_best = score
state = state + 1
cmd.delete(mut_sele)
else:
cmd.create(obj_name,frag_name,1,1)
print(" Mutagenesis: no rotamers found in library.")
cmd.set("seq_view",0,obj_name,quiet=1)
pymol.util.cbaw(obj_name)
cmd.hide("("+obj_name+")")
cmd.show(self.rep,obj_name)
cmd.show('lines',obj_name) #neighbor always show lines
if cartoon:
cmd.show("cartoon",obj_name)
if sticks:
cmd.show("sticks",obj_name)
cmd.set('auto_zoom',auto_zoom,quiet=1)
cmd.delete(frag_name)
cmd.frame(state_best)
cmd.unpick()
cmd.feedback("pop")
def do_pick(self,bondFlag):
if(bondFlag):
print(" ") # clear out misleading bond pick pk2 information...
cmd.unpick()
def test_unpick(self):
cmd.pseudoatom('m1')
cmd.edit('m1')
cmd.unpick()
self.assertTrue('pk1' not in cmd.get_names('selections'))
