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 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 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 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 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 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 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 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,