def pymol_mutate(file_name, chain, res_index):
pymol.finish_launching()
cmd.delete('all')
selection = chain + '/' + res_index + '/'
mutant = 'CYS'
cmd.wizard("mutagenesis")
pdb = file_name[:-4]
cmd.load(file_name)
cmd.remove('not (alt ''+A)')
cmd.select('mut', 'resi ' + res_index + ' and chain ' + chain)
if cmd.count_atoms('mut') == 0:
return False
cmd.refresh_wizard()
cmd.get_wizard().set_mode(mutant)
cmd.get_wizard().do_select(selection)
nStates = cmd.count_states("mutation")
for i in range(1, nStates + 1):
cmd.get_wizard().do_select(selection)
cmd.frame(i)
cmd.get_wizard().apply()
cmd.save("rec_" + str(res_index) + "_" + str(i) + ".pdb")
cmd.set_wizard()
cmd.remove(file_name[:-4])
return True
def testSimple(self):
cmd.fab('A', 'm1')
cmd.fab('A', 'm2')
v1 = 'foo'
v2 = 'bar'
v3 = 'com'
# single state
cmd.set_property('filename', v1, 'm1')
self.assertTrue('foo' == v1)
self.assertTrue(cmd.get_property('filename', 'm1') == v1)
self.assertTrue(cmd.get_property('filename', 'm2') == None)
# multiple objects
cmd.set_property('filename', v1)
self.assertTrue(cmd.get_property('filename', 'm2') == v1)
# two states
cmd.create('m1', 'm1', 1, 2)
self.assertTrue(cmd.count_states() == 2)
# set for all states
cmd.set_property('filename', v1, 'm1')
self.assertTrue(cmd.get_property('filename', 'm1', 2) == v1)
# set for particular state
cmd.set_property('filename', v2, 'm1', 2)
self.assertTrue(cmd.get_property('filename', 'm1', 1) == v1)
self.assertTrue(cmd.get_property('filename', 'm1', 2) == v2)
# set for current state
cmd.frame(2)
cmd.set_property('filename', v3, 'm1', -1)
self.assertTrue(cmd.get_property('filename', 'm1', 1) == v1)
self.assertTrue(cmd.get_property('filename', 'm1', 2) == v3)
def testRewind(self):
self.prep_movie()
cmd.frame(30)
self.assertEquals(cmd.get_frame(), 30)
cmd.rewind()
self.assertEquals(cmd.get_frame(), 1)
def testMset(self):
# basic tet
self.prep_movie()
self.assertEquals(cmd.count_frames(), 60)
# test clearing
cmd.mset()
self.assertEquals(cmd.count_frames(), 0)
# test states and frame mapping
cmd.mset("1x10 1 -10 10 -1")
cmd.frame(1)
self.assertEquals(cmd.get_frame(), 1)
self.assertEquals(cmd.get("state"), "1")
cmd.frame(10)
self.assertEquals(cmd.get_frame(), 10)
self.assertEquals(cmd.get("state"), "1")
cmd.frame(12)
self.assertEquals(cmd.get_frame(), 12)
self.assertEquals(cmd.get("state"), "2")
cmd.frame(22)
self.assertEquals(cmd.get_frame(), 22)
self.assertEquals(cmd.get("state"), "9")
cmd.frame(30)
self.assertEquals(cmd.get_frame(), 30)
self.assertEquals(cmd.get("state"), "1")
def testMset(self):
# basic tet
self.prep_movie()
self.assertEquals(cmd.count_frames(),60)
# test clearing
cmd.mset()
self.assertEquals(cmd.count_frames(),0)
# test states and frame mapping
cmd.mset("1x10 1 -10 10 -1")
cmd.frame(1)
self.assertEquals(cmd.get_frame(),1)
self.assertEquals(cmd.get("state"),"1")
cmd.frame(10)
self.assertEquals(cmd.get_frame(),10)
self.assertEquals(cmd.get("state"),"1")
cmd.frame(12)
self.assertEquals(cmd.get_frame(),12)
self.assertEquals(cmd.get("state"),"2")
cmd.frame(22)
self.assertEquals(cmd.get_frame(),22)
self.assertEquals(cmd.get("state"),"9")
cmd.frame(30)
self.assertEquals(cmd.get_frame(),30)
self.assertEquals(cmd.get("state"),"1")
def Update(self):
try:
# Copy the initial protein (Frame 1) into the working state
cmd.create(self.TargetObj, self.TargetName, 1, self.State)
cmd.refresh()
# Display the last frame
cmd.frame(self.State)
#print "Switched to frame " + str(self.State)
except:
self.CriticalError("Object " + str(self.TargetName) + " no longer exists")
if not self.UpdateLigandAnchorPoint() and not self.UpdateLigandFlexibility():
self.selSideChains = self.UpdateSideChainConformations()
if self.WriteOutLigand() or self.EditView() or \
self.top.UpdateDataList(self.Line, self.TOP, self.top.Reference, self.dictCoord):
self.Delete_Object()
self.Delete_Object()
return
def frag(state=state, obj=obj):
pwd, mutations, orig_sequence = setup(obj)
#get_positions_in_selection(sub, distance)
# Run over all sites where to mutate, optionally add and retain hydrogens.
for site in mutations.keys():
variants = mutations[site]
# Run over all variants.
for variant in variants:
cmd.load(obj)
cmd.do('wizard mutagenesis')
cmd.do('refresh_wizard')
cmd.get_wizard().set_hyd("keep")
cmd.get_wizard().set_mode(variant)
#cmd.get_wizard().do_select(site + '/')
# Get the number of available rotamers at that site.
# Introduce a condition here to check if rotamers are requested.
# <<OPTIONAL>>
nRots = getRots(site, variant)
#if nRots > 3:
# nRots = 3
nRots=1
cmd.rewind()
for i in range(1, nRots + 1):
cmd.get_wizard().do_select("(" + site + "/)")
cmd.frame(i)
cmd.get_wizard().apply()
# Optimize the mutated sidechain
#<<OPTION>>
#print "Sculpting."
local_sculpt(obj, variant, site)
# Protonation of the N.
#cmd.do("select n%d, name n and %d/" % (int(site), int(site)))
#cmd.edit("n%d" % int(site), None, None, None, pkresi=0, pkbond=0)
#cmd.do("h_fill")
# Protonation of the C.
#cmd.do("select c%d, name c and %d/" % (int(site), int(site)))
#cmd.edit("c%d" % int(site), None, None, None, pkresi=0, pkbond=0)
#cmd.do("h_fill")
# Definition of saveString
#saveString = '%s/' % pwd
#saveString += 'frag-' + get_one(orig_sequence[site]).lower() +\
# site + get_one(variant).lower() + '-%s.pdb, ' % state +\
# '((%s/))' % site
save_string_rot = '%s/' % pwd
save_string_rot += 'frag-' + get_one(orig_sequence[site]).lower() +\
site + get_one(variant).lower() + '-%02d-%s.pdb, ' % (i, state) +\
'((%s/))' % site
#print saveString
#cmd.do('save %s' % saveString.lower())
cmd.do('save %s' % save_string_rot.lower())
cmd.do('delete all')
cmd.set_wizard('done')
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 testSimple(self):
cmd.fab('A', 'm1')
cmd.fab('A', 'm2')
v1 = 'foo'
v2 = 'bar'
v3 = 'com'
# single state
cmd.set_property('filename', v1, 'm1')
self.assertTrue('foo' == v1)
self.assertTrue(cmd.get_property('filename', 'm1') == v1)
self.assertTrue(cmd.get_property('filename', 'm2') == None)
# multiple objects
cmd.set_property('filename', v1)
self.assertTrue(cmd.get_property('filename', 'm2') == v1)
# two states
cmd.create('m1', 'm1', 1, 2)
self.assertTrue(cmd.count_states() == 2)
# set for all states
cmd.set_property('filename', v1, 'm1')
self.assertTrue(cmd.get_property('filename', 'm1', 2) == v1)
# set for particular state
cmd.set_property('filename', v2, 'm1', 2)
self.assertTrue(cmd.get_property('filename', 'm1', 1) == v1)
self.assertTrue(cmd.get_property('filename', 'm1', 2) == v2)
# set for current state
cmd.frame(2)
cmd.set_property('filename', v3, 'm1', -1)
self.assertTrue(cmd.get_property('filename', 'm1', 1) == v1)
self.assertTrue(cmd.get_property('filename', 'm1', 2) == v3)
def testCreateTargetState(self):
self.create_many_states("gly", "m1", 4)
cmd.frame(3)
cmd.create('m2', 'm1', 0, 0)
self.assertEqual(cmd.count_states('m2'), 4)
cmd.delete('m2')
cmd.create('m2', 'm1', 1, 0)
self.assertEqual(cmd.count_states('m2'), 1)
cmd.delete('m2')
cmd.create('m2', 'm1', 2, 0)
self.assertEqual(cmd.count_states('m2'), 2)
cmd.delete('m2')
cmd.create('m2', 'm1', 0, 2)
self.assertEqual(cmd.count_states('m2'), 5)
cmd.delete('m2')
cmd.create('m2', 'm1', 1, 2)
self.assertEqual(cmd.count_states('m2'), 2)
cmd.delete('m2')
cmd.create('m2', 'm1', 2, 2)
self.assertEqual(cmd.count_states('m2'), 2)
cmd.delete('m2')
cmd.create('m2', 'm1', 0, -1)
self.assertEqual(cmd.count_states('m2'), 4)
cmd.create('m2', 'm1', 0, -1)
self.assertEqual(cmd.count_states('m2'), 8)
cmd.create('m2', 'm1', 2, -1)
self.assertEqual(cmd.count_states('m2'), 9)
def testIsolevel(self):
cmd.viewport(100, 100)
cmd.fragment('gly', 'm1')
cmd.set('gaussian_b_floor', 30)
cmd.set('mesh_width', 5)
cmd.map_new('map')
cmd.delete('m1')
# make mesh
cmd.isodot('dot', 'map')
cmd.isodot('dot', 'map', source_state=1, state=-2)
## check mesh presence by color
meshcolor = 'red'
cmd.color(meshcolor, 'dot')
self.ambientOnly()
self.assertImageHasColor(meshcolor)
cmd.frame(2)
self.assertEqual(cmd.get_state(), 2)
self.assertImageHasColor(meshcolor)
for contourlvl in range(7):
cmd.isolevel('dot', contourlvl)
self.assertImageHasColor(meshcolor)
cmd.isolevel('dot', 10)
self.assertImageHasNotColor(meshcolor)
def testRewind(self):
self.prep_movie()
cmd.frame(30)
self.assertEquals(cmd.get_frame(), 30)
cmd.rewind()
self.assertEquals(cmd.get_frame(), 1)
def testIsosurface(self):
cmd.viewport(100, 100)
cmd.fragment('gly', 'm1')
cmd.set('gaussian_b_floor', 30)
cmd.set('mesh_width', 5)
cmd.map_new('map')
cmd.delete('m1')
# make mesh
cmd.isosurface('surface', 'map')
cmd.isosurface('surface', 'map', source_state=1, state=-2)
## check mesh presence by color
meshcolor = 'red'
cmd.color(meshcolor, 'surface')
self.ambientOnly()
self.assertImageHasColor(meshcolor)
cmd.frame(2)
self.assertEqual(cmd.get_state(), 2)
self.assertImageHasColor(meshcolor)
with testing.mktemp('.pse') as filename:
cmd.save(filename)
cmd.delete('*')
self.assertImageHasNotColor(meshcolor)
cmd.load(filename)
self.assertImageHasColor(meshcolor)
cmd.frame(2)
self.assertEqual(cmd.get_state(), 2)
self.assertImageHasColor(meshcolor)
def Update(self):
try:
# Copy the initial protein (Frame 1) into the working state
cmd.create(self.TargetObj, self.TargetName, 1, self.State)
cmd.refresh()
# Display the last frame
cmd.frame(self.State)
#print "Switched to frame " + str(self.State)
except:
self.CriticalError("Object " + str(self.TargetName) +
" no longer exists")
if not self.UpdateLigandAnchorPoint(
) and not self.UpdateLigandFlexibility():
self.selSideChains = self.UpdateSideChainConformations()
if self.WriteOutLigand() or self.EditView() or \
self.top.UpdateDataList(self.Line, self.TOP, self.top.Reference, self.dictCoord):
self.Delete_Object()
self.Delete_Object()
return
def makeMovie(numClusts, frameRate):
real = int(numClusts)+1;
fr = int(frameRate)
movieSetup = "1 x" + str(real*fr)
cmd.mset(movieSetup)
#Load in all the system data.
for x in range(0, real):
# load the next system.
clustName = "system-" + str(x)
system = clustName + ".xyz"
cmd.load(system)
# Set the sphere scale and view
cmd.set("sphere_scale","0.5","all")
#Set the right view
cmd.set_view("0.910306633, -0.382467061, 0.158301696, 0.326706469, 0.898694992, 0.292592257, -0.254171938, -0.214630708, 0.943043232, 0.000000000, 0.000000000, -99.425979614, 10.461934090, 13.087766647, 11.786855698, 80.009132385, 118.842796326, -20.000000000")
#Set all the frame data
for x in range(0, real):
# set the current frame.
frameNum = (x*fr)+1
cmd.frame(frameNum)
clustName = "system-" + str(x)
movieState = "hide; show spheres, " + clustName
cmd.mdo(frameNum,movieState)
cmd.mview("store")
cmd.mview("reinterpolate")
cmd.mplay()
def gotoframe(event):
try:
cmd.frame(gotoent.get())
except:
showinfo('Alert!', 'You need to enter the frame number')
interior.mainloop()
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 testScene(self):
cmd.fragment('ala', 'm1')
cmd.fragment('gly', 'm2')
cmd.create('m2', 'm2', 1, 2)
cmd.create('m2', 'm2', 1, 3)
cmd.create('m2', 'm2', 1, 4)
# store
cmd.show_as('sticks', 'm1')
cmd.show_as('spheres', 'm2')
cmd.color('blue', 'm1')
cmd.color('yellow', 'm2')
view_001 = cmd.get_view()
cmd.scene('new', 'store', 'hello world')
# store
cmd.frame(3)
cmd.show_as('lines')
cmd.color('red')
cmd.turn('x', 45)
view_002 = cmd.get_view()
cmd.scene('new', 'store')
# we actually don't know the auto naming counter
# self.assertEqual(cmd.get_scene_list(), ['001', '002'])
names = cmd.get_scene_list()
# recall
cmd.scene(names[0], 'recall', animate=0)
self.assertArrayEqual(view_001, cmd.get_view(), delta=1e-3)
self.assertEqual(cmd.count_atoms('m1'), cmd.count_atoms('color blue'))
self.assertEqual(cmd.count_atoms('m1'), cmd.count_atoms('rep sticks'))
self.assertEqual(cmd.count_atoms('m2'),
cmd.count_atoms('color yellow'))
self.assertEqual(cmd.count_atoms('m2'), cmd.count_atoms('rep spheres'))
self.assertNotEqual(cmd.get_wizard(), None)
self.assertEqual(cmd.get_state(), 1)
# recall
cmd.scene(names[1], 'recall', animate=0)
self.assertArrayEqual(view_002, cmd.get_view(), delta=1e-3)
self.assertEqual(0, cmd.count_atoms('color blue'))
self.assertEqual(0, cmd.count_atoms('rep sticks'))
self.assertEqual(cmd.count_atoms(), cmd.count_atoms('color red'))
self.assertEqual(cmd.count_atoms(), cmd.count_atoms('rep lines'))
self.assertEqual(cmd.get_wizard(), None)
self.assertEqual(cmd.get_state(), 3)
# with movie (not playing) it must not recall the state
cmd.mset('1-4')
cmd.frame(1)
cmd.scene(names[1], 'recall', animate=0)
self.assertEqual(cmd.get_state(), 1)
# rename and delete
cmd.scene('F2', 'store')
cmd.scene(names[0], 'rename', new_key='F1')
cmd.scene(names[1], 'delete')
self.assertEqual(cmd.get_scene_list(), ['F1', 'F2'])
def mvClear():
"""Deletes the movie."""
mv.movie = []
cmd.mclear()
cmd.frame(1)
mv.ray = 0
mv.pngPath = ""
mv.maxframe = 1
def updateframe(self, f):
''' When the slider is moved, run this. '''
#Check the max number of frames
self.update_max_frames()
#change to that frame
cmd.frame(f)
def updateframe(self, f):
''' When the slider is moved, run this. '''
#Check the max number of frames
self.update_max_frames()
#change to that frame
cmd.frame(f)
def testMappend(self):
self.prep_movie()
cmd.fragment("ala")
cmd.mappend(5, "delete *")
cmd.mappend(5, "frame 1")
cmd.frame(5)
self.assertEquals(len(cmd.get_names()), 0)
self.assertEquals(cmd.get_frame(), 1)
def testMappend(self):
self.prep_movie()
cmd.fragment("ala")
cmd.mappend(5,"delete *")
cmd.mappend(5,"frame 1")
cmd.frame(5)
self.assertEquals(len(cmd.get_names()),0)
self.assertEquals(cmd.get_frame(),1)
def state2frame(selection, start=1):
for i, x in enumerate(
list(
range(int(start),
int(start) + cmd.count_states(selection) + 1))):
cmd.frame(x)
cmd.set('state', str(i + 1), selection)
print("Frame => %s; and State => %s" % (str(x), str(i + 1)))
def testScene(self):
cmd.fragment('ala', 'm1')
cmd.fragment('gly', 'm2')
cmd.create('m2', 'm2', 1, 2)
cmd.create('m2', 'm2', 1, 3)
cmd.create('m2', 'm2', 1, 4)
# store
cmd.show_as('sticks', 'm1')
cmd.show_as('spheres', 'm2')
cmd.color('blue', 'm1')
cmd.color('yellow', 'm2')
view_001 = cmd.get_view()
cmd.scene('new', 'store', 'hello world')
# store
cmd.frame(3)
cmd.show_as('lines')
cmd.color('red')
cmd.turn('x', 45)
view_002 = cmd.get_view()
cmd.scene('new', 'store')
# we actually don't know the auto naming counter
# self.assertEqual(cmd.get_scene_list(), ['001', '002'])
names = cmd.get_scene_list()
# recall
cmd.scene(names[0], 'recall', animate=0)
self.assertArrayEqual(view_001, cmd.get_view(), delta=1e-3)
self.assertEqual(cmd.count_atoms('m1'), cmd.count_atoms('color blue'))
self.assertEqual(cmd.count_atoms('m1'), cmd.count_atoms('rep sticks'))
self.assertEqual(cmd.count_atoms('m2'), cmd.count_atoms('color yellow'))
self.assertEqual(cmd.count_atoms('m2'), cmd.count_atoms('rep spheres'))
self.assertNotEqual(cmd.get_wizard(), None)
self.assertEqual(cmd.get_state(), 1)
# recall
cmd.scene(names[1], 'recall', animate=0)
self.assertArrayEqual(view_002, cmd.get_view(), delta=1e-3)
self.assertEqual(0, cmd.count_atoms('color blue'))
self.assertEqual(0, cmd.count_atoms('rep sticks'))
self.assertEqual(cmd.count_atoms(), cmd.count_atoms('color red'))
self.assertEqual(cmd.count_atoms(), cmd.count_atoms('rep lines'))
self.assertEqual(cmd.get_wizard(), None)
self.assertEqual(cmd.get_state(), 3)
# with movie (not playing) it must not recall the state
cmd.mset('1-4')
cmd.frame(1)
cmd.scene(names[1], 'recall', animate=0)
self.assertEqual(cmd.get_state(), 1)
# rename and delete
cmd.scene('F2', 'store')
cmd.scene(names[0], 'rename', new_key='F1')
cmd.scene(names[1], 'delete')
self.assertEqual(cmd.get_scene_list(), ['F1', 'F2'])
def testBackward(self):
self.prep_movie()
cmd.middle()
cmd.backward()
self.assertEquals(cmd.get_frame(), 30)
cmd.frame(1)
cmd.backward()
self.assertEquals(cmd.get_frame(), 1)
def testBackward(self):
self.prep_movie()
cmd.middle()
cmd.backward()
self.assertEquals(cmd.get_frame(),30)
cmd.frame(1)
cmd.backward()
self.assertEquals(cmd.get_frame(),1)
def mutate(protein, resi, mode='ALA', chain='A'):
cmd.wizard('mutagenesis')
cmd.do("refresh_wizard")
cmd.get_wizard().set_mode(mode.upper())
selection = f'/{protein}//{chain}/{resi}'
cmd.get_wizard().do_select(selection)
cmd.frame(str(1))
cmd.get_wizard().apply()
cmd.set_wizard('done')
cmd.refresh()
def _testZoomGeneric(self, func, views):
self._load_default_scene()
cmd.frame(2)
for (state, view) in views.items():
func(state=state)
self.assertViewIs(view)
func(state=-1)
self.assertViewIs(views[2])
def _testZoomGeneric(self, func, views):
self._load_default_scene()
cmd.frame(2)
for (state, view) in views.items():
func(state=state)
self.assertViewIs(view)
func(state=-1)
self.assertViewIs(views[2])
def dump_mviews():
'''
DESCRIPTION
Dump the current movie as 'set_view' with 'mview store' commands.
'''
for frame in get_keyframes() or ():
cmd.frame(frame)
print(cmd.get_view(3).strip())
print('mview store, {}'.format(frame))
def mutate(molecule,chain,resi,target="CYS",mutframe="1"):
target = target.upper()
cmd.wizard("mutagenesis")
cmd.do("refresh_wizard")
cmd.get_wizard().set_mode("%s"%target)
selection="/%s//%s/%s"%(molecule,chain,resi)
cmd.get_wizard().do_select(selection)
cmd.frame(str(mutframe))
cmd.get_wizard().apply()
#cmd.set_wizard("done")
cmd.set_wizard()
def mutate(molecule, chain, resi, target="CYS", mutframe="1"):
target = target.upper()
cmd.wizard("mutagenesis")
cmd.do("refresh_wizard")
cmd.get_wizard().set_mode("%s" % target)
selection = "/%s//%s/%s" % (molecule, chain, resi)
cmd.get_wizard().do_select(selection)
cmd.frame(str(mutframe))
cmd.get_wizard().apply()
# cmd.set_wizard("done")
cmd.set_wizard()
def run(self):
print("FlexAID parsing thread has begun.")
# Set the auto_zoom to off
cmd.set("auto_zoom", 0)
cmd.delete("TOP_*__")
cmd.delete("RESULT_*")
cmd.refresh()
cmd.frame(1)
self.queue.put(lambda: self.top.InitStatus())
self.queue.put(lambda: self.top.progressBarHandler(0, self.NbTotalGen))
# send ready to simulate signal
print(' Signal sent to start simulation')
self.FlexAID.ParseState = 0
print(' Waiting for FlexAID to start')
# wait for FlexAID to start, to crash or to finish (if simulation is very short and quickly done)
while self.FlexAID.SimulateState < 0:
time.sleep(self.top.INTERVAL)
print(' Parsing the logfile of FlexAID')
while self.FlexAID.Run is not None: # and self.FlexAID.Run.poll() is None:
time.sleep(self.top.INTERVAL)
if self.ParseLines():
break
if not self.FlexAID.ParseState > 0:
self.ParseLines()
# Put back the auto_zoom to on
cmd.set("auto_zoom", self.auto_zoom)
# error in simulation or parsing?
if self.FlexAID.SimulateState > 0 or self.FlexAID.ParseState > 0:
self.queue.put(lambda: self.top.ErrorStatus(self.ErrorMsg))
else:
self.queue.put(lambda: self.top.SuccessStatus())
if self.top.Results:
cmd.enable("RESULT_*")
cmd.refresh()
cmd.disable("TOP_*__")
cmd.refresh()
cmd.frame(1)
self.FlexAID.ParseState = 10
print("FlexAID parsing thread has ended.")
def load():
global last1, last2
list = glob("pdb/*/*")
list = map(lambda x: (random.random(), x), list)
list.sort()
list = map(lambda x: x[1], list)
l = len(list)
c = 0
for file in list:
c = c + 1
try:
cmd.set("suspend_updates", "1")
cmd.delete("pdb")
print file, last1, last2, c, "of", l
last2 = last1
last1 = file
cmd.load(file, "pdb")
cmd.set_title("pdb", 1, os.path.split(file)[-1])
cmd.rewind()
# cmd.refresh()
# cmd.hide()
cmd.show("cartoon")
cmd.color("auto", "ss h")
cmd.color("auto", "ss s")
cmd.orient("pdb")
cmd.color("auto", "organic and elem c")
cmd.show("spheres", "organic")
cmd.move("z", -50.0)
sys.__stderr__.write(".")
sys.__stderr__.flush()
n = cmd.count_states()
finally:
cmd.set("suspend_updates", "0")
if cmd.count_atoms():
start = time.time()
if n > 1:
while (time.time() - start) < cycle_time:
for a in range(1, n + 1):
cmd.refresh()
cmd.frame(a)
cmd.move("z", 2)
cmd.turn("y", 1)
time.sleep(0.025)
sys.__stderr__.write(" %d of %d" % (c, l))
sys.__stderr__.write("\n")
sys.__stderr__.flush()
else:
cmd.refresh()
while (time.time() - start) < cycle_time:
for a in range(1, n + 1):
time.sleep(0.05)
cmd.move("z", 1.0)
cmd.turn("y", 1)
def load():
global last1, last2
list = glob("pdb/*/*")
list = map(lambda x: (random.random(), x), list)
list.sort()
list = map(lambda x: x[1], list)
l = len(list)
c = 0
for file in list:
c = c + 1
try:
cmd.set("suspend_updates", "1")
cmd.delete('pdb')
print file, last1, last2, c, "of", l
last2 = last1
last1 = file
cmd.load(file, 'pdb')
cmd.set_title('pdb', 1, os.path.split(file)[-1])
cmd.rewind()
# cmd.refresh()
# cmd.hide()
cmd.show('cartoon')
cmd.color('auto', 'ss h')
cmd.color('auto', 'ss s')
cmd.orient('pdb')
cmd.color('auto', 'organic and elem c')
cmd.show('spheres', 'organic')
cmd.move('z', -50.0)
sys.__stderr__.write(".")
sys.__stderr__.flush()
n = cmd.count_states()
finally:
cmd.set("suspend_updates", "0")
if cmd.count_atoms():
start = time.time()
if n > 1:
while (time.time() - start) < cycle_time:
for a in range(1, n + 1):
cmd.refresh()
cmd.frame(a)
cmd.move('z', 2)
cmd.turn('y', 1)
time.sleep(0.025)
sys.__stderr__.write(" %d of %d" % (c, l))
sys.__stderr__.write("\n")
sys.__stderr__.flush()
else:
cmd.refresh()
while (time.time() - start) < cycle_time:
for a in range(1, n + 1):
time.sleep(0.05)
cmd.move('z', 1.0)
cmd.turn('y', 1)
def run(self):
print("FlexAID parsing thread has begun.")
# Set the auto_zoom to off
cmd.set("auto_zoom", 0)
cmd.delete("TOP_*__")
cmd.delete("RESULT_*")
cmd.refresh()
cmd.frame(1)
self.queue.put(lambda: self.top.InitStatus())
self.queue.put(lambda: self.top.progressBarHandler(0, self.NbTotalGen))
# send ready to simulate signal
print(' Signal sent to start simulation')
self.FlexAID.ParseState = 0
print(' Waiting for FlexAID to start')
# wait for FlexAID to start, to crash or to finish (if simulation is very short and quickly done)
while self.FlexAID.SimulateState < 0:
time.sleep(self.top.INTERVAL)
print(' Parsing the logfile of FlexAID')
while self.FlexAID.Run is not None: # and self.FlexAID.Run.poll() is None:
time.sleep(self.top.INTERVAL)
if self.ParseLines():
break
if not self.FlexAID.ParseState > 0:
self.ParseLines()
# Put back the auto_zoom to on
cmd.set("auto_zoom", self.auto_zoom)
# error in simulation or parsing?
if self.FlexAID.SimulateState > 0 or self.FlexAID.ParseState > 0:
self.queue.put(lambda: self.top.ErrorStatus(self.ErrorMsg))
else:
self.queue.put(lambda: self.top.SuccessStatus())
if self.top.Results:
cmd.enable("RESULT_*")
cmd.refresh()
cmd.disable("TOP_*__")
cmd.refresh()
cmd.frame(1)
self.FlexAID.ParseState = 10
print("FlexAID parsing thread has ended.")
def closest_keyframe(quiet=1):
'''
DESCRIPTION
Jump to the closest movie keyframe.
'''
r = get_closest_keyframe()
if r is not None:
cmd.frame(r)
if not int(quiet):
print(' Closest Keyframe: ' + str(r))
return r
def testSaveState(self, format, pymol_version):
if pymol_version > testing.PYMOL_VERSION[1]:
self.skipTest("version %f" % (pymol_version))
# for rms_cur (not all formats save all identifiers)
m = -1
cmd.set('retain_order')
# create a multistate object
cmd.fragment('ala', 'm1')
cmd.create('m1', 'm1', 1, 2)
cmd.create('m1', 'm1', 1, 3)
cmd.translate([5, 0, 0], 'm1', state=2)
cmd.translate([0, 5, 0], 'm1', state=3)
n_states = cmd.count_states('m1')
with testing.mktemp('.' + format) as filename:
if format == 'mae' and not pymol.invocation.options.incentive_product:
format = 'cms'
# explicit
for state in range(1, n_states + 1):
cmd.delete('m2')
cmd.save(filename, 'm1', state=state)
cmd.load(filename, 'm2', format=format)
rms = cmd.rms_cur('m1', 'm2', state, 1, matchmaker=m)
self.assertAlmostEqual(rms, 0.00, delta=1e-2)
# current state
for state in range(1, n_states + 1):
cmd.frame(state)
cmd.delete('m2')
cmd.save(filename, 'm1')
cmd.load(filename, 'm2', 1, format=format)
rms = cmd.rms_cur('m1', 'm2', state, 1, matchmaker=m)
self.assertAlmostEqual(rms, 0.00, delta=1e-2)
if format in ('mol', 'cms'):
# no multi support
return
# all states
cmd.delete('m2')
cmd.save(filename, 'm1', state=0)
cmd.load(filename, 'm2', 1, discrete=1, multiplex=0)
self.assertEqual(cmd.count_states('m2'), n_states)
for state in range(1, n_states + 1):
rms = cmd.rms_cur('m1',
'm2 and state %d' % state,
state,
state,
matchmaker=m)
self.assertAlmostEqual(rms, 0.00, delta=1e-2)
def mutXYZposition(residues):
cmd.hide("everything")
cmd.show("sticks")
for resi in residues:
for caa in residues[resi]:
print(resi, caa)
filename = "residue" + str(resi) + "to" + caa + ".csv"
outfile = open(filename, "w")
row = ("rotamer" + "," + "X" + "," + "Y" + "," + "Z" + "\n")
cmd.wizard("mutagenesis")
cmd.do("refresh_wizard")
cmd.get_wizard().set_mode(caa)
sel = "/test//A/" + str(resi)
cmd.get_wizard().do_select(sel)
fram = cmd.count_states("mutation")
stored.pos = []
cmd.iterate_state(0,
'mutation',
'stored.pos.append((x,y,z))',
atomic=0)
counter = 1
state = 1
natom = int(len(stored.pos) / fram)
for po in stored.pos:
if counter < natom:
row = (str(state) + "," + str(po[0]) + "," + str(po[1]) +
"," + str(po[2]) + "\n")
outfile.write(row)
counter += 1
elif counter == natom:
row = (str(state) + "," + str(po[0]) + "," + str(po[1]) +
"," + str(po[2]) + "\n")
outfile.write(row)
counter = 1
state += 1
outfile.close()
cmd.frame(fram)
cmd.get_wizard().apply()
cmd.set_wizard("done")
cmd.save("residue" + str(resi) + "to" + caa + "rotamer" +
str(fram) + ".pdb")
for f in range(1, fram):
fra = fram - f
cmd.wizard("mutagenesis")
cmd.do("refresh_wizard")
cmd.get_wizard().do_select(sel)
cmd.frame(fra)
cmd.get_wizard().apply()
cmd.set_wizard("done")
cmd.save("residue" + str(resi) + "to" + caa + "rotamer" +
str(fra) + ".pdb")
def testSaveState(self, format, pymol_version):
if pymol_version > testing.PYMOL_VERSION[1]:
self.skipTest("version %f" % (pymol_version))
# for rms_cur (not all formats save all identifiers)
m = -1
cmd.set('retain_order')
# create a multistate object
cmd.fragment('ala', 'm1')
cmd.create('m1', 'm1', 1, 2)
cmd.create('m1', 'm1', 1, 3)
cmd.translate([5, 0, 0], 'm1', state=2)
cmd.translate([0, 5, 0], 'm1', state=3)
n_states = cmd.count_states('m1')
with testing.mktemp('.' + format) as filename:
if format == 'mae' and not pymol.invocation.options.incentive_product:
format = 'cms'
# explicit
for state in range(1, n_states + 1):
cmd.delete('m2')
cmd.save(filename, 'm1', state=state)
cmd.load(filename, 'm2', format=format)
rms = cmd.rms_cur('m1', 'm2', state, 1, matchmaker=m)
self.assertAlmostEqual(rms, 0.00, delta=1e-2)
# current state
for state in range(1, n_states + 1):
cmd.frame(state)
cmd.delete('m2')
cmd.save(filename, 'm1')
cmd.load(filename, 'm2', 1, format=format)
rms = cmd.rms_cur('m1', 'm2', state, 1, matchmaker=m)
self.assertAlmostEqual(rms, 0.00, delta=1e-2)
if format in ('mol', 'cms'):
# no multi support
return
# all states
cmd.delete('m2')
cmd.save(filename, 'm1', state=0)
cmd.load(filename, 'm2', 1, discrete=1, multiplex=0)
self.assertEqual(cmd.count_states('m2'), n_states)
for state in range(1, n_states + 1):
rms = cmd.rms_cur('m1', 'm2 and state %d' % state,
state, state, matchmaker=m)
self.assertAlmostEqual(rms, 0.00, delta=1e-2)
def closest_keyframe(quiet=1):
'''
DESCRIPTION
Jump to the closest movie keyframe.
'''
keyframes = get_keyframes()
if not keyframes:
return 0
current = cmd.get_frame()
r = min(keyframes, key=lambda i: abs(i - current))
cmd.frame(r)
if not int(quiet):
print(' Closest Keyframe: ' + str(r))
return r
def closest_keyframe(quiet=1):
'''
DESCRIPTION
Jump to the closest movie keyframe.
'''
keyframes = get_keyframes()
if not keyframes:
return 0
current = cmd.get_frame()
r = min(keyframes, key=lambda i: abs(i - current))
cmd.frame(r)
if not int(quiet):
print(' Closest Keyframe: ' + str(r))
return r
def compute_contact_surface(opts):
with open(opts.output, "w") as fd:
print(
"{:5}{:>12}{:>12}{:>12}{:>12}{:>12}".format(
"",
"ligand",
"protein",
"complex",
"contact",
"ligand",
),
file=fd,
)
print(
"{:5}{:>12}{:>12}{:>12}{:>12}{:>12}".format(
"frame",
"area(Å\u00b2)",
"area(Å\u00b2)",
"area(Å\u00b2)",
"area(Å\u00b2)",
"portion(%)",
),
file=fd,
)
for f in range(2, cmd.count_frames() + 1):
print("Processing frame {}...".format(f - 1), flush=True)
cmd.frame(f)
set_selections(opts, f)
ligand_area = cmd.get_area("ligand", f)
protein_area = cmd.get_area("protein", f)
complex_area = cmd.get_area("complex", f)
contact_area = ((ligand_area + protein_area) - complex_area) / 2
ligand_portion = (contact_area * 100) / ligand_area
print(
"{:5}{:12.4f}{:12.4f}{:12.4f}{:12.4f}{:12.1f}".format(
f - 1,
ligand_area,
protein_area,
complex_area,
contact_area,
ligand_portion,
),
file=fd,
)
print("Output written to {}".format(opts.output))
def mutate_to_cys(pdb, resnum_i):
selection_i = "resi " + str(resnum_i)
cmd.wizard("mutagenesis")
cmd.get_wizard().set_mode("CYS")
cmd.do("refresh_wizard")
cmd.get_wizard().do_select(selection_i)
cmd.get_wizard().do_select(selection_i)
for frame_i in [1, 2, 3]:
cmd.frame(frame_i)
cmd.create("rotamer_" + str(resnum_i) + "_" + str(frame_i), "mutation", frame_i, 1)
rotamer_i_pymol_prefix = "/" + "rotamer_" + str(resnum_i) + "_" + str(frame_i) + "///" + resnum_i + "/"
cmd.set_wizard("done")
def next_keyframe(quiet=1):
'''
DESCRIPTION
Jump to the next movie keyframe.
'''
keyframes = get_keyframes()
current = cmd.get_frame()
keyframes = [i for i in keyframes if i > current]
if keyframes:
r = keyframes[0]
cmd.frame(r)
else:
r = None
if not int(quiet):
print(' Next Keyframe: ' + str(r))
return r
def prev_keyframe(quiet=1):
'''
DESCRIPTION
Jump to the previous movie keyframe.
'''
keyframes = get_keyframes()
current = cmd.get_frame()
keyframes = [i for i in keyframes if i < current]
if keyframes:
r = keyframes[-1]
cmd.frame(r)
else:
r = None
if not int(quiet):
print(' Previous Keyframe: ' + str(r))
return r
def make_all():
#make the whole movie
global views
global frames
global models
#first get total number of frames
ftot = 0
i = 0
setcommand = ""
for nframes in frames[:-1]:
ftot += nframes
if models.has_key(i):
setcommand += " " + models[i] + " "
else:
setcommand += " 1 x%i" % nframes
i += 1
#initialize movie
#cmd.mset("1 x%i" % ftot)
#cmd.mset("1 x50 1 -30 30 x20")
cmd.mset( setcommand )
#loop through views
start_view = views[0][:]
i = 0
first_frame = 1
for view in views[1:]:
end_view = view[:]
if settings.has_key(i):
movs.animate_transition( start_view, end_view, frames[i], first_frame, settings[i] )
elif fades.has_key(i):
movs.animate_transition( start_view, end_view, frames[i], first_frame, fades[i] )
else:
movs.animate_transition( start_view, end_view, frames[i], first_frame )
#add an action
if actions.has_key(i):
mdo_cmd = actions[i]#+";set_view ("+str( views[i] )+")"
print mdo_cmd
cmd.mdo(first_frame, mdo_cmd)
first_frame += frames[i]
i += 1
start_view = end_view[:]
cmd.frame(1)
def frames2states(selection, specification):
'''
DESCRIPTION
Map specific object states to frames.
"specification" is a sequence of "frame:state" mappings.
EXAMPLE
fetch 1d7q 1nmr, async=0
mset 1-20
# reverse state order just for 1nmr
frames2states 1nmr, 1:20 20:1
'''
names = cmd.get_object_list('(' + selection + ')')
for x in specification.split():
frame, state = x.split(':')
cmd.frame(int(frame))
for name in names:
cmd.mview('store', object=name, state=int(state))
def pymol_mutate(file_name, chain, res_index, number):
pymol.finish_launching()
cmd.delete(file_name[:-4])
selection = chain + '/' + res_index + '/'
mutant = 'CYS'
cmd.wizard("mutagenesis")
pdb = file_name[:-4]
cmd.load(file_name)
cmd.refresh_wizard()
cmd.get_wizard().set_mode(mutant)
cmd.get_wizard().do_select(selection)
nStates = cmd.count_states("mutation")
for i in range(1, nStates + 1):
cmd.get_wizard().do_select(selection)
cmd.frame(i)
cmd.get_wizard().apply()
cmd.save("rec_" + str(res_index) + "_" + str(i) + ".pdb")
cmd.set_wizard()
cmd.remove(file_name[:-4])
def make_all():
# make the whole movie
global views
global frames
global models
# first get total number of frames
ftot = 0
setcommand = ""
for i, nframes in enumerate(frames[:-1]):
ftot += nframes
if i in models:
setcommand += " " + models[i] + " "
else:
setcommand += " 1 x%i" % nframes
# initialize movie
# cmd.mset("1 x%i" % ftot)
# cmd.mset("1 x50 1 -30 30 x20")
cmd.mset(setcommand)
# loop through views
start_view = views[0][:]
first_frame = 1
for i, view in enumerate(views[1:]):
end_view = view[:]
if i in settings:
movs.animate_transition(start_view, end_view, frames[i], first_frame, settings[i])
elif i in fades:
movs.animate_transition(start_view, end_view, frames[i], first_frame, fades[i])
else:
movs.animate_transition(start_view, end_view, frames[i], first_frame)
# add an action
if i in actions:
mdo_cmd = actions[i] # +";set_view ("+str( views[i] )+")"
print mdo_cmd
cmd.mdo(first_frame, mdo_cmd)
first_frame += frames[i]
start_view = end_view[:]
cmd.frame(1)
def testMadd(self):
# test clearing
self.prep_movie()
self.assertEquals(cmd.count_frames(),60)
# test states and frame mapping
cmd.madd("1x10 1 -10 10 -1")
self.assertEquals(cmd.count_frames(),90)
cmd.frame(1)
self.assertEquals(cmd.get_frame(),1)
self.assertEquals(cmd.get("state"),"1")
cmd.frame(10)
self.assertEquals(cmd.get_frame(),10)
self.assertEquals(cmd.get("state"),"1")
cmd.frame(72)
self.assertEquals(cmd.get_frame(),72)
self.assertEquals(cmd.get("state"),"2")
cmd.frame(82)
self.assertEquals(cmd.get_frame(),82)
self.assertEquals(cmd.get("state"),"9")
cmd.frame(90)
self.assertEquals(cmd.get_frame(),90)
self.assertEquals(cmd.get("state"),"1")
def testForward(self):
self.prep_movie()
cmd.forward()
self.assertEquals(cmd.get_frame(),2)
cmd.forward()
self.assertEquals(cmd.get_frame(),3)
cmd.frame(30)
self.assertEquals(cmd.get_frame(),30)
cmd.frame(60)
cmd.forward()
self.assertEquals(cmd.get_frame(),60)
cmd.frame(60)
cmd.forward()
self.assertEquals(cmd.get_frame(),60)
def testMdelete(self):
cmd.mset("1x10 1 -10 10 -1")
# 1-10 = state 1
# 11-20 = states 1..10
# 21-30 = states 10..1
cmd.mdelete(count=10, frame=11)
# simple delete
self.assertEquals(cmd.count_frames(),20)
# test state mapping
cmd.frame(1)
self.assertEquals(cmd.get("state"),"1")
cmd.frame(11)
self.assertEquals(cmd.get("state"),"10")
cmd.frame(20)
self.assertEquals(cmd.get("state"),"1")
def frag(state=state, obj=obj3):
pwd, orig_sequence = setup(obj)
stored.rotamerDict = {}
# Add and retain hydrogens
cmd.get_wizard().set_hyd("keep")
# Run over all sites where to mutate
for site in mutations.keys():
variants = mutations[site]
# Run over all variants.
for variant in variants:
cmd.load(obj)
cmd.do('wizard mutagenesis')
cmd.do('refresh_wizard')
cmd.get_wizard().do_select("(%s/)" % site)
cmd.do("cmd.get_wizard().set_mode('%s')"%variant)
# Get the number of available rotamers at that site
# Introduce a condition here to check if
# rotamers are requested.
# <<OPTION>>
print variant, "variant"
nRots = getRots(site, variant)
nRots = 2
stored.rotamerDict[str(site)+getOne(variant)] = nRots
cmd.rewind()
for i in range(1, nRots + 1):
cmd.get_wizard().do_select("(" + site + "/)")
cmd.frame(i)
cmd.get_wizard().apply()
# Optimize the mutated sidechain
#<<OPTION>>
print "Sculpting."
localSculpt(obj, site)
# Protonation of the N.
cmd.do("select n%d, name n and %d/" % (int(site), int(site)))
cmd.edit("n%d" % int(site), None, None, None, pkresi=0, pkbond=0)
cmd.do("h_fill")
# Protonation of the C.
cmd.do("select c%d, name c and %d/" % (int(site), int(site)))
cmd.edit("c%d" % int(site), None, None, None, pkresi=0, pkbond=0)
cmd.do("h_fill")
# Definition of saveString
saveString = '%s/' % pwd
saveString += 'frag-' + getOne(orig_sequence[site]).lower() +\
site + getOne(variant).lower() + '-rot%i-%s.pdb, ' \
% (i,state) +'((%s/))' % site
#print saveString
cmd.do('save %s' % saveString)
cmd.do('delete all')
cmd.set_wizard('done')
print "Frag is all done"
#cmd.show('surface', 'tcr')
# Create one-to-one mapping between states and frames.
cmd.mset("1 -%d" % cmd.count_states())
# Zoom viewport
#cmd.zoom('complex')
#cmd.orient('complex')
cmd.zoom('ligand')
cmd.orient('ligand')
cmd.turn('x', -90)
# Render movie
frame_prefix = 'frames/frame'
cmd.set('ray_trace_frames', 1)
cmd.set('ray_trace_frames', 0) # DEBUG
for iteration in range(niterations):
print "rendering frame %04d / %04d" % (iteration+1, niterations)
cmd.frame(iteration+1)
cmd.set('stick_transparency', float(ncfile.variables['states'][iteration, replica]) / float(nstates-1))
cmd.png(frame_prefix + '%04d.png' % (iteration), ray=True)
#cmd.mpng(frame_prefix, iteration+1, iteration+1)
#cmd.load_model(model, 'complex')
cmd.set('ray_trace_frames', 0)
# Close file
ncfile.close()
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 apply(self):
cmd = self.cmd
pymol = cmd._pymol
if self.status == 1:
# find the name of the object which contains the selection
new_name = None
obj_list = cmd.get_names("objects")
for a in obj_list:
if cmd.get_type(a) == "object:molecule":
if cmd.count_atoms("(%s and %s)" % (a, src_sele)):
new_name = a
break
src_frame = cmd.get_state()
if new_name == None:
print " Mutagenesis: object not found."
else:
auto_zoom = cmd.get_setting_text("auto_zoom")
cmd.set("auto_zoom", "0", quiet=1)
if self.lib_mode != "current":
# create copy w/o residue
cmd.create(tmp_obj1, "(%s and not %s)" % (new_name, src_sele))
# remove existing c-cap in copy (if any)
cmd.remove("byres (name N and (%s in (neighbor %s)) and resn nme,nhh)" % (tmp_obj1, src_sele))
# remove existing n-cap in copy (if any)
cmd.remove("byres (name C and (%s in (neighbor %s)) and resn ace)" % (tmp_obj1, src_sele))
# save copy for bonded atom reference
cmd.create(tmp_obj3, new_name)
# transfer the selection to copy
cmd.select(src_sele, "(%s in %s)" % (tmp_obj3, src_sele))
# create copy with mutant in correct frame
cmd.create(tmp_obj2, obj_name, src_frame, 1)
cmd.set_title(tmp_obj2, 1, "")
cmd.delete(new_name)
# create the merged molecule
cmd.create(new_name, "(%s or %s)" % (tmp_obj1, tmp_obj2), 1) # only one state in merged object...
# now connect them
cmd.select(mut_sele, "(byres (%s like %s))" % (new_name, src_sele))
# bond N+0 to C-1
if (cmd.select(tmp_sele1, "(name C and (%s in (neighbor %s)))" % (new_name, src_sele)) == 1) and (
cmd.select(tmp_sele2, "((%s in %s) and n;N)" % (mut_sele, tmp_obj2)) == 1
):
cmd.bond(tmp_sele1, tmp_sele2)
cmd.set_geometry(tmp_sele1, 3, 3) # make amide planer
cmd.set_geometry(tmp_sele2, 3, 3) # make amide planer
# bond C+0 to N+1
if (cmd.select(tmp_sele1, "(name N and (%s in (neighbor %s)))" % (new_name, src_sele)) == 1) and (
cmd.select(tmp_sele2, "((%s in %s) and n;C)" % (mut_sele, tmp_obj2)) == 1
):
cmd.bond(tmp_sele1, tmp_sele2)
cmd.set_geometry(tmp_sele1, 3, 3) # make amide planer
cmd.set_geometry(tmp_sele2, 3, 3) # make amide planer
cmd.delete(tmp_sele1)
cmd.delete(tmp_sele2)
# fix N-H hydrogen position (if any exists)
cmd.h_fix("(name N and bound_to (%s in %s and n;H))" % (new_name, tmp_obj2))
# now transfer selection back to the modified object
cmd.delete(tmp_obj1)
cmd.delete(tmp_obj2)
cmd.delete(tmp_obj3)
self.clear()
# and return to frame 1
cmd.frame(1)
cmd.refresh_wizard()
else:
# create copy with conformation in correct state
cmd.create(tmp_obj2, obj_name, src_frame, 1)
# remove existing c-cap in copy (if any)
cmd.remove("byres (name N and (%s in (neighbor %s)) and resn nme,nhh)" % (new_name, src_sele))
cmd.remove("(%s) and name OXT" % src_sele)
# remove existing n-cap in copy (if any)
cmd.remove("byres (name C and (%s in (neighbor %s)) and resn ace)" % (new_name, src_sele))
# save existing conformation on undo stack
# cmd.edit("((%s in %s) and name ca)"%(new_name,src_sele))
cmd.push_undo("(" + src_sele + ")")
# modify the conformation
cmd.update(new_name, tmp_obj2)
# cmd.unpick()
cmd.delete(tmp_obj2)
self.clear()
# and return to frame 1
cmd.frame(1)
cmd.refresh_wizard()
cmd.set("auto_zoom", auto_zoom, quiet=1)
cmd.show('cartoon')
cmd.hide('surface')
cmd.scene('S1', action='store', view=0, frame=0, animate=-1)
cmd.hide('cartoon', 'chain A+B+C')
cmd.show('mesh', 'chain A')
cmd.show('sticks', 'chain A+B+C')
cmd.scene('S2', action='store', view=0, frame=0, animate=-1)
cmd.set('ray_trace_mode', 0)
cmd.mset(1, 500)
cmd.frame(0)
cmd.scene('S0')
cmd.mview()
cmd.frame(60)
cmd.set_view((-0.175534308, -0.331560850, -0.926960170,
0.541812420, 0.753615797, -0.372158051,
0.821965039, -0.567564785, 0.047358301,
0.000000000, 0.000000000, -249.619018555,
58.625568390, 15.602619171, 77.781631470,
196.801528931, 302.436492920, -20.000000000))
cmd.mview()
cmd.frame(90)
cmd.set_view((-0.175534308, -0.331560850, -0.926960170,
0.541812420, 0.753615797, -0.372158051,
0.821965039, -0.567564785, 0.047358301,
