def mini(total_steps=500, gradient=0.001, interval=100, object='rt', fix_flag=None, rest_flag=None, solvation=None, finish=None): global state if not state: print " realtime.mini: please run setup first..." else: model = state.model print " realtime.mini: %d atoms total\n" % model.nAtom try: while total_steps>0: total_steps = total_steps - interval state.minimize(max_iter=interval, fix_flag=fix_flag, rest_flag=rest_flag, solvation=solvation) cmd.delete(object) cmd.load_model(state.model,object,1) cmd.refresh() if finish!=None: apply(finish[0],finish[1],finish[2]) except: cmd.load_model(state.model,'ref') traceback.print_exc() print " realtime.mini: complete."
def set_raw_alignment(name, aln, transform=0): ''' DESCRIPTION API only. Load an alignment object from a list like the one obtained with cmd.get_raw_alignment ''' import itertools if not isinstance(aln[0], dict): aln = [dict(idx_pair) for idx_pair in aln] models = set(model for idx_pdict in aln for model in idx_pdict) sele1 = cmd.get_unused_name('_sele1') sele2 = cmd.get_unused_name('_sele2') fit = cmd.fit if transform else cmd.rms_cur for model1, model2 in itertools.combinations(models, 2): index_list1 = [] index_list2 = [] for idx_pdict in aln: if model1 in idx_pdict and model2 in idx_pdict: index_list1.append(idx_pdict[model1]) index_list2.append(idx_pdict[model2]) cmd.select_list(sele1, model1, index_list1, mode='index') cmd.select_list(sele2, model2, index_list2, mode='index') fit(sele1, sele2, cycles=0, matchmaker=4, object=name) cmd.delete(sele1) cmd.delete(sele2)
def testPseSupport(self): cmd.load_callback(callback.Callback(), 'c1') with testing.mktemp('tmp.pse') as session_filename: cmd.save(session_filename) cmd.delete('*') cmd.load(session_filename) self.assertTrue('c1' in cmd.get_names())
def testFun(filePath): import networkx as nx cmd.delete("all") cmd.fetch("1C3W") cmd.hide("lines", "all") cmd.show("cartoon", "1C3W") cmd.color("green", "all") #------------------------------ cmd.color("yellow", "resi 194 and resn GLU") #------------------------------- cmd.show("sticks", "resi 194 and resn GLU") highlightRes("GLUA0194", color="yellow") highlightRes("GLUA0204", color="yellow") g = loadHbTxt(filePath) allNodes = nx.node_connected_component(g, "GLUA0194") #=========================================================================== # print allNodes #=========================================================================== accRes = {} for line in open("/Users/xzhu/sibyl/BR/1C3W/hydro/def/raw/acc.res"): fields = line.split() resString = fields[1] + fields[2] acc = float(fields[4]) accRes[resString] = acc colorThreshold = 0.02 for eachResidue in accRes.keys(): if accRes[eachResidue] > colorThreshold: if eachResidue in allNodes: print eachResidue highlightRes(eachResidue)
def load(): r = 0 rep = [ "simple", "technical", "ligands", "ligand_sites","ligand_sites_trans","ligand_sites_mesh","pretty", "publication" ] list = glob("pdb/*/*") # while list[0]!="pdb/f8/pdb1f8u": # list.pop(0) for file in list: print file cmd.delete('pdb') cmd.load(file,'pdb') cmd.orient('pdb') cur_rep = rep.pop(0) rep = rep + [cur_rep] getattr(pymol.preset,cur_rep)('pdb') cmd.refresh() # give PyMOL a chance time.sleep(0.02) time.sleep(0.02) time.sleep(0.02) time.sleep(0.02) cmd.refresh() time.sleep(0.02) time.sleep(0.02) time.sleep(0.02) time.sleep(0.02) while(pymol.run==0): time.sleep(0.1)
def load_save1(): while 1: time.sleep(random.random()) cmd.delete("obj1") cmd.load("dat/pept.pdb","obj1") time.sleep(random.random()) cmd.save("tmp/T01a.pdb","obj1")
def load_save2(): while 1: time.sleep(random.random()) cmd.delete("obj2") cmd.load("dat/water.pdb","obj2") time.sleep(random.random()) cmd.save("tmp/T01b.pdb","obj2")
def load(): cmd.set("valence") r = 0 list = glob("pdb/*/*") # while list[0]!="pdb/f8/pdb1f8u": # list.pop(0) for file in list: try: cmd.delete('pdb') cmd.load(file,'pdb') cmd.set_title('pdb',1,os.path.split(file)[-1]) cmd.rewind() cmd.orient('pdb') cmd.refresh() cmd.show_as("ribbon") cmd.refresh() cmd.show_as("sticks") cmd.refresh() sys.__stderr__.write(".") sys.__stderr__.flush() n = cmd.count_states() if n>1: cmd.rewind() sys.__stderr__.write(file+"\n") sys.__stderr__.flush() for a in range(1,n+1): cmd.forward() cmd.refresh() except: traceback.print_exc()
def minimize(selection='all', forcefield='MMFF94s', method='conjugate gradients', nsteps=500, conv=0.0001, cutoff=False, cut_vdw=6.0, cut_elec=8.0): pdb_string = cmd.get_pdbstr(selection) name = cmd.get_legal_name(selection) obconversion = ob.OBConversion() obconversion.SetInAndOutFormats('pdb', 'pdb') mol = ob.OBMol() obconversion.ReadString(mol, pdb_string) mol.AddHydrogens() ff = ob.OBForceField.FindForceField(forcefield) # GAFF, MMFF94s, MMFF94, UFF, Ghemical ff.Setup(mol) if cutoff == True: ff.EnableCutOff(True) ff.SetVDWCutOff(cut_vdw) ff.SetElectrostaticCutOff(cut_elec) if method == 'conjugate gradients': ff.ConjugateGradients(nsteps, conv) else: ff.SteepestDescent(nsteps, conv) ff.GetCoordinates(mol) nrg = ff.Energy() pdb_string = obconversion.WriteString(mol) cmd.delete(name) if name == 'all': name = 'all_' cmd.read_pdbstr(pdb_string, name) print '#########################################' print 'The Energy of %s is %8.2f %s ' % (name, nrg, ff.GetUnit()) print '#########################################'
def colorize(): cmd.hide('(not (name C+CA+N+O))') cmd.spectrum('b', 'red_yellow_green', minimum='-1.0', maximum='1.0') cmd.select('missing', 'b = -2.0') cmd.color('white', 'missing') cmd.delete('missing')
def com(selection,state=None,mass=None,object=None, quiet=1, **kwargs): """ DESCRIPTION Places a pseudoatom at the center of mass Author: Sean Law Michigan State University slaw (at) msu . edu SEE ALSO pseudoatom, get_com """ quiet = int(quiet) if (object == None): object = cmd.get_legal_name(selection) object = cmd.get_unused_name(object + "_COM", 0) cmd.delete(object) if (state != None): x, y, z=get_com(selection,mass=mass, quiet=quiet) if not quiet: print "%f %f %f" % (x, y, z) cmd.pseudoatom(object,pos=[x, y, z], **kwargs) cmd.show("spheres",object) else: for i in range(cmd.count_states()): x, y, z=get_com(selection,mass=mass,state=i+1, quiet=quiet) if not quiet: print "State %d:%f %f %f" % (i+1, x, y, z) cmd.pseudoatom(object,pos=[x, y, z],state=i+1, **kwargs) cmd.show("spheres", 'last ' + object)
def slowpacking(pdb): "Derive mean packing density of pdb as pd.Series." cmd.delete('all') cmd.load(pdb) cmd.remove('solvent') # Only heavy atoms cmd.remove('hydro') # Compute SAS per atom cmd.set('dot_solvent') cmd.get_area('all', load_b=1) N = float(cmd.select('interior', 'b = 0')) internal_coords = [at.coord for at in cmd.get_model('interior').atom]#[1:50] all_coords = [at.coord for at in cmd.get_model('all').atom]#[1:50] # Count counts = pd.Series(0, index=RADS) for a, b in product(internal_coords, all_coords): es = euclid_step(a, b) if es is not None: counts.loc[es] += 1 counts = counts.cumsum() # Mean per center atom meancounts = counts / N # Normalize to density volumina = pd.Series(4 / 3.0 * sp.pi * (RADS ** 3), index=RADS) density = meancounts / volumina # Correct for center density -= 1 / (4/3 * sp.pi * RADS ** 3) # Results counts.index = ["{}_correctcount".format(i) for i in counts.index] density.index = ["{}_density".format(i) for i in density.index] return pd.concat(([counts, density]))
def on_showaxes_clicked(self, event=None): if self.showaxesbtn['text'] == 'Show the axes': draw_axes() self.showaxesbtn['text'] = 'Hide the axes' else: cmd.delete('axes') self.showaxesbtn['text'] = 'Show the axes'
def cartoonize(color, rep): """draw a cartoon representation of glycans""" stored.ResiduesNumber = [] cmd.iterate('name c1', 'stored.ResiduesNumber.append((resi))') resn_list = [int(i) for i in stored.ResiduesNumber] bonds = get_glyco_bonds(resn_list[0], resn_list[-1]+1) con_matrix = writer(bonds) #con_matrix = writer2(bonds) rings = find_rings(resn_list) rings_coords = get_ring_coords(resn_list, rings) bonds_coords = get_bonds_coords(resn_list, con_matrix) colors = get_colors_c1(resn_list, color) bonds_colors = get_bonds_colors(resn_list, con_matrix, color) cmd.set('suspend_updates', 'on') for state, coords in enumerate(rings_coords): obj = [] if rep == 'beads': radius_s = 1.8 radius_b = 0.18 obj = beads(obj, coords, colors[state], radius_s) obj = cylinder(obj, bonds_coords[state], bonds_colors[state], radius_b) else: if rep == 'cartoon': radius = 0.075 else: radius = 0.035 obj = hexagon(obj, coords, colors[state], rep, radius) obj = cylinder(obj, bonds_coords[state], bonds_colors[state], radius) cmd.load_cgo(obj,'cgo01', state+1) cmd.select('glycan', 'byres name C1') cmd.delete('glycan') cmd.delete('tmp') cmd.set('two_sided_lighting', 1) cmd.set('suspend_updates', 'off')
def packing(pdb): "Derive mean packing density of pdb as pd.Series." cmd.delete('all') cmd.load(pdb) cmd.remove('solvent') # Only heavy atoms cmd.remove('hydro') # Compute SAS per atom cmd.set('dot_solvent', 1) cmd.get_area('all', load_b=1) cmd.select('interior', 'b = 0') counts = pd.Series(0, index=RADS) vest = pd.Series(0, index=RADS) # from biggest to smallest radius for r in RADS[::-1]: # Counting counts.loc[r] = cmd.select('extended', 'interior extend {}'.format(r)) cmd.remove('not extended') # moleculare area #cmd.set('dot_solvent', 0) vest[r] = cmd.get_area('all') # Results cvdens = counts / vest counts.index = ["{}_rawcount".format(i) for i in counts.index] vest.index = ["{}_volume estimate".format(i) for i in vest.index] cvdens.index = ["{}_cv density".format(i) for i in cvdens.index] return pd.concat(([counts, cvdens, vest]))
def process_molecule_mae(file_header, mol, suspend_undo): global already_processed global undo_each_molecule tot = [] tot.extend(file_header) tot.extend(mol) molstr = string.join(tot,'') nameorig, mdl = read_mae_model(molstr) name = nameorig.strip() if name in already_processed: return True already_processed = set(already_processed | set([name])) tmpname = "_temp_%s" % name cmd.delete(tmpname) try: cmd.load_model(mdl, tmpname) natoms = cmd.count_atoms(tmpname) except: return False if undo_each_molecule: cmd.push_undo( "( %s )" % name, just_coordinates=0) cmd.set("suspend_undo", 1, updates=0) cmd.remove(name) cmd.create(name, tmpname, copy_properties=True) cmd.set_title(name, -1, "") cmd.delete(tmpname) if undo_each_molecule: cmd.set("suspend_undo", suspend_undo, updates=0) cmd.push_undo("", just_coordinates=0, finish_undo=1) return True
def showHbBond(sele1, sele2, onlyShortest=True): '''Show hydrogen bond between two residues. ''' atoms1 = getAllAtoms(sele1) atoms2 = getAllAtoms(sele2) smallestDist = 10000 smallestDistObj = None for firstAtom in atoms1: if not hasHbond(firstAtom): continue firstSele = "name " + firstAtom + " and " + sele1 for secondAtom in atoms2: if not hasHbond(secondAtom): continue secondSele = "name " + secondAtom + " and " + sele2 # print firstSele # print secondSele distName = sele1+firstAtom+'-'+sele2+secondAtom tempDist = cmd.distance(distName, firstSele, secondSele) if tempDist < smallestDist: smallestDist = tempDist if smallestDistObj: cmd.delete(smallestDistObj) smallestDistObj = distName else: cmd.delete(distName)
def DisplaySphere(self): try: # Display the Sphere cmd.delete(self.SphereDisplay) cmd.refresh() except: pass try: cmd.pseudoatom(self.SphereDisplay, pos=self.SphereView.Center, vdw=self.SphereView.Radius, state=self.State) cmd.refresh() cmd.color('oxygen', self.SphereDisplay) cmd.refresh() cmd.hide('everything', self.SphereDisplay) cmd.refresh() cmd.show('spheres', self.SphereDisplay) cmd.refresh() except: self.ErrorCode = 1 return self.ErrorCode
def process_molecule_sdf(mol, suspend_undo): global already_processed global undo_each_molecule nameorig = mol[0] name = nameorig.strip() if name in already_processed: return True already_processed = set(already_processed | set([name])) tmpname = "_temp_%s" % name molstr = string.join(mol,'') cmd.delete(tmpname) try: importing.read_sdfstr(molstr, tmpname,object_props='*') natoms = cmd.count_atoms(tmpname) except: return False if undo_each_molecule: cmd.push_undo( "( %s )" % name, just_coordinates=0) cmd.set("suspend_undo", 1, updates=0) cmd.remove(name) print "before cmd.create(): using copy_properties=True" cmd.create(name, tmpname, copy_properties=True) cmd.set_title(name, -1, "") cmd.delete(tmpname) if undo_each_molecule: cmd.set("suspend_undo", suspend_undo, updates=0) cmd.push_undo("", just_coordinates=0, finish_undo=1) return True
def rc( selection = "all" ): """ tube coloring for large RNA comparisons """ cmd.bg_color( "white" ) cmd.hide( 'everything',selection ) cmd.color( 'red','resn rG+G+DG and '+selection ) cmd.color( 'forest','resn rC+C+DC and '+selection) cmd.color( 'orange','resn rA+A+DA and '+selection) cmd.color( 'blue','resn rU+U+DT+BRU and '+selection) cmd.select( 'backbone', " (name o1p+o2p+o3p+p+op1+op2+'c1*'+'c2*'+'c3*'+'c5*'+'o2*'+'o3*'+'o4*'+'o5*'+'c1*'+'c2*'+'c3*'+'c4*'+'o2*'+'o4*'+c1'+c2'+c3'+c5'+o2'+o3'+o4'+o5'+c1'+c2'+c3'+c4'+o2'+o4') and (not name c1+c2+c3+c4+c5+o2+o3+o4+o5) ") #for x in AllObj: #print x cmd.show( "cartoon", selection ) cmd.spectrum( "resi", "rainbow", selection+" and backbone" ) cmd.cartoon( "tube", "backbone and "+selection ) cmd.set( "cartoon_ring_mode", 0 ) cmd.set( "cartoon_ring_transparency", 0.0 ) cmd.set( "cartoon_tube_radius", 1.0 ) cmd.color( 'red','resn rG+G and name n1+c6+o6+c5+c4+n7+c8+n9+n3+c2+n1+n2 and '+selection) cmd.color( 'forest','resn rC+C and name n1+c2+o2+n3+c4+n4+c5+c6 and '+selection) cmd.color( 'orange','resn rA+A and name n1+c6+n6+c5+n7+c8+n9+c4+n3+c2 and '+selection) cmd.color( 'blue','resn rU+U and name n3+c4+o4+c5+c6+n1+c2+o2 and '+selection) cmd.delete('backbone')
def Quit_Wizard(self): try: # Delete Sphere object General_cmd.unmask_Objects(self.exc) cmd.config_mouse(self.config_mouse) cmd.delete(self.SphereDisplay) cmd.refresh() except: pass # Catch error in App if self.ErrorCode > 0: self.App.WizardError = True # Re-enable controls self.App.ActiveWizard = None cmd.set_wizard() cmd.set_view(self.View) cmd.refresh() self.queue.put(lambda: self.top.SphereRunning(False)) self.queue.put(lambda: self.top.top.root.deiconify()) self.queue.put(lambda: self.top.top.root.update())
def chain_contact(): def chain_contact_loop(c,skip,chainPullList): d = 0 l = c + 1 while len(chainPullList) > l and (26-d) >= 0: cmd.select('chain_contact','%s w. 5 of %s'%(chainPullList[d],chainPullList[c+1]),enable=0,quiet=1,merge=1) cmd.select('chain_contact','%s w. 5 of %s'%(chainPullList[c+1],chainPullList[d]),enable=0,quiet=1,merge=1) d += 1 l += 1 while d == (c+1) or d in skip: d += 1 glb.update() cmd.hide('everything') cmd.show('mesh', 'all') cmd.color('gray40', 'all') objects = cmd.get_names('all') chainPullList = [] for i in cmd.get_chains(quiet=1): chainPullList.append('Chain-'+i) if len(chainPullList) < 2: showinfo('Notice','There needs to be two or more chains to run this functions.') return False c = 0 skip = [] while c < (len(chainPullList)-1) and c < 26: skip.append(c+1) chain_contact_loop(c,skip,chainPullList) c += 1 glb.procolor('chain_contact','mesh','cpk',None) cmd.delete('chain_contact') return chainPullList
def load(): cmd.set("valence") r = 0 list = glob("pdb/*/*") # while list[0]!="pdb/f8/pdb1f8u": # list.pop(0) for file in list: try: cmd.delete('pdb') cmd.load(file,'pdb') cmd.set_title('pdb',1,os.path.split(file)[-1]) cmd.rewind() cmd.orient('pdb') cmd.refresh() cmd.zoom('center',16) cmd.label("polymer and (name ca or elem P)","'//%s/%s/%s`%s/%s'%(segi,chain,resn,resi,name)") cmd.refresh() sys.__stderr__.write(".") sys.__stderr__.flush() n = cmd.count_states() if n>1: cmd.rewind() sys.__stderr__.write(file+"\n") sys.__stderr__.flush() for a in range(1,n+1): cmd.forward() cmd.refresh() except: traceback.print_exc()
def test_conelineinter(sele): v = com(sele + " and name SG") a = (v - com(sele + " and name CB")).normalized() print v, a p = v + 5 * randvec() d = randvec().normalized() # v = Vec(0, 0, 0) # a = Vec(1, 0, 0) t = 45 X = conelineinter(p, d, v, a, t) print "p", p print "d", d print "v", v print "a", a print "t", t print "X", X cmd.delete("lines") cmd.delete("X*") cmd.delete("L*") cmd.delete("A*") cmd.delete("B*") drawlines(p, d) for i, x in enumerate(X): createpoint(sele, x, "X" + str(i)) o = projperp(a, x - v) L = o.length() o = o.normalized() ang = 90.0 - math.atan(1.0 / L) * 180.0 / math.pi print ang o1 = rotation_matrix(a, ang) * o o2 = rotation_matrix(a, -ang) * o createpoint(sele, v + o1, "A" + str(i)) createpoint(sele, v + o2, "B" + str(i)) drawlines(x, (x - (v + o1)).normalized(), "LA" + str(i)) drawlines(x, (x - (v + o2)).normalized(), "LB" + str(i))
def amber99(selection="(all)",quiet=0,_self=cmd): cmd=_self result = 1 # first, set all parameters to zero cmd.alter(selection,"partial_charge=0") cmd.alter(selection,"elec_radius=0.0") cmd.alter(selection,"text_type=''") # next, flag all atoms so that we'll be able to detect what we miss cmd.flag(23,selection,'set') # get the amber99 dictionary if not hasattr(champ,'amber99_dict'): from chempy.champ.amber99 import amber99_dict champ.amber99_dict = amber99_dict # iterate through the residue dictionary matching each residue based on chemistry # and generating the expressions for reassigning formal charges alter_list = [] for resn in champ.amber99_dict.keys(): if cmd.select(tmp_sele1,"(%s) and resn %s"%(selection,resn))>0: entry = champ.amber99_dict[resn] for rule in entry: model = cmd.get_model(tmp_sele1) ch = Champ() model_pat = ch.insert_model(model) ch.pattern_detect_chirality(model_pat) assn_pat = ch.insert_pattern_string(rule[0]) ch.pattern_clear_tags(model_pat) if ch.match_1v1_n(assn_pat,model_pat,10000,2)>0: result = ch.pattern_get_ext_indices_with_tags(model_pat) for atom_tag in result[0]: # just iterate over atom tags if len(atom_tag[1])==1: # one and only one match tag = atom_tag[1][0] prop_list = rule[1][tag] # the following expression both changes the formal charge and resets flag 23 alter_list.append([atom_tag[0], "name='''%s''';text_type='''%s''';partial_charge=%f;elec_radius=%f;flags=flags&-8388609"%prop_list]) # now evaluate all of these expressions efficiently en-masse cmd.alter_list(selection,alter_list) # see if we missed any atoms missed_count = cmd.count_atoms("("+selection+") and flag 23") if missed_count>0: if not quiet: # looks like we did, so alter the user print " WARNING: %d atoms did not have properties assigned"%missed_count result = 0 # remove the temporary selection we used to select appropriate residues cmd.delete(tmp_sele1) return result
def mkpntx(s1, s2): x = com(s1) - com(s2) if abs(x.x) > 0.1 or abs(x.y) > 0.1: print "DIE!", x return z = x.z c = Vec(0, z / 2 / math.tan(36.0 * math.pi / 180), z / 2) cmd.delete("p1") cmd.delete("p2") cmd.delete("p3") cmd.delete("p4") cmd.delete("p5") cmd.create("p1", s1) cmd.create("p2", s1) cmd.create("p3", s1) cmd.create("p4", s1) cmd.create("p5", s1) rot("p1", Vec(1, 0, 0), 0 * 72, c) rot("p2", Vec(1, 0, 0), 1 * 72, c) rot("p3", Vec(1, 0, 0), 2 * 72, c) rot("p4", Vec(1, 0, 0), 3 * 72, c) rot("p5", Vec(1, 0, 0), 4 * 72, c) cmd.color("green", "p1 and elem C") cmd.color("cyan", "p2 and elem C") cmd.color("yellow", "p3 and elem C") cmd.color("magenta", "p4 and elem C") cmd.color("orange", "p5 and elem C")
def drawtestconeva(v, a): cmd.delete("cone hyperb") # v = com(sele+" and name SG") # a = (v - com(sele+" and name CB")).normalized() # print v, a ang = 5.0 R = rotation_matrix(a, ang) perp = a.cross(randvec()).normalized() p = v + perp d = rotation_matrix(perp, 45) * a P, D = [], [] for i in range(int(360 / ang)): P.append(p) D.append(d) p = R * (p - v) + v d = R * d drawlines(P, D, "hyperb", COL=(0, 0, 1)) p = v d = rotation_matrix(a.cross(randvec()), 45) * a P, D = [], [] for i in range(360 / ang): P.append(p) D.append(d) d = R * d drawlines(P, D, "cone", COL=(1, 0, 0))
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 findSurfaceAtoms(selection="all", cutoff=2.5, quiet=1): """ DESCRIPTION Finds those atoms on the surface of a protein that have at least 'cutoff' exposed A**2 surface area. USAGE findSurfaceAtoms [ selection, [ cutoff ]] SEE ALSO findSurfaceResidues """ cutoff, quiet = float(cutoff), int(quiet) tmpObj = cmd.get_unused_name("_tmp") cmd.create(tmpObj, "(" + selection + ") and polymer", zoom=0) cmd.set("dot_solvent", 1, tmpObj) cmd.get_area(selection=tmpObj, load_b=1) # threshold on what one considers an "exposed" atom (in A**2): cmd.remove(tmpObj + " and b < " + str(cutoff)) selName = cmd.get_unused_name("exposed_atm_") cmd.select(selName, "(" + selection + ") in " + tmpObj) cmd.delete(tmpObj) if not quiet: print("Exposed atoms are selected in: " + selName) return selName
def hide_rep(tag): try: sel = glb.SELE if tag == 'Lines': cmd.hide('lines', sel) elif tag == 'Sticks': cmd.hide('sticks', sel) elif tag == 'Ribbons': cmd.hide('ribbon', sel) elif tag == 'Cartoon': cmd.hide('cartoon', sel) elif tag == 'Dots': cmd.hide('dots', sel) elif tag == 'Spheres': cmd.hide('spheres', sel) elif tag == 'Mesh': cmd.hide('mesh', sel) elif tag == 'Surface': cmd.hide('surface', sel) elif tag == 'Water': cmd.hide('(resn HOH)') elif tag == 'Everything': cmd.hide('everything', sel) elif tag == 'Ball and Stick': cmd.hide('spheres', sel) cmd.hide('sticks', sel) elif tag == 'Polar Contacts': cmd.delete(sel+"_polar_conts") except: showinfo('Error', 'Update Selection!')
def ColorByDisplacementAll(objSel1, objSel2, super1='all', super2='all', doColor="True", doAlign="True", AlignedWhite='yes'): ### First create backup copies; names starting with __ (underscores) are normally hidden by PyMOL tObj1, tObj2, aln = "__tempObj1", "__tempObj2", "__aln" if strTrue(doAlign): ### Create temp objects cmd.create(tObj1, objSel1) cmd.create(tObj2, objSel2) ### Align and make create an object aln which indicates which atoms were paired between the two structures ### Super is must faster than align http://www.pymolwiki.org/index.php/Super cmd.super(tObj1 + ' and ' + str(super1), tObj2 + ' and ' + str(super2), object=aln) ### Modify the original matrix of object1 from the alignment cmd.matrix_copy(tObj1, objSel1) else: ### Create temp objects cmd.create(tObj1, objSel1) cmd.create(tObj2, objSel2) ### Align and make create an object aln which indicates which atoms were paired between the two structures ### Super is must faster than align http://www.pymolwiki.org/index.php/Super cmd.super(tObj1 + ' and ' + str(super1), tObj2 + ' and ' + str(super2), object=aln) ### Modify the B-factor columns of the original objects, ### in order to identify the residues NOT used for alignment, later on cmd.alter(objSel1 + " or " + objSel2, "b=-0.2") cmd.alter(tObj1 + " or " + tObj2, "chain='A'") cmd.alter(tObj1 + " or " + tObj2, "segi='A'") ### Update pymol internal representations; one of these should do the trick cmd.refresh() cmd.rebuild() cmd.sort(tObj1) cmd.sort(tObj2) ### Create lists for storage stored.alnAres, stored.alnBres = [], [] ### Iterate over objects and get resi if AlignedWhite == 'yes': cmd.iterate(tObj1 + " and not " + aln, "stored.alnAres.append((resi, name))") cmd.iterate(tObj2 + " and not " + aln, "stored.alnBres.append((resi, name))") else: cmd.iterate(tObj1, "stored.alnAres.append((resi, name))") cmd.iterate(tObj2, "stored.alnBres.append((resi, name))") ### Change the B-factors for EACH object displacementUpdateBAll(tObj1, stored.alnAres, tObj2, stored.alnBres) ### Store the NEW B-factors stored.alnAnb, stored.alnBnb = [], [] ### Iterate over objects and get b if AlignedWhite == 'yes': ### Iterate over objects which is not aligned cmd.iterate(tObj1 + " and not " + aln, "stored.alnAnb.append(b)") cmd.iterate(tObj2 + " and not " + aln, "stored.alnBnb.append(b)") else: ### Or Iterate over all objects with CA cmd.iterate(tObj1, "stored.alnAnb.append(b)") cmd.iterate(tObj2, "stored.alnBnb.append(b)") ### Get rid of all intermediate objects and clean up cmd.delete(tObj1) cmd.delete(tObj2) cmd.delete(aln) ### Assign the just stored NEW B-factors to the original objects print "Sooon ready. 1 more minute" for x in range(len(stored.alnAres)): cmd.alter( objSel1 + " and resi " + str(stored.alnAres[x][0]) + " and name " + str(stored.alnAres[x][1]), "b = " + str(stored.alnAnb[x])) for x in range(len(stored.alnBres)): cmd.alter( objSel2 + " and resi " + str(stored.alnBres[x][0]) + " and name " + str(stored.alnBres[x][1]), "b = " + str(stored.alnBnb[x])) cmd.rebuild() cmd.refresh() cmd.sort(objSel1) cmd.sort(objSel2) ### Provide some useful information stored.allRMSDval = [] stored.allRMSDval = stored.alnAnb + stored.alnBnb print "\nColorByDisplacementAll completed successfully." print "The MAXIMUM Displacement is: " + str(max( stored.allRMSDval)) + " residue " + str(stored.alnAres[int( stored.allRMSDval.index(max(stored.allRMSDval)))]) if strTrue(doColor): ### Showcase what we did #cmd.orient() #cmd.hide("all") cmd.show("sticks", objSel1 + " or " + objSel2) ### Select the residues not used for alignment; they still have their B-factors as "-0.2" cmd.select("notUsedForAln", "b = -0.2") ### White-wash the residues not used for alignment cmd.color("white", "notUsedForAln") ### Select the residues not in both pdb files; they have their B-factors as "-0.01" cmd.select("ResNotInBothPDB", "b = -0.01") ### White-wash the residues not used for alignment cmd.color("black", "ResNotInBothPDB") ### Color the residues used for alignment according to their B-factors (Displacement values) #cmd.spectrum("b", 'rainbow', "((" + objSel1 + ") or (" + objSel2 +" )) and not notUsedForAln+ResNotInBothPDB") cmd.spectrum( "b", 'rainbow', "((" + objSel1 + ") or (" + objSel2 + " )) and not (notUsedForAln or ResNotInBothPDB)") ### Delete the selection of atoms not used for alignment ### If you would like to keep this selection intact, ### just comment "cmd.delete" line and ### uncomment the "cmd.disable" line abowe. cmd.disable("notUsedForAln") cmd.delete("notUsedForAln") cmd.disable("ResNotInBothPDB") cmd.delete("ResNotInBothPDB") print "\nObjects are now colored by C-alpha displacement deviation." print "Blue is minimum and red is maximum..." print "White is those residues used in the alignment algorithm. Can be turned off in top of algorithm." print "Black is residues that does not exist in both files..."
import pandas as pd from pymol import cmd import os from tqdm import tqdm pdb_path = "./pdbs" data = pd.read_csv("./csvs/less-than-256.csv") num_atoms = [] print("Loading number of atoms.") for pdb_file_name in tqdm(data.columns): cmd.delete("all") if len(pdb_file_name) != 4: pdb_file_name = pdb_file_name[1:] pdb_file_name = pdb_file_name.lower() pdb_path = "./pdbs/" + pdb_file_name + ".pdb" if not os.path.exists(pdb_path): print('fetching', pdb_file_name) cmd.fetch(pdb_file_name, path=os.path.join('.', 'pdbs'), type='pdb') else: cmd.load(pdb_path) num_atoms.append(cmd.count_atoms("all")) data = data.transpose() data['num_atoms'] = num_atoms data = data.nsmallest(data.shape[0], 'num_atoms') # use nlargest for to get the inverse data.drop("num_atoms", axis=1, inplace=True) data = data.transpose() data.to_csv('./csvs/sorted-less-than-256.csv', index=False)
return pymol_module ligands_dir = 'test/test_files/ligand_system/' ligand_files = [ '5_long_Ligands.pdb', '7_veryDifferent_Ligands.pdb', '9_similar_Ligands.pdb', '21_large_Ligands.pdb' ] #['9_similar_Ligands.pdb','7_veryDifferent_Ligands.pdb', ligands_path = [ligands_dir + lig_file for lig_file in ligand_files] cmd = start_pymol() all_results_dir = '/home/rhinerc/Desktop/ALL TEST RESULTS/all_optimizers/pca_criterion' for lig in ligands_path: cmd.delete('all') pymol_module = load_ligands(lig) print('COMPARING ' + lig) print('len(all_atoms)', len(pymol_module.logic_handler.all_atoms)) print('len(selected_atoms)', len(pymol_module.logic_handler.selected_atoms)) print('len(selected_restraints)', len(pymol_module.logic_handler.selected_restraints)) start_time = time.time() #Note; Changed criterion from convex_hull back to pca unscaled on Fr 24.05 Optimizer.compare_pair_optimizers(criterion=Optimizer._calculate_value_unscaled_pca_2d, \ atoms=pymol_module.logic_handler.all_atoms, \ opt_types=[Optimizer.TreeHeuristicOptimizer, Optimizer.TreeHeuristicOptimizer, Optimizer.TreeHeuristicOptimizer, Optimizer.TreeHeuristicOptimizer,Optimizer.BestMoleculeRingOptimizer,Optimizer.BruteForceRingOptimzer,
def color_by_mutation(obj1, obj2, waters=0, labels=0): ''' DESCRIPTION Creates an alignment of two proteins and superimposes them. Aligned residues that are different in the two (i.e. mutations) are highlighted and colored according to their difference in the BLOSUM90 matrix. Is meant to be used for similar proteins, e.g. close homologs or point mutants, to visualize their differences. USAGE color_by_mutation selection1, selection2 [,waters [,labels ]] ARGUMENTS obj1: object or selection obj2: object or selection waters: bool (0 or 1). If 1, waters are included in the view, colored differently for the both input structures. default = 0 labels: bool (0 or 1). If 1, the possibly mutated sidechains are labeled by their chain, name and id default = 0 EXAMPLE color_by_mutation protein1, protein2 SEE ALSO super ''' from pymol import stored, CmdException if cmd.count_atoms(obj1) == 0: print('%s is empty' % obj1) return if cmd.count_atoms(obj2) == 0: print('%s is empty' % obj2) return waters = int(waters) labels = int(labels) # align the two proteins aln = '__aln' # first, an alignment with 0 cycles (no atoms are rejected, which maximized the number of aligned residues) # for some mutations in the same protein this works fine). This is essentially done to get a # sequence alignment cmd.super(obj1, obj2, object=aln, cycles=0) # superimpose the the object using the default parameters to get a slightly better superimposition, # i.e. get the best structural alignment cmd.super(obj1, obj2) stored.resn1, stored.resn2 = [], [] stored.resi1, stored.resi2 = [], [] stored.chain1, stored.chain2 = [], [] # store residue ids, residue names and chains of aligned residues cmd.iterate(obj1 + ' and name CA and ' + aln, 'stored.resn1.append(resn)') cmd.iterate(obj2 + ' and name CA and ' + aln, 'stored.resn2.append(resn)') cmd.iterate(obj1 + ' and name CA and ' + aln, 'stored.resi1.append(resi)') cmd.iterate(obj2 + ' and name CA and ' + aln, 'stored.resi2.append(resi)') cmd.iterate(obj1 + ' and name CA and ' + aln, 'stored.chain1.append(chain)') cmd.iterate(obj2 + ' and name CA and ' + aln, 'stored.chain2.append(chain)') mutant_selection = '' non_mutant_selection = 'none or ' colors = [] # loop over the aligned residues for n1, n2, i1, i2, c1, c2 in zip(stored.resn1, stored.resn2, stored.resi1, stored.resi2, stored.chain1, stored.chain2): # take care of 'empty' chain names if c1 == '': c1 = '""' if c2 == '': c2 = '""' if n1 == n2: non_mutant_selection += '((%s and resi %s and chain %s) or (%s and resi %s and chain %s)) or ' % ( obj1, i1, c1, obj2, i2, c2) else: mutant_selection += '((%s and resi %s and chain %s) or (%s and resi %s and chain %s)) or ' % ( obj1, i1, c1, obj2, i2, c2) # get the similarity (according to the blosum matrix) of the two residues and c = getBlosum90ColorName(n1, n2) colors.append( (c, '%s and resi %s and chain %s and elem C' % (obj2, i2, c2))) if mutant_selection == '': raise CmdException('No mutations found') # create selections cmd.select('mutations', mutant_selection[:-4]) cmd.select('non_mutations', non_mutant_selection[:-4]) cmd.select( 'not_aligned', '(%s or %s) and not mutations and not non_mutations' % (obj1, obj2)) # create the view and coloring cmd.hide('everything', '%s or %s' % (obj1, obj2)) cmd.show('cartoon', '%s or %s' % (obj1, obj2)) cmd.show( 'lines', '(%s or %s) and ((non_mutations or not_aligned) and not name c+o+n)' % (obj1, obj2)) cmd.show('sticks', '(%s or %s) and mutations and not name c+o+n' % (obj1, obj2)) cmd.color('gray', 'elem C and not_aligned') cmd.color('white', 'elem C and non_mutations') cmd.color('blue', 'elem C and mutations and %s' % obj1) for (col, sel) in colors: cmd.color(col, sel) cmd.hide('everything', '(hydro) and (%s or %s)' % (obj1, obj2)) cmd.center('%s or %s' % (obj1, obj2)) if labels: cmd.label('mutations and name CA', '"(%s-%s-%s)"%(chain, resi, resn)') if waters: cmd.set('sphere_scale', '0.1') cmd.show('spheres', 'resn HOH and (%s or %s)' % (obj1, obj2)) cmd.color('red', 'resn HOH and %s' % obj1) cmd.color('salmon', 'resn HOH and %s' % obj2) print(''' Mutations are highlighted in blue and red. All mutated sidechains of %s are colored blue, the corresponding ones from %s are colored on a spectrum from blue to red according to how similar the two amino acids are (as measured by the BLOSUM90 substitution matrix). Aligned regions without mutations are colored white. Regions not used for the alignment are gray. NOTE: There could be mutations in the gray regions that were not detected.''' % (obj1, obj2)) cmd.delete(aln) cmd.deselect()
"ligand", "polar_atoms", mode=2) print("Polar contact: ") print polar_distance, halo.name, halo.resn, halo.resi model_polar = cmd.get_model("current_polar") for pol in model_polar.atom: cmd.select("current_polar", "id %s" % (pol.id)) # check for halogen bonds, distances 5.0, angles: > 140 current_distance = cmd.distance("current_distance", "current_halogen", "current_polar") current_angle = cmd.angle("current_angle", "current_neighbor", "current_halogen", "current_polar") if (current_angle >= 140) and (current_distance <= 5.0): print("Halogen bond: ") print current_distance, current_angle, pol.name, pol.resn, pol.resi cmd.delete("current_angle") cmd.delete("current_distance") # visualizations cmd.hide("lines") cmd.hide( "nonbonded") # hide all nonbonded atoms, i.e. oxygen of water or ions cmd.show("sticks", "ligand") cmd.show("lines", "bindingsite") cmd.show("nb_spheres", "water_bs") # nb_spheres = non bonded spheres cmd.color("skyblue", "water_bs") cmd.zoom("ligand", 5) # high numbers = far away
def deleteArrows(self): for arrow in cmd.get_names_of_type("object:cgo"): if "rrow" in arrow: cmd.delete(arrow)
def showInteractions(self): if not "filtered" in self.logData: return currentSel = self.tree_data.focus() if currentSel == "" : return rowId = self.tree_data.item(currentSel)["values"][0] data = self.logData["filtered"].iloc[[rowId]] pdbCode = data["PDB Code"].values[0] if self.currentMolecule["PdbCode"] and self.currentMolecule["PdbCode"] != pdbCode: cmd.delete(self.currentMolecule["PdbCode"]) actual_objects = cmd.get_object_list() for obj in actual_objects: if obj.upper() != pdbCode.upper(): cmd.delete(obj) if self.currentMolecule["PdbCode"] != pdbCode: if self.logData["cifDir"] != None: potentialPaths = [ path.join( self.logData["cifDir"] , pdbCode.lower() +".cif" ), path.join( self.logData["cifDir"] , pdbCode.upper() +".cif" ) ] cifFound = False for filePath in potentialPaths: if path.isfile(filePath): cmd.load(filePath) cifFound = True break if not cifFound: cmd.fetch(pdbCode) else: cmd.fetch(pdbCode) frame = int(data["Model No"].values[0]) if frame != 0: cmd.frame(frame+1) selection = self.getSelection(data) selectionName = "suprSelection" cmd.select(selectionName, selection) cmd.show( "sticks" , selectionName ) cmd.center(selectionName) cmd.zoom(selectionName) if self.chkvar_around.get() > 0: selectionAroundName = "suprAround" radius = self.ent_around.get() try: radius = float(radius) except: return cmd.select( selectionAroundName, "byres ( suprSelection around "+str(radius)+" ) " ) cmd.select( selectionAroundName, "byres ( suprSelection around 5 ) " ) cmd.show("lines", selectionAroundName) self.logData["displayingAround"] = True else: self.logData["displayingAround"] = False self.deleteArrows() arrowBegin, arrowEnd = self.getArrow(data) cgo_arrow(arrowBegin, arrowEnd, 0.1, name = self.arrowName, color = self.arrowColor) self.logData["displaying"] = True self.currentMolecule["PdbCode"] = pdbCode cmd.deselect() self.actualDisplaying["rowData"] = data self.actualDisplaying["selectionTime"] = time()
def Btn_CreatePartition(self): DestFile = '' Output = self.Step3Output.get() if General.validate_String(Output, '', False, False, True): self.DisplayMessage( " ERROR: Could not save the partition file because you entered an invalid name.", 2) return auto_zoom = cmd.get("auto_zoom") if Output != '': if not self.Vertex: self.top.DisplayMessage( " ERROR: Cannot save an empty cleft. Add spheres that include volume of the parent.", 1) return if General_cmd.object_Exists(Output): answer = tkMessageBox.askquestion( "Question", message= "An object with that name already exists. Would you like to overwrite it?", icon='warning') if str(answer) == 'no': return try: cmd.set("auto_zoom", 0) DestFile = os.path.join(self.top.GetCleftTempProject_Dir, Output + '.pdb') self.top.Manage.copy_TempPartition(self.TempPartition, DestFile) cmd.load(DestFile, Output, state=1) cmd.refresh() cmd.hide('everything', Output) cmd.refresh() cmd.show('surface', Output) cmd.refresh() partition_rgb = self.top.Default.SetPartitionColor( self.Cleft.CleftName) if len(partition_rgb): cmd.color('partition', Output) cmd.refresh() cmd.delete(self.PartitionDisplay) cmd.refresh() Cleft = CleftObj.CleftObj() Cleft.CleftFile = DestFile Cleft.CleftName = self.Step3Output.get() Cleft.PartitionParent = self.Cleft Cleft.Partition = True Cleft.UTarget = self.Cleft.UTarget Cleft.Set_CleftMD5() Cleft.Color = General.rgb_to_hex(partition_rgb) self.top.Default.TempBindingSite.Add_Cleft(Cleft) self.top.CopySession = False # Put the partition cleft over its parent General_cmd.Oscillate(self.Cleft.CleftName, 0.0) self.Reset_Step1() else: self.top.DisplayMessage( " ERROR: Cleft '" + self.Cleft.CleftName + "' could not be found to set partition color", 1) except: self.top.DisplayMessage( " ERROR: Could not create partition object: File not found.", 1) else: self.top.DisplayMessage( " ERROR: Could not create partition object: Output is null.", 1) cmd.set("auto_zoom", auto_zoom)
def draw_ligand(pdbmat2, pdb2, gcen2, iconf): #============================= ibeg = iconf * pdb2.natom ifin = ibeg + pdb2.natom ltype = LINES ligand_obj = pymol_cgo_new(ltype) # print('drawing conf: ',iconf,ibeg,ifin,pdb2.natom) # vbeg = [0., 0., 0.] vend = [0., 0., 0.] cbeg = .5 cend = .9 # # extract rot mat rmt2 = [[pdbmat2[0], pdbmat2[1], pdbmat2[2]], [pdbmat2[4], pdbmat2[5], pdbmat2[6]], [pdbmat2[8], pdbmat2[9], pdbmat2[10]]] # # extract trans trn2 = [pdbmat2[3], pdbmat2[7], pdbmat2[11]] # # find rotated origin in molc. local coords gcen2_rot = rot_vec(rmt2, gcen2) # # displacement of origin subtracted from apparant trans to get actual trans for k in range(3): trn2[k] = trn2[k] - (gcen2[k] - gcen2_rot[k]) # # extract and transform coords from required model xyz = [0., 0., 0.] crd2 = [] for i in range(ibeg, ifin): # apply rotations and translations for k in range(3): xyz[k] = pdb2.coords[i][k] for k in range(3): xyz[k] = pdb2.coords[i][k] - gcen2[k] xyz2 = rot_vec(rmt2, xyz) for k in range(3): xyz[k] = xyz2[k] + gcen2[k] + trn2[k] crd2.append([xyz[0], xyz[1], xyz[2]]) # # generate bonds nbond = 0 margin = 1.4 for i in range(pdb2.natom): if (pdb2.name[i][2:3] == 'H'): radi = 1.1 else: radi = pdb2.radius[i] for j in range(i + 1, pdb2.natom): # print 'checking: ',i,j dist2 = 0. if (pdb2.name[j][2:3] == 'H'): radj = 1.1 else: radj = pdb2.radius[j] for k in range(3): dist2 += (crd2[i][k] - crd2[j][k])**2 dist = math.sqrt(dist2) overlap = dist + margin - radi - radj if (overlap < 0.): nbond += 1 for k in range(3): vbeg[k] = crd2[i][k] vend[k] = crd2[j][k] if (pdb2.bfact[i] > 0.1): cbeg = 0.1 elif (pdb2.bfact[i] < -0.1): cbeg = 0.9 else: cbeg = 2. if (pdb2.bfact[j] > 0.1): cend = 0.1 elif (pdb2.bfact[j] < -0.1): cend = 0.9 else: cend = 2. pymol_cgo_addline(ligand_obj, vbeg, vend, cbeg, cend) # print "number of bonds: ",nbond pymol_cgo_end(ligand_obj) cmd.delete('ligand_obj') cmd.load_cgo(ligand_obj, 'ligand_obj')
def show_contacts(selection, selection2, result="contacts", cutoff=3.6, bigcutoff=4.0, SC_DEBUG=DEBUG): """ USAGE show_contacts selection, selection2, [result=contacts],[cutoff=3.6],[bigcutoff=4.0] Show various polar contacts, the good, the bad, and the ugly. Edit MPB 6-26-14: The distances are heavy atom distances, so I upped the default cutoff to 4.0 Returns: True/False - if False, something went wrong """ if SC_DEBUG > 4: print('Starting show_contacts') print('selection = "' + selection + '"') print('selection2 = "' + selection2 + '"') result = cmd.get_legal_name(result) #if the group of contacts already exist, delete them cmd.delete(result) # ensure only N and O atoms are in the selection all_don_acc1 = selection + " and (donor or acceptor)" all_don_acc2 = selection2 + " and (donor or acceptor)" if SC_DEBUG > 4: print('all_don_acc1 = "' + all_don_acc1 + '"') print('all_don_acc2 = "' + all_don_acc2 + '"') #if theses selections turn out not to have any atoms in them, pymol throws cryptic errors when calling the dist function like: #'Selector-Error: Invalid selection name' #So for each one, manually perform the selection and then pass the reference to the distance command and at the end, clean up the selections #the return values are the count of the number of atoms all1_sele_count = cmd.select('all_don_acc1_sele', all_don_acc1) all2_sele_count = cmd.select('all_don_acc2_sele', all_don_acc2) #print out some warnings if DEBUG > 3: if not all1_sele_count: print('Warning: all_don_acc1 selection empty!') if not all2_sele_count: print('Warning: all_don_acc2 selection empty!') ######################################## allres = result + "_all" if all1_sele_count and all2_sele_count: cmd.distance(allres, 'all_don_acc1_sele', 'all_don_acc2_sele', bigcutoff, mode=0) cmd.set("dash_radius", "0.05", allres) cmd.set("dash_color", "purple", allres) cmd.hide("labels", allres) ######################################## #compute good polar interactions according to pymol polres = result + "_polar" if all1_sele_count and all2_sele_count: cmd.distance(polres, 'all_don_acc1_sele', 'all_don_acc2_sele', cutoff, mode=2) #hopefully this checks angles? Yes cmd.set("dash_radius", "0.126", polres) ######################################## #When running distance in mode=2, the cutoff parameter is ignored if set higher then the default of 3.6 #so set it to the passed in cutoff and change it back when you are done. old_h_bond_cutoff_center = cmd.get( 'h_bond_cutoff_center') # ideal geometry old_h_bond_cutoff_edge = cmd.get( 'h_bond_cutoff_edge') # minimally acceptable geometry cmd.set('h_bond_cutoff_center', bigcutoff) cmd.set('h_bond_cutoff_edge', bigcutoff) #compute possibly suboptimal polar interactions using the user specified distance pol_ok_res = result + "_polar_ok" if all1_sele_count and all2_sele_count: cmd.distance(pol_ok_res, 'all_don_acc1_sele', 'all_don_acc2_sele', bigcutoff, mode=2) cmd.set("dash_radius", "0.06", pol_ok_res) #now reset the h_bond cutoffs cmd.set('h_bond_cutoff_center', old_h_bond_cutoff_center) cmd.set('h_bond_cutoff_edge', old_h_bond_cutoff_edge) ######################################## onlyacceptors1 = selection + " and (acceptor and !donor)" onlyacceptors2 = selection2 + " and (acceptor and !donor)" onlydonors1 = selection + " and (!acceptor and donor)" onlydonors2 = selection2 + " and (!acceptor and donor)" #perform the selections onlyacceptors1_sele_count = cmd.select('onlyacceptors1_sele', onlyacceptors1) onlyacceptors2_sele_count = cmd.select('onlyacceptors2_sele', onlyacceptors2) onlydonors1_sele_count = cmd.select('onlydonors1_sele', onlydonors1) onlydonors2_sele_count = cmd.select('onlydonors2_sele', onlydonors2) #print out some warnings if SC_DEBUG > 2: if not onlyacceptors1_sele_count: print('Warning: onlyacceptors1 selection empty!') if not onlyacceptors2_sele_count: print('Warning: onlyacceptors2 selection empty!') if not onlydonors1_sele_count: print('Warning: onlydonors1 selection empty!') if not onlydonors2_sele_count: print('Warning: onlydonors2 selection empty!') accres = result + "_aa" if onlyacceptors1_sele_count and onlyacceptors2_sele_count: aa_dist_out = cmd.distance(accres, 'onlyacceptors1_sele', 'onlyacceptors2_sele', cutoff, 0) if aa_dist_out < 0: print( '\n\nCaught a pymol selection error in acceptor-acceptor selection of show_contacts' ) print('accres:', accres) print('onlyacceptors1', onlyacceptors1) print('onlyacceptors2', onlyacceptors2) return False cmd.set("dash_color", "red", accres) cmd.set("dash_radius", "0.125", accres) ######################################## donres = result + "_dd" if onlydonors1_sele_count and onlydonors2_sele_count: dd_dist_out = cmd.distance(donres, 'onlydonors1_sele', 'onlydonors2_sele', cutoff, 0) #try to catch the error state if dd_dist_out < 0: print( '\n\nCaught a pymol selection error in dd selection of show_contacts' ) print('donres:', donres) print('onlydonors1', onlydonors1) print('onlydonors2', onlydonors2) print("cmd.distance('" + donres + "', '" + onlydonors1 + "', '" + onlydonors2 + "', " + str(cutoff) + ", 0)") return False cmd.set("dash_color", "red", donres) cmd.set("dash_radius", "0.125", donres) ########################################################## ##### find the buried unpaired atoms of the receptor ##### ########################################################## #initialize the variable for when CALC_SASA is False unpaired_atoms = '' ## Group cmd.group( result, "%s %s %s %s %s %s" % (polres, allres, accres, donres, pol_ok_res, unpaired_atoms)) ## Clean up the selection objects #if the show_contacts debug level is high enough, don't delete them. if SC_DEBUG < 5: cmd.delete('all_don_acc1_sele') cmd.delete('all_don_acc2_sele') cmd.delete('onlyacceptors1_sele') cmd.delete('onlyacceptors2_sele') cmd.delete('onlydonors1_sele') cmd.delete('onlydonors2_sele') return True
def __call__(self): # 1st check for a dockeye action flag de_action = 'none' mark_number = 0 do_mm = True try: actionfile = open('dockeye_action', 'r') line = actionfile.readline() fields = line.split() de_action = fields[0] mark_number = int(fields[1]) actionfile.close() os.system('/bin/rm -f dockeye_action') #print(de_action,mark_number) except: # de_action = 'none' mark_number = 0 # get view on screen my_view = cmd.get_view() delta_mv = 0. for i in range(18): delta_mv = max(delta_mv, abs(my_view[i] - self.my_view[i])) self.my_view[i] = my_view[i] #print my_view # get orientation/position matrices for two molecules # how does pymol define rotation center of molecule? # apparnetly by geometric average pdbmat1 = cmd.get_object_matrix(self.pdbobj1) pdbmat2 = cmd.get_object_matrix(self.pdbobj2) # if (de_action == 'mark'): # write bookmark print('bookmarking... ', mark_number) et = self.energy[0] ee = self.energy[1] ev = self.energy[2] print('current energies: %12.5g %12.5g %12.5g model %4d \n' % (ee, ev, et, self.nbest[0])) #mark_prt = 'dockeye_prt_mark_%d.pdb' % (mark_number) mark_lig = 'dockeye_lig_mark_%d.pdb' % (mark_number) ligfile = open(mark_lig, 'w') ligfile.write('REMARK pdbfile 1: ' + self.pdbfile1 + '\n') ligfile.write('REMARK pdbfile 2: ' + self.pdbfile2 + '\n') ligfile.write('REMARK # of atoms 1: %6d 2: %6d\n' % (self.pdb1.natom, self.pdb2.natom)) ligfile.write('REMARK geometric centers: \n') ligfile.write('REMARK 1: %8.3f %8.3f %8.3f \n' % (self.gcen1[0], self.gcen1[1], self.gcen1[2])) ligfile.write('REMARK 2: %8.3f %8.3f %8.3f \n' % (self.gcen2[0], self.gcen2[1], self.gcen2[2])) ligfile.write('REMARK net charge 1: %8.3f 2: %8.3f \n' % (self.qtot1, self.qtot2)) ligfile.write( 'REMARK energy parameters dielectric: blank VDW depth: blank\n' ) ligfile.write('REMARK # of ligand conformers: %6d\n' % (self.pdb2.nmodel)) ligfile.write( 'REMARK current energies: %12.5g %12.5g %12.5g model %4d \n' % (ee, ev, et, self.nbest[0])) for i in range(4): for j in range(4): indx = j + 4 * i ligfile.write('REMARK %12.5f ' % (pdbmat1[indx])) ligfile.write('\n') for i in range(4): for j in range(4): indx = j + 4 * i ligfile.write('REMARK %12.5f ' % (pdbmat2[indx])) ligfile.write('\n') # # extract rot rmtp = [[pdbmat1[0], pdbmat1[1], pdbmat1[2]], [pdbmat1[4], pdbmat1[5], pdbmat1[6]], [pdbmat1[8], pdbmat1[9], pdbmat1[10]]] rmtl = [[pdbmat2[0], pdbmat2[1], pdbmat2[2]], [pdbmat2[4], pdbmat2[5], pdbmat2[6]], [pdbmat2[8], pdbmat2[9], pdbmat2[10]]] # # extract trans trnp = [pdbmat1[3], pdbmat1[7], pdbmat1[11]] trnl = [pdbmat2[3], pdbmat2[7], pdbmat2[11]] # # apply transrot to coords # write out transrot to temporary pdb files gcenp_rot = rot_vec(rmtp, self.gcen1) gcenl_rot = rot_vec(rmtl, self.gcen2) for k in range(3): trnp[k] = trnp[k] - (self.gcen1[k] - gcenp_rot[k]) trnl[k] = trnl[k] - (self.gcen2[k] - gcenl_rot[k]) i1 = 0 #print(rmtp,trnp) #print(rmtl,trnl) xyz = [0., 0., 0.] tmpfile = 'dockeye_lig_tmp.pdb' for n in range(self.pdb2.nmodel): ligfile.write('MODEL%4d \n' % (n + 1)) for i in range(self.pdb2.natom): # # apply rotations and translations # and inverse of protein rot/trans to ligand # in case user moved protein too- now ligand should be in # coord frame of original protein pdb for k in range(3): xyz[k] = self.pdb2.coords[i1][k] - self.gcen2[k] xyz1 = rot_vec(rmtl, xyz) for k in range(3): xyz[k] = xyz1[k] + self.gcen2[k] + trnl[ k] - self.gcen1[k] - trnp[k] xyz2 = rot_vec(rmtp, xyz, inv=1) for k in range(3): xyz[k] = xyz2[k] + self.gcen1[k] string = 'ATOM %6d%6s%4s%1s%4s %8.3f%8.3f%8.3f%6.2f%7.3f \n' \ % (i,self.pdb2.name[i],self.pdb2.res[i], \ self.pdb2.chain[i], self.pdb2.resnum[i], xyz[0],xyz[1],xyz[2], \ self.pdb2.radius[i],self.pdb2.bfact[i]) ligfile.write(string) i1 += 1 ligfile.write('ENDMDL\n') ligfile.close() mark_pml = 'dockeye_mark_%d.pml' % (mark_number) pmlfile = open(mark_pml, 'w') pmlfile.write( '#------------------------------------------------\n') pmlfile.write('run $HOME/source/dockeye_multi/src/dockeyeM_c.py\n') pmlfile.write('de("%s","%s")\n' % (self.pdbfile1, mark_lig)) pmlfile.write('#optional view settings\n') pmlfile.write('hide lines\n') pmlfile.write('spectrum b, red_white_blue\n') pmlfile.write('show sticks, dockeye_lig\n') pmlfile.write('show surface, dockeye_prt\n') pmlfile.write('set transparency, 0.4\n') pmlfile.write( '#------------------------------------------------\n') pmlfile.close() # done with bookmarking # # check for new view or pose # delta_mm = 0. for i in range(12): delta_mm = max(delta_mm, abs(pdbmat1[i] - self.objmat1[i])) delta_mm = max(delta_mm, abs(pdbmat2[i] - self.objmat2[i])) self.objmat1[i] = pdbmat1[i] self.objmat2[i] = pdbmat2[i] if (delta_mm > 0.01): # we only do expensive energy calc if pose changed do_mm = True else: do_mm = False if ((delta_mv > 0.01) or do_mm): # we only update if pose or view changed cgo_obj = pdb_interaction(pdbmat1, pdbmat2, self.pdb1, self.pdb2, self.gcen1, self.gcen2, self.energy, do_mm, self.logscale, self.dielectric, self.eps, self.nbest, self.energy_min) if (self.nbest[0] != self.nbest[1]): # print('Switching models ',self.nbest) self.nbest[1] = self.nbest[0] # # write new best pose to logfile # et = self.energy[0] ee = self.energy[1] ev = self.energy[2] if (self.energy[0] < self.energy_min): print( ' NEW MIN ee: %12.3g ev: %12.3g et: %12.3g model %4d ' % (ee, ev, et, self.nbest[0])) self.energy_min = et self.dockeye_log.write( 'new min: %12.5g %12.5g %12.5g model %4d \n' % (ee, ev, et, self.nbest[0])) for i in range(4): for j in range(4): indx = j + 4 * i self.dockeye_log.write('%12.5f ' % (pdbmat1[indx])) self.dockeye_log.write('\n') for i in range(4): for j in range(4): indx = j + 4 * i self.dockeye_log.write('%12.5f ' % (pdbmat2[indx])) self.dockeye_log.write('\n') #else: # if(do_mm): # #print('Current energy: ee: %12.3g ev: %12.3g et: %12.3g' % (ee,ev,et)) # continue if (do_mm): cmd.delete('dockeye_obj') cmd.load_cgo(cgo_obj, 'dockeye_obj') draw_ligand(pdbmat2, self.pdb2, self.gcen2, self.nbest[0])
os.rename(path_to_file, output_path) # .ent -> .pdb # see https://github.com/dsw7/BridgingInteractions/tree/master/scalene-triangle/pymol-get-surface-example cmd.load(output_path) cmd.create( tmpObj, "({} and polymer and chain {}) and not resn HOH".format(CODE, CHAIN)) cmd.set("dot_solvent") cmd.get_area(selection=tmpObj, load_b=1) cmd.remove(tmpObj + " and b < " + str(SOLVENT_EXPOSED_CUTOFF)) cmd.show(selection=tmpObj, representation="dots") # show the exposed atoms stored.tmp_dict = {} cmd.iterate_state(state=-1, selection=tmpObj, expression=ITER_STATE_EXP) exposed = stored.tmp_dict.keys() exposed.sort() cmd.delete(tmpObj) cmd.delete('all') os.rename( output_path, path_to_file) # .pdb -> .ent such that file_pdb.clear() can del dir # compute closest surface coordinate if protein ends up having both bridge and metal # -------------------------------------------------------------------------- try: # must put this in a try / catch block as SOME R3 coords are float dtype but # still string crashed: 2m48 for example, -27.595-106.521-108.313 for _, value in dict_bridges.iteritems(): for m in metals: # need to convert to float dtype before passing into get_closest() array_b_coord = array(value[1][6:9]).astype(float) # bridge SD
def draw(prot_name, seqfile, pdbfile, cfile, factor): seq = read_fasta(open(seqfile, 'r')).values()[0][0] seqlen = len(seq) contacts = parse_contacts(open(cfile, 'r')) cmd.load(pdbfile, prot_name) cmd.set('dash_gap', 0.0) cmd.set('dash_radius', 0.1) cmd.bg_color('white') cmd.hide('everything') cmd.show('cartoon') cmd.color('gray', prot_name) """ view = (\ -0.271442711, -0.905138493, 0.327085078,\ 0.034359235, -0.348747194, -0.936563492,\ 0.961805284, -0.242983535, 0.125761271,\ 0.000000000, 0.000000000, -128.858474731,\ 17.616867065, -0.161788940, -4.633638382,\ 103.167495728, 154.549499512, -20.000000000 ) #PconsFold paper: -0.087676540, -0.441159278, -0.893107057,\ 0.482956320, 0.765313327, -0.425448418,\ 0.871214509, -0.468636513, 0.145965248,\ -0.000171857, 0.001094781, -158.355941772,\ 23.238109589, -7.513275623, 6.870838165,\ 131.660964966, 185.186004639, -20.000000000 ) cmd.set_view(view) """ count = 0 maxdist = 20.0 for contact in contacts: if count > seqlen * factor: break if seq[contact[1]-1] == 'G': atm1a = '/%s//A/%s/CA' % (prot_name, contact[1]) atm1b = atm1a else: atm1a = '/%s//A/%s/CA' % (prot_name, contact[1]) atm1b = '/%s//A/%s/CB' % (prot_name, contact[1]) if seq[contact[2]-1] == 'G': atm2a = '/%s//A/%s/CA' % (prot_name, contact[2]) atm2b = atm2a else: atm2a = '/%s//A/%s/CA' % (prot_name, contact[2]) atm2b = '/%s//A/%s/CB' % (prot_name, contact[2]) cmd.select('a', atm1a) cmd.select('b', atm2a) d_name = 'd' + str(count) dist = cmd.distance(d_name, atm1a, atm2a) if dist == -1: ## atom pair not in structure (xtal vs. seqres) continue cmd.hide('labels', d_name) col_name = 'own_color' + str(count) score = contact[0] dist = cmd.distance(d_name + 'b', atm1b, atm2b) cmd.delete(d_name + 'b') #if score > 0.5: print '%s: %f => %f' % (d_name, dist, dist/(maxdist/2)) if dist < maxdist/2: #cmd.hide('labels', d_name) #cmd.set_color(col_name, [0.0 + score, 1.0 - score, 0.0]) cmd.set_color(col_name, [0.0 + (dist/(maxdist/2)-0.4), 1.0, 0.0]) cmd.color(col_name, d_name) #cmd.color("forest", d_name) #elif dist < 10: #cmd.color("tv_orange", d_name) elif dist > maxdist/2 and dist < maxdist: #cmd.set_color(col_name, [0.0, 0.1 + score,1.0 - score]) cmd.set_color(col_name, [1.0, 1.0 - (dist/(maxdist/2)-1), 0.0]) cmd.color(col_name, d_name) else: cmd.color("red", d_name) count = count +1 cmd.set('ray_shadows', 0) cmd.set('antialias', 1) cmd.ray(1635,1038) cmd.png(prot_name + '.png')
def pnl_make(rmt1, rmt2, gcen1, gcen2, trn1, trn2, energy, emin): """ refresh and display panel with energy bars and orientations 2 sept 2019, move energy bars up for more room for -ve energies and dynamically rescale to keep bars in window """ my_view = cmd.get_view() mod_center = [my_view[12], my_view[13], my_view[14]] rmtView = [[my_view[0], my_view[3], my_view[6]], [my_view[1], my_view[4], my_view[7]], [my_view[2], my_view[5], my_view[8]]] cam_center = [my_view[9], my_view[10], my_view[11]] d_front = my_view[15] d_back = my_view[16] scale = d_back - d_front xsize = abs(cam_center[2]) / 22. xmove = 3.0 ymove = 3.0 if (emin < -4.): bscale = abs(emin) // 4 else: bscale = 1 # # create pnl objects # # # energy bars # +ve energies on log scale, -ve on linear scale now # ltype = TRIANGLES bar_obj = pymol_cgo_new(ltype) dy = -0.2 #ecut = 0.5 ecut = 0.2 et = energy[0] ee = energy[1] ev = energy[2] if (et < -ecut): et_color = 0. # blue #et_size = -1.*xsize # log scale #et_size = (0.1 -1.*math.log10(-et/ecut))*xsize*2. # linear scale et_size = 0.5 * et * xsize / bscale elif (et > ecut): et_color = 1. # red #et_size = 1.*xsize et_size = (0.1 + 1. * math.log10(et / ecut)) * xsize * 2. else: et_color = 2. # white et_size = 0.1 * xsize et_size_min = 0.5 * emin * xsize / bscale # if (ee < -ecut): ee_color = 0. # blue #ee_size = -1.*xsize #ee_size = (0.1 -1.*math.log10(-ee/ecut))*xsize*2. # linear scale ee_size = 0.5 * ee * xsize / bscale elif (ee > ecut): ee_color = 1. # red #ee_size = 1.*xsize ee_size = (0.1 + 1. * math.log10(ee / ecut)) * xsize * 2. else: ee_color = 2. # white ee_size = 0.1 * xsize # if (ev < -ecut): ev_color = 0. # blue #ev_size = -1.*xsize #ev_size = (0.1 -1.*math.log10(-ev/ecut))*xsize*2. # linear scale ev_size = 0.5 * ev * xsize / bscale elif (ev > ecut): ev_color = 1. # red #ev_size = 1.*xsize ev_size = (0.1 + 1. * math.log10(ev / ecut)) * xsize * 2. else: ev_color = 2. # white ev_size = 0.1 * xsize # # at left, vertical bars # dx = -0.2 # bar separation #----------------- # E total #----------------- dend = [0.85 * dx * xsize, 0., 0.] dend_rot = rot_vec(rmtView, dend, inv=1) nm = [0., 0., 1.] nm_rot = rot_vec(rmtView, nm, inv=1) end1 = [0., 0., 0.] beg1 = [0., 0., 0.] end2 = [0., 0., 0.] # et_beg = [0., 0., 0.] et_end = [0., et_size, 0.] et_end_min = [0., et_size_min, 0.] et_end_rot = rot_vec(rmtView, et_end, inv=1) et_end_min_rot = rot_vec(rmtView, et_end_min, inv=1) #et_offset = [-1.3*xmove*xsize,0.,0.] et_offset = [-1.3 * xmove * xsize, +1.0 * ymove * xsize, 0.] et_offset_rot = rot_vec(rmtView, et_offset, inv=1) for k in range(3): et_beg[k] = et_offset_rot[k] + mod_center[k] et_end_rot[k] += et_offset_rot[k] + mod_center[k] et_end_min_rot[k] += et_offset_rot[k] + mod_center[k] end1[k] = et_end_rot[k] - dend_rot[k] beg1[k] = et_beg[k] - dend_rot[k] color = [2., et_color, et_color] pymol_cgo_addtri(bar_obj, et_beg, et_end_rot, end1, color, nm_rot) color = [2., 2., et_color] pymol_cgo_addtri(bar_obj, et_beg, beg1, end1, color, nm_rot) # # low energy mark # for k in range(3): color[k] = 0.5 end1[k] = et_end_min_rot[k] - dend_rot[k] beg1[k] = et_end_min_rot[k] beg1[1] = beg1[1] + 0.2 pymol_cgo_addtri(bar_obj, beg1, et_end_min_rot, end1, color, nm_rot) end2[0] = end1[0] end2[1] = end1[1] + 0.2 end2[2] = end1[2] pymol_cgo_addtri(bar_obj, beg1, end2, end1, color, nm_rot) #----------------- # E electrostatic #----------------- ee_beg = [0., 0., 0.] ee_end = [0., ee_size, 0.] ee_end_rot = rot_vec(rmtView, ee_end, inv=1) #ee_offset = [(-1.3*xmove+2.*dx)*xsize,0.,0.] ee_offset = [(-1.3 * xmove + 2. * dx) * xsize, +1.0 * ymove * xsize, 0.] ee_offset_rot = rot_vec(rmtView, ee_offset, inv=1) for k in range(3): ee_beg[k] = ee_offset_rot[k] + mod_center[k] ee_end_rot[k] += ee_offset_rot[k] + mod_center[k] end1[k] = ee_end_rot[k] - dend_rot[k] beg1[k] = ee_beg[k] - dend_rot[k] color = [2., ee_color, ee_color] pymol_cgo_addtri(bar_obj, ee_beg, ee_end_rot, end1, color, nm_rot) color = [2., 2., ee_color] pymol_cgo_addtri(bar_obj, ee_beg, beg1, end1, color, nm_rot) #----------------- # E vdw #----------------- ev_beg = [0., 0., 0.] ev_end = [0., ev_size, 0.] # apply view angle ev_end_rot = rot_vec(rmtView, ev_end, inv=1) #ev_offset = [(-1.3*xmove+dx)*xsize,0.,0.] ev_offset = [(-1.3 * xmove + dx) * xsize, +1.0 * ymove * xsize, 0.] ev_offset_rot = rot_vec(rmtView, ev_offset, inv=1) for k in range(3): ev_beg[k] = ev_offset_rot[k] + mod_center[k] ev_end_rot[k] += ev_offset_rot[k] + mod_center[k] end1[k] = ev_end_rot[k] - dend_rot[k] end1[k] = ev_end_rot[k] - dend_rot[k] beg1[k] = ev_beg[k] - dend_rot[k] color = [2., ev_color, ev_color] pymol_cgo_addtri(bar_obj, ev_beg, ev_end_rot, end1, color, nm_rot) color = [2., 2., ev_color] pymol_cgo_addtri(bar_obj, ev_beg, beg1, end1, color, nm_rot) # # finish up & display energy bars # pymol_cgo_end(bar_obj) cmd.delete('bar_obj') cmd.load_cgo(bar_obj, 'bar_obj')
def pairwise_dist(pdbfile, sel1, sel2, max_dist, output="P", sidechain="N", show="N", outfile="./"): """ usage: pairwise_dist sel1, sel2, max_dist, [output=S/P/N, [sidechain=N/Y, [show=Y/N]]] sel1 and sel2 can be any to pre-existing or newly defined selections max_dist: maximum distance in Angstrom between atoms in the two selections --optional settings: output: accepts Screen/Print/None (default N) sidechain: limits (Y) results to sidechain atoms (default N) show: shows (Y) individual distances in pymol menu (default=N) """ print "" cmd.delete("dist*") extra = "" if sidechain == "Y": extra = " and not name c+o+n" #builds models m1 = cmd.get_model(sel2 + " around " + str(max_dist) + " and " + sel1 + extra) m1o = cmd.get_object_list(sel1) m2 = cmd.get_model(sel1 + " around " + str(max_dist) + " and " + sel2 + extra) m2o = cmd.get_object_list(sel2) #defines selections cmd.select("__tsel1a", sel1 + " around " + str(max_dist) + " and " + sel2 + extra) cmd.select("__tsel1", "__tsel1a and " + sel2 + extra) cmd.select("__tsel2a", sel2 + " around " + str(max_dist) + " and " + sel1 + extra) cmd.select("__tsel2", "__tsel2a and " + sel1 + extra) cmd.select("IntAtoms_" + str(max_dist), "__tsel1 or __tsel2") cmd.select("IntRes_" + str(max_dist), "byres IntAtoms_" + str(max_dist)) #controlers-1 if len(m1o) == 0: print "warning, '" + sel1 + extra + "' does not contain any atoms." return if len(m2o) == 0: print "warning, '" + sel2 + extra + "' does not contain any atoms." return #measures distances s = "" counter = 0 for c1 in range(len(m1.atom)): for c2 in range(len(m2.atom)): distance = math.sqrt( sum( map(lambda f: (f[0] - f[1])**2, zip(m1.atom[c1].coord, m2.atom[c2].coord)))) if distance < float(max_dist): s += "%s/%s/%s/%s/%s to %s/%s/%s/%s/%s: %.3f\n" % ( m1o[0], m1.atom[c1].chain, m1.atom[c1].resn, m1.atom[c1].resi, m1.atom[c1].name, m2o[0], m2.atom[c2].chain, m2.atom[c2].resn, m2.atom[c2].resi, m2.atom[c2].name, distance) counter += 1 if show == "Y": cmd.distance( m1o[0] + " and " + m1.atom[c1].chain + "/" + m1.atom[c1].resi + "/" + m1.atom[c1].name, m2o[0] + " and " + m2.atom[c2].chain + "/" + m2.atom[c2].resi + "/" + m2.atom[c2].name) #controler-2 if counter == 0: print "warning, no distances were measured! Check your selections/max_dist value" return #outputs if output == "S": print s if output == "P": filename = os.getcwd( ) + '/interface_analyzer/' + pdbfile + '_distance' + str(max_dist) f = open(filename, 'w') f.write("Number of distances calculated: %s\n" % (counter)) f.write(s) f.close() print "Results saved in _%s" % filename print "Number of distances calculated: %s" % (counter) cmd.hide("lines", "IntRes_*") if show == "Y": cmd.show("lines", "IntRes_" + max_dist) cmd.deselect()
cmd.pseudoatom(object="myline1pa1", pos=(0, 0, 0), color=(1, 1, 1)) cmd.pseudoatom(object="myline1pa2", pos=(1, 1, 1), color=(1, 1, 1)) cmd.distance(name="myline1", selection1="myline1pa1", selection2="myline1pa2", width=0.5, gap=0.2, label=0, state=1) cmd.set("dash_color", (0.9411764705882353, 0.20392156862745098, 0.20392156862745098), selection="myline1") cmd.set("dash_width", 10) cmd.delete("myline1pa1") cmd.delete("myline1pa2") cmd.pseudoatom(object="mypseudoatom1", pos=(0, 0, 0), color=(0.9411764705882353, 0.20392156862745098, 0.20392156862745098, 0.5)) cmd.pseudoatom(object="mypseudoatom2", pos=(1, 1, 1), color=(0.9411764705882353, 0.20392156862745098, 0.20392156862745098, 0.5)) cmd.group("mygroup", members="myline1") cmd.group("mygroup", members="mypseudoatom1") cmd.group("mygroup", members="mypseudoatom2")
def reset(self): cmd.delete(self.object_prefix + "*") cmd.delete("sele*") cmd.delete("_indicate*") cmd.unpick() cmd.refresh_wizard()
cmd.load("protein.mol2", "protein") donor_projected_point_0 = [COLOR, 0.0, 0.0, 1.0] + [ALPHA, 1.0] + [SPHERE, float(27.308), float(3.547), float(65.078), float(0.5)] cmd.load_cgo(donor_projected_point_0, "donor_projected_point_0_obj", 1) donor_projected_projection_0 = [COLOR, 0.6, 0.6, 1.0] + [ALPHA, 1.0] + [SPHERE, float(26.877), float(0.821), float(65.99), float(0.5)] cmd.load_cgo(donor_projected_projection_0, "donor_projected_projection_0_obj", 1) cmd.pseudoatom(object="donor_projected_line_0pa1", pos=(27.308, 3.547, 65.078), color=(1, 1, 1)) cmd.pseudoatom(object="donor_projected_line_0pa2", pos=(26.877, 0.821, 65.99), color=(1, 1, 1)) cmd.distance(name="donor_projected_line_0", selection1="donor_projected_line_0pa1", selection2="donor_projected_line_0pa2", width=0.5, gap=0.2, label=0, state=1) cmd.set("dash_color", (0.6, 0.6, 1.0), selection="donor_projected_line_0") cmd.set("dash_width", 4.0) cmd.delete("donor_projected_line_0pa1") cmd.delete("donor_projected_line_0pa2") cmd.group("donor_projected_0", members="donor_projected_point_0_obj") cmd.group("donor_projected_0", members="donor_projected_projection_0") cmd.group("donor_projected_0", members="donor_projected_line_0") cmd.select("sele", "resi 81") cmd.show("sticks", "sele") acceptor_projected_point_1 = [COLOR, 1.0, 0.0, 0.0] + [ALPHA, 1.0] + [SPHERE, float(28.364), float(4.137), float(65.698), float(0.5)] cmd.load_cgo(acceptor_projected_point_1, "acceptor_projected_point_1_obj", 1) acceptor_projected_projection_1 = [COLOR, 1.0, 0.6, 0.6] + [ALPHA, 1.0] + [SPHERE, float(30.481), float(2.301), float(66.766), float(0.5)] cmd.load_cgo(acceptor_projected_projection_1, "acceptor_projected_projection_1_obj", 1) cmd.pseudoatom(object="acceptor_projected_line_1pa1", pos=(28.364, 4.137, 65.698), color=(1, 1, 1)) cmd.pseudoatom(object="acceptor_projected_line_1pa2", pos=(30.481, 2.301, 66.766), color=(1, 1, 1))
def fetch_similar_blast( chain_id, similarity=95, ligand=None, dist=5, compounds="organic or inorganic", prosthetic_groups="HEM FAD NAP NDP ADP FMN", max_resolution=None, max_structures=50, ): """ Fetch sequence similar structures from RCSB PDB and optionally keep only apo structures. Apo are evaluated respective to a choosen ligand on the reference chain. On the first use update the database with the command `update_cluster_data`. Update the database weekly. OPTIONS chain_id Reference structure chain id. similarity Sequence similarity threshold (one of the available from RCSB PDB). ligand Reference ligand PDB id. dist Distance cut-off around reference ligand for apo evaluation. compounds Selection that should be considered ligands upon apo computation. Only used when ligand is given. prothestic_groups List of ligands to be ignored when evaluating apo. max_resolution Fetch only X-ray structures with up to such resolution. max_structures Fetch at most n structures. 0 for all structures. EXAMPLES fetch_similar_blast 2XY9_A, 100 fetch_similar_blast 2XY9_A, 95, 3ES, 3, organic fetch_similar_blast 6Y2F_A, max_structures=0 SEE ALSO update_cluster_data fetch_similar_shape3d """ chain_id = chain_id.upper() max_structures = int(max_structures) pm.fetch(chain_id, chain_id) sims = [] similars = find_similar_chain_ids(chain_id, similarity) cont = 0 for sim_pdb, sim_chain in similars: if max_structures != 0 and cont >= max_structures: break sim_obj = f"{sim_pdb}_{sim_chain}" if sim_obj.upper() == chain_id.upper(): continue pm.fetch(sim_obj, **{"async": 0}) pm.align(sim_obj, chain_id) # Check the resolution resol = None if max_resolution: resol = get_resolution(sim_pdb) if not resol or resol > max_resolution: pm.delete(sim_obj) continue # Check nearby ligands if ligand: model = pm.get_model( f"({sim_obj} and ({compounds}))" f" within {dist} of" f"({chain_id} and (resn {ligand}))" ) resns = set(a.resn for a in model.atom) is_apo = True for resn in resns: if resn not in prosthetic_groups.split(): is_apo = False break if not is_apo: pm.delete(sim_obj) continue cont += 1 sims.append((sim_obj, sim_chain, sim_pdb, resol)) plot_hierarquical_cluster([chain_id] + [s[0] for s in sims]) return sims
def delete_all(self): cmd.delete("plane*")
def apply(self): cmd = self.cmd if self.status == 1: # find the name of the object which contains the selection src_frame = cmd.get_state() try: new_name = cmd.get_object_list(src_sele)[0] except IndexError: print(" Mutagenesis: object not found.") return if True: auto_zoom = cmd.get_setting_text('auto_zoom') cmd.set('auto_zoom', "0", quiet=1) if self.lib_mode != "current": # create copy with mutant in correct frame state = cmd.get_object_state(new_name) cmd.create(tmp_obj2, obj_name, src_frame, state) cmd.set_title(tmp_obj2, state, '') cmd.color(self.stored.identifiers[4], "?%s & elem C" % tmp_obj2) cmd.alter(tmp_obj2, 'ID = -1') # select backbone connection atoms cmd.select(tmp_sele1, 'neighbor ?%s' % (src_sele), 0) # remove residue and neighboring c-cap/n-cap (if any) cmd.remove("?%s | byres (?%s & " "(name N & resn NME+NHH | name C & resn ACE))" % (src_sele, tmp_sele1)) # create the merged molecule cmd.create(new_name, "?%s | ?%s" % (new_name, tmp_obj2), state, state) # now connect them cmd.select( tmp_sele2, '/%s/%s/%s/%s' % ((new_name, ) + self.stored.identifiers[:3])) cmd.bond('?%s & name C' % (tmp_sele1), '?%s & name N' % (tmp_sele2), quiet=1) cmd.bond('?%s & name N' % (tmp_sele1), '?%s & name C' % (tmp_sele2), quiet=1) cmd.set_geometry('(?%s | ?%s) & name C+N' % (tmp_sele1, tmp_sele2), 3, 3) # make amide planer # fix N-H hydrogen position (if any exists) cmd.h_fix('?%s & name N' % (tmp_sele2)) # delete temporary objects/selections cmd.delete(tmp_sele1) cmd.delete(tmp_sele2) cmd.delete(tmp_obj2) 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)
def remove(self): cmd.delete(self.name)
def interface(sele1=None, sele2=None, d=4, sc_only=0): """Select and name the interfaces between selections. Defaults to combinations between all chains. Args: sele1 (str): First PyMol selection sele2 (str): Second PyMol selection d (int): Depth of interface sc_only (int): Filter by side-chain contacts only, instead of all atoms Returns: Nothing """ d = str(d) stored.chains = [] if "\"\"" in [sele1, sele2] or None in [sele1, sele2]: chain_names = cmd.get_chains('polymer') stored.chains = [ "chain "+s for s in chain_names ] else: stored.chains.append(sele1) stored.chains.append(sele2) for a, b in combinations(stored.chains, 2): if int(sc_only) == 1: selection = ( "(br. ("+a+" and not name c+ca+o+n+h+ha) "+ "within "+d+" of ("+b+" and not name c+ca+o+n+h+ha)) "+ " or (br. ("+b+" and not name c+ca+o+n+h+ha) "+ "within "+d+" of ("+a+" and not name c+ca+o+n+h+ha)) " ) else: selection = ( "(br. "+a+" within "+d+" of "+b+")"+ " or (br. "+b+" within "+d+" of "+a+")" ) # Make nicer names for the default case a_name = "".join(a.split()).replace("chain","") b_name = "".join(b.split()).replace("chain","") sel_name = "int_"+a_name+b_name try: sele = cmd.select(sel_name, selection) except: print("Error in selection: "+selection) raise CmdException # Remove empty selections stored.test = [] try: cmd.iterate(sel_name+" and name ca", "stored.test.append(\"\"+resi)") except: print("Cannot iterate through "+sel_name) raise CmdException if not stored.test: try: cmd.delete(sel_name) except: print("Cannot delete "+sel_name) raise CmdException
def do_library(self): cmd = self.cmd pymol = cmd._pymol if not ((cmd.count_atoms("(%s) and name N" % src_sele) == 1) and (cmd.count_atoms("(%s) and name C" % src_sele) == 1) and (cmd.count_atoms("(%s) and name O" % src_sele) == 1)): self.clear() return 1 cmd.feedback("push") cmd.feedback("disable", "selector", "everythin") cmd.feedback("disable", "editor", "actions") self.prompt = ['Loading rotamers...'] self.bump_scores = [] state_best = 0 pymol.stored.name = 'residue' cmd.iterate("first (%s)" % src_sele, 'stored.name=model+"/"+segi+"/"+chain+"/"+resn+"`"+resi') self.res_text = pymol.stored.name cmd.select("_seeker_hilight", src_sele) auto_zoom = cmd.get_setting_text('auto_zoom') cmd.set('auto_zoom', "0", quiet=1) cmd.frame(0) cmd.delete(frag_name) if self.auto_center: cmd.center(src_sele, animate=-1) self.lib_mode = self.mode if self.lib_mode == "current": pymol.stored.resn = "" cmd.iterate("(%s & name CA)" % src_sele, "stored.resn=resn") rot_type = _rot_type_xref.get(pymol.stored.resn, pymol.stored.resn) if (self.c_cap != 'none') or (self.n_cap != 'none') or (self.hyd != 'auto'): self.lib_mode = rot_type # force fragment-based load else: cmd.create(frag_name, src_sele, 1, 1) if self.c_cap == 'open': cmd.remove("%s and name OXT" % frag_name) if self.lib_mode != 'current': rot_type = self.lib_mode frag_type = self.lib_mode if (self.n_cap == 'posi') and (frag_type[0:3] != 'NT_'): if not (cmd.count_atoms( "elem C & !(%s) & (bto. (name N & (%s))) &! resn ACE" % (src_sele, src_sele))): # use N-terminal fragment frag_type = "NT_" + frag_type if (self.c_cap == 'nega') and (frag_type[0:3] != 'CT_'): if not (cmd.count_atoms( "elem N & !(%s) & (bto. (name C & (%s))) & !resn NME+NHH" % (src_sele, src_sele))): # use C-terminal fragment frag_type = "CT_" + frag_type if rot_type[0:3] in ['NT_', 'CT_']: rot_type = rot_type[3:] rot_type = _rot_type_xref.get(rot_type, rot_type) cmd.fragment(frag_type.lower(), frag_name, origin=0) # trim off hydrogens if (self.hyd == 'none'): cmd.remove("(" + frag_name + " and hydro)") elif (self.hyd == 'auto'): if cmd.count_atoms("(" + src_sele + ") and hydro") == 0: cmd.remove("(" + frag_name + " and hydro)") # copy identifying information cmd.alter("?%s & name CA" % src_sele, "stored.identifiers = (segi, chain, resi, ss, color)", space=self.space) cmd.alter("?%s" % frag_name, "(segi, chain, resi, ss) = stored.identifiers[:4]", space=self.space) # move the fragment if ((cmd.count_atoms("(%s & name CB)" % frag_name) == 1) and (cmd.count_atoms("(%s & name CB)" % src_sele) == 1)): cmd.pair_fit( "(%s & name CA)" % frag_name, "(%s & name CA)" % src_sele, "(%s & name CB)" % frag_name, "(%s & name CB)" % src_sele, "(%s & name C)" % frag_name, "(%s & name C)" % src_sele, "(%s & name N)" % frag_name, "(%s & name N)" % src_sele) else: cmd.pair_fit("(%s & name CA)" % frag_name, "(%s & name CA)" % src_sele, "(%s & name C)" % frag_name, "(%s & name C)" % src_sele, "(%s & name N)" % frag_name, "(%s & name N)" % src_sele) # fix the carbonyl position... cmd.iterate_state(1, "(%s & name O)" % src_sele, "stored.list=[x,y,z]") cmd.alter_state(1, "(%s & name O)" % frag_name, "(x,y,z)=stored.list") if cmd.count_atoms("(%s & name OXT)" % src_sele): cmd.iterate_state(1, "(%s & name OXT)" % src_sele, "stored.list=[x,y,z]") cmd.alter_state(1, "(%s & name OXT)" % frag_name, "(x,y,z)=stored.list") elif cmd.count_atoms("(%s & name OXT)" % frag_name): # place OXT if no template exists angle = cmd.get_dihedral("(%s & name N)" % frag_name, "(%s & name CA)" % frag_name, "(%s & name C)" % frag_name, "(%s & name O)" % frag_name) cmd.protect("(%s & name O)" % frag_name) cmd.set_dihedral("(%s & name N)" % frag_name, "(%s & name CA)" % frag_name, "(%s & name C)" % frag_name, "(%s & name OXT)" % frag_name, 180.0 + angle) cmd.deprotect(frag_name) # fix the hydrogen position (if any) if cmd.count_atoms("(hydro and bound_to (name N & (%s)))" % frag_name) == 1: if cmd.count_atoms("(hydro and bound_to (name N & (%s)))" % src_sele) == 1: cmd.iterate_state( 1, "(hydro and bound_to (name N & (%s)))" % src_sele, "stored.list=[x,y,z]") cmd.alter_state( 1, "(hydro and bound_to (name N & (%s)))" % frag_name, "(x,y,z)=stored.list") elif cmd.select( tmp_sele1, "(name C & bound_to (%s and elem N))" % src_sele) == 1: # position hydro based on location of the carbonyl angle = cmd.get_dihedral("(%s & name C)" % frag_name, "(%s & name CA)" % frag_name, "(%s & name N)" % frag_name, tmp_sele1) cmd.set_dihedral("(%s & name C)" % frag_name, "(%s & name CA)" % frag_name, "(%s & name N)" % frag_name, "(%s & name H)" % frag_name, 180.0 + angle) cmd.delete(tmp_sele1) # add c-cap (if appropriate) if self.c_cap in ['amin', 'nmet']: if not cmd.count_atoms( "elem N & !(%s) & (bto. (name C & (%s))) & !resn NME+NHH" % (src_sele, src_sele)): if cmd.count_atoms("name C & (%s)" % (frag_name)) == 1: if self.c_cap == 'amin': editor.attach_amino_acid("name C & (%s)" % (frag_name), 'nhh', _self=cmd) elif self.c_cap == 'nmet': editor.attach_amino_acid("name C & (%s)" % (frag_name), 'nme', _self=cmd) if cmd.count_atoms( "hydro & bound_to (name N & bound_to (name C & (%s)))" % frag_name): cmd.h_fix("name N & bound_to (name C & (%s))" % frag_name) # trim hydrogens if (self.hyd == 'none'): cmd.remove("(" + frag_name + " and hydro)") elif (self.hyd == 'auto'): if cmd.count_atoms("(" + src_sele + ") and hydro") == 0: cmd.remove("(" + frag_name + " and hydro)") # add n-cap (if appropriate) if self.n_cap in ['acet']: if not cmd.count_atoms( "elem C & !(%s) & (bto. (name N & (%s))) & !resn ACE " % (src_sele, src_sele)): if cmd.count_atoms("name N & (%s)" % (frag_name)) == 1: if self.n_cap == 'acet': editor.attach_amino_acid("name N & (%s)" % (frag_name), 'ace', _self=cmd) if cmd.count_atoms( "hydro & bound_to (name N & bound_to (name C & (%s)))" % frag_name): cmd.h_fix("name N & (%s)" % frag_name) # trim hydrogens if (self.hyd == 'none'): cmd.remove("(" + frag_name + " and hydro)") elif (self.hyd == 'auto'): if cmd.count_atoms("(" + src_sele + ") and hydro") == 0: cmd.remove("(" + frag_name + " and hydro)") cartoon = (cmd.count_atoms("(%s & name CA & rep cartoon)" % src_sele) > 0) sticks = (cmd.count_atoms("(%s & name CA & rep sticks)" % src_sele) > 0) cmd.delete(obj_name) key = rot_type lib = None if self.dep == 'dep': try: result = cmd.phi_psi("%s" % src_sele) if len(result) == 1: (phi, psi) = list(result.values())[0] (phi, psi) = (int(10 * round(phi / 10)), int(10 * (round(psi / 10)))) key = (rot_type, phi, psi) if key not in self.dep_library: (phi, psi) = (int(20 * round(phi / 20)), int(20 * (round(psi / 20)))) key = (rot_type, phi, psi) if key not in self.dep_library: (phi, psi) = (int(60 * round(phi / 60)), int(60 * (round(psi / 60)))) key = (rot_type, phi, psi) lib = self.dep_library.get(key, None) except: pass if lib is None: key = rot_type lib = self.ind_library.get(key, None) if (lib is not None) and self.dep == 'dep': print( ' Mutagenesis: no phi/psi, using backbone-independent rotamers.' ) if lib is not None: state = 1 for a in lib: cmd.create(obj_name, frag_name, 1, state) if state == 1: cmd.select(mut_sele, "(byres (%s like %s))" % (obj_name, src_sele)) if rot_type == 'PRO': cmd.unbond("(%s & name N)" % mut_sele, "(%s & name CD)" % mut_sele) for b in a.keys(): if b != 'FREQ': cmd.set_dihedral("(%s & n;%s)" % (mut_sele, b[0]), "(%s & n;%s)" % (mut_sele, b[1]), "(%s & n;%s)" % (mut_sele, b[2]), "(%s & n;%s)" % (mut_sele, b[3]), a[b], state=state) else: cmd.set_title(obj_name, state, "%1.1f%%" % (a[b] * 100)) if rot_type == 'PRO': cmd.bond("(%s & name N)" % mut_sele, "(%s & name CD)" % mut_sele) state = state + 1 cmd.delete(frag_name) print(" Mutagenesis: %d rotamers loaded." % len(lib)) if self.bump_check: cmd.delete(bump_name) cmd.create( bump_name, "(((byobj %s) within 6 of (%s and not name N+C+CA+O+H+HA)) and (not (%s)))|(%s)" % (src_sele, mut_sele, src_sele, mut_sele), singletons=1) cmd.color("gray50", bump_name + " and elem C") cmd.set("seq_view", 0, bump_name, quiet=1) cmd.hide("everything", bump_name) if ((cmd.select( tmp_sele1, "(name N & (%s in (neighbor %s)))" % (bump_name, src_sele)) == 1) and (cmd.select( tmp_sele2, "(name C & (%s in %s))" % (bump_name, mut_sele)) == 1)): cmd.bond(tmp_sele1, tmp_sele2) if ((cmd.select( tmp_sele1, "(name C & (%s in (neighbor %s)))" % (bump_name, src_sele)) == 1) and (cmd.select( tmp_sele2, "(name N & (%s in %s))" % (bump_name, mut_sele)) == 1)): cmd.bond(tmp_sele1, tmp_sele2) cmd.delete(tmp_sele1) cmd.delete(tmp_sele2) cmd.protect( "%s and not (%s in (%s and not name N+C+CA+O+H+HA))" % (bump_name, bump_name, mut_sele)) cmd.sculpt_activate(bump_name) cmd.show("cgo", bump_name) # draw the bumps cmd.set("sculpt_vdw_vis_mode", 1, bump_name) state = 1 score_best = 1e6 for a in lib: score = cmd.sculpt_iterate(bump_name, state, 1) self.bump_scores.append(score) if score < score_best: state_best = state score_best = score state = state + 1 cmd.delete(mut_sele) else: cmd.create(obj_name, frag_name, 1, 1) print(" Mutagenesis: no rotamers found in library.") cmd.set("seq_view", 0, obj_name, quiet=1) pymol.util.cbaw(obj_name, _self=cmd) cmd.hide("(" + obj_name + ")") cmd.show(self.rep, obj_name) cmd.show('lines', obj_name) #neighbor always show lines if cartoon: cmd.show("cartoon", obj_name) if sticks: cmd.show("sticks", obj_name) cmd.set('auto_zoom', auto_zoom, quiet=1) cmd.delete(frag_name) cmd.frame(state_best) # this might be redundant if frame(state_best) changed the state self.do_state(state_best) cmd.unpick() cmd.feedback("pop")
def runDSSP(self): """ @return: whether DSSP has been executed successfully @rtype: boolean """ # delete old results self.sel_obj_list = [] self.dssp_rlt_dict = {} self.SSE_res_dict = {} self.SSE_sel_dict = {} pdb_fn = None sel_name = None sel = self.pymol_sel.get() if len(sel) > 0: # if any pymol selection/object is specified # save the pymol selection/object in the tmp dir all_sel_names = cmd.get_names('all') # get names of all selections if sel in all_sel_names: if cmd.count_atoms(sel) == 0: err_msg = 'ERROR: The selection %s is empty.' % (sel, ) print 'ERROR: %s' % (err_msg, ) tkMessageBox.showinfo(title='ERROR', message=err_msg) return False else: sel_name = sel # no selection/object with the input name is found # we assume either a single-word selector or # some other selection-expression is used # NOTE: if more than one selection is selected, they should be # saved separately and SSE should be calculated for each # of the selections. else: print 'The selection/object you specified is not found.' print 'Your input will be interpreted as a selection-expression.' # check whether the selection is empty tmpsel = self.randomSeleName(prefix='your_sele_') cmd.select(tmpsel, sel) if cmd.count_atoms(tmpsel) == 0: cmd.delete(tmpsel) err_msg = 'ERROR: The selection %s is empty.' % (sel, ) print 'ERROR: %s' % (err_msg, ) tkMessageBox.showinfo(title='ERROR', message=err_msg) return False else: sel_name = tmpsel else: # what structure do you want DSSP to work on? err_msg = 'No PyMOL selection/object specified!' print 'ERROR: %s' % (err_msg, ) tkMessageBox.showinfo(title='ERROR', message=err_msg) return False # each object in the selection is treated as an independent struc objlist = cmd.get_object_list(sel_name) self.ss_asgn_prog = 'DSSP' print 'Starting %s ...' % (self.ss_asgn_prog, ) for objname in objlist: self.sel_obj_list.append('%s and %s' % (sel_name, objname)) self.runDSSPOneObj(self.sel_obj_list[-1]) ## cmd.delete(tmpsel) return True
def clear(self): cmd = self.cmd self.status = 0 self.bump_scores = [] cmd.delete(tmp_hbonds) cmd.delete(tmp_obj2) cmd.delete(mut_sele) cmd.delete(src_sele) cmd.delete(obj_name) cmd.delete(bump_name) cmd.delete("_seeker_hilight") cmd.refresh_wizard()
def elbow_angle(obj, light='L', heavy='H', limit_l=107, limit_h=113, draw=0): """ DESCRIPTION Calculates the integer elbow angle of an antibody Fab complex and optionally draws a graphical representation of the vectors used to determine the angle. ARGUMENTS obj = string: object light/heavy = strings: chain ID of light and heavy chains, respectively limit_l/limit_h = integers: residue numbers of the last residue in the light and heavy chain variable domains, respectively draw = boolean: Choose whether or not to draw the angle visualization REQUIRES: com.py, transformations.py, numpy (see above) """ # store current view orig_view = cmd.get_view() limit_l = int(limit_l) limit_h = int(limit_h) draw = int(draw) # for temp object names tmp_prefix = "tmp_elbow_" prefix = tmp_prefix + obj + '_' # names vl = prefix + 'VL' vh = prefix + 'VH' cl = prefix + 'CL' ch = prefix + 'CH' # selections vl_sel = 'polymer and %s and chain %s and resi 1-%i' % (obj, light, limit_l) vh_sel = 'polymer and %s and chain %s and resi 1-%i' % (obj, heavy, limit_h) cl_sel = 'polymer and %s and chain %s and not resi 1-%i' % (obj, light, limit_l) ch_sel = 'polymer and %s and chain %s and not resi 1-%i' % (obj, heavy, limit_h) v_sel = '((' + vl_sel + ') or (' + vh_sel + '))' c_sel = '((' + cl_sel + ') or (' + ch_sel + '))' # create temp objects cmd.create(vl, vl_sel) cmd.create(vh, vh_sel) cmd.create(cl, cl_sel) cmd.create(ch, ch_sel) # superimpose vl onto vh, calculate axis and angle Rv = calc_super_matrix(vl, vh) angle_v, direction_v, point_v = transformations.rotation_from_matrix(Rv) # superimpose cl onto ch, calculate axis and angle Rc = calc_super_matrix(cl, ch) angle_c, direction_c, point_c = transformations.rotation_from_matrix(Rc) # delete temporary objects cmd.delete(vl) cmd.delete(vh) cmd.delete(cl) cmd.delete(ch) # if dot product is positive, angle is acute if (numpy.dot(direction_v, direction_c) > 0): direction_c = direction_c * -1 # ensure angle is > 90 (need to standardize this) # TODO: make both directions point away from the elbow axis. elbow = int(numpy.degrees(numpy.arccos(numpy.dot(direction_v, direction_c)))) # while (elbow < 90): # elbow = 180 - elbow # limit to physically reasonable range # compare the direction_v and direction_c axes to the vector defined by # the C-alpha atoms of limit_l and limit_h of the original fab hinge_l_sel = "%s//%s/%s/CA" % (obj, light, limit_l) hinge_h_sel = "%s//%s/%s/CA" % (obj, heavy, limit_h) hinge_l = cmd.get_atom_coords(hinge_l_sel) hinge_h = cmd.get_atom_coords(hinge_h_sel) hinge_vec = numpy.array(hinge_h) - numpy.array(hinge_l) test = numpy.dot(hinge_vec, numpy.cross(direction_v, direction_c)) if (test > 0): elbow = 360 - elbow print(" Elbow angle: %i degrees" % elbow) if (draw == 1): # there is probably a more elegant way to do this, but # it works so I'm not going to mess with it for now pre = obj + '_elbow_' # draw hinge vector cmd.pseudoatom(pre + "hinge_l", pos=hinge_l) cmd.pseudoatom(pre + "hinge_h", pos=hinge_h) cmd.distance(pre + "hinge_vec", pre + "hinge_l", pre + "hinge_h") cmd.set("dash_gap", 0) # draw the variable domain axis com_v = COM(v_sel) start_v = [a - 10 * b for a, b in zip(com_v, direction_v)] end_v = [a + 10 * b for a, b in zip(com_v, direction_v)] cmd.pseudoatom(pre + "start_v", pos=start_v) cmd.pseudoatom(pre + "end_v", pos=end_v) cmd.distance(pre + "v_vec", pre + "start_v", pre + "end_v") # draw the constant domain axis com_c = COM(c_sel) start_c = [a - 10 * b for a, b in zip(com_c, direction_c)] end_c = [a + 10 * b for a, b in zip(com_c, direction_c)] cmd.pseudoatom(pre + "start_c", pos=start_c) cmd.pseudoatom(pre + "end_c", pos=end_c) cmd.distance(pre + "c_vec", pre + "start_c", pre + "end_c") # customize appearance cmd.hide("labels", pre + "hinge_vec") cmd.hide("labels", pre + "v_vec") cmd.hide("labels", pre + "c_vec") cmd.color("green", pre + "hinge_l") cmd.color("red", pre + "hinge_h") cmd.color("black", pre + "hinge_vec") cmd.color("black", pre + "start_v") cmd.color("black", pre + "end_v") cmd.color("black", pre + "v_vec") cmd.color("black", pre + "start_c") cmd.color("black", pre + "end_c") cmd.color("black", pre + "c_vec") # draw spheres cmd.show("spheres", pre + "hinge_l or " + pre + "hinge_h") cmd.show("spheres", pre + "start_v or " + pre + "start_c") cmd.show("spheres", pre + "end_v or " + pre + "end_c") cmd.set("sphere_scale", 2) cmd.set("dash_gap", 0, pre + "hinge_vec") cmd.set("dash_width", 5) cmd.set("dash_radius", 0.3) # group drawing objects cmd.group(pre, pre + "*") # restore original view cmd.set_view(orig_view) return 0
def selectSSE(self, sel, sse): """ generate selector for selecting all residues having the given sse. return the selection name. """ #sel = self.pymol_sel.get() sel_list_chn = [] if VERBOSE: print '\nSelecting SSE %s ... \n' % (sse) for chn in self.SSE_res_dict[sel][sse]: # color one chain at a time if chn == ' ': chn_str = '-' else: chn_str = chn if VERBOSE: print 'Selecting SSE %s on chain %s ... \n' % (sse, chn) limit = 150 # color every 150 residues sel_name_chn = self.randomSeleName( prefix='%s_%s_%s_' % ('_'.join(sel.split()), chn_str, sse)) if len(self.SSE_res_dict[sel][sse][chn]) < limit: #sel_expr = '/%s//%s/%s/' % (sel,chn.strip(), '+'.join(self.SSE_res[sse][chn])) # always quote chain name in case it is empty (otherwise sel misinterpreted) sel_expr = '(%s) and \"%s\"/%s/' % (sel, chn.strip(), '+'.join( self.SSE_res_dict[sel][sse][chn])) cmd.select(sel_name_chn, sel_expr) if VERBOSE: print 'select %s, %s' % (sel_name_chn, sel_expr) sel_list_chn.append(sel_name_chn) else: rn = len(self.SSE_res_dict[sel][sse][chn]) print 'total number of res with %s = %d' % (sse, rn) sz = int(math.ceil(rn / float(limit))) sel_list_seg = [] for i in xrange(sz): s, e = i * limit, min((i + 1) * limit, rn) print s, e #sel_expr = '/%s//%s/%s/' % (sel,chn.strip(), '+'.join(self.SSE_res[sse][chn][s:e])) # always quote chain name in case it is empty (otherwise sel misinterpreted) sel_expr = '(%s) and \"%s\"/%s/' % ( sel, chn.strip(), '+'.join( self.SSE_res_dict[sel][sse][chn][s:e])) sel_name_seg = self.randomSeleName( prefix='%s_%s_%s_tmp_' % ('_'.join(sel.split()), chn_str, sse)) cmd.select(sel_name_seg, sel_expr) if VERBOSE: print 'select %s, %s' % (sel_name_seg, sel_expr) sel_list_seg.append(sel_name_seg) sel_expr = ' or '.join(sel_list_seg) cmd.select(sel_name_chn, sel_expr) if VERBOSE: print 'select %s, %s' % (sel_name_chn, sel_expr) [cmd.delete(asel) for asel in sel_list_seg] sel_list_chn.append(sel_name_chn) if len(sel_list_chn) > 0: sel_name = self.randomSeleName( prefix='%s_%s_%s_' % ('_'.join(sel.split()), sse, self.ss_asgn_prog)) sel_expr = ' or '.join(sel_list_chn) cmd.select(sel_name, sel_expr) [cmd.delete(asel) for asel in sel_list_chn] else: print 'INFO: No residues are assigned to SSE \'%s\'.' % (sse, ) sel_name = None return sel_name
def supercell(a=1, b=1, c=1, object=None, color='green', name='supercell', withmates=1, prefix='m'): ''' DESCRIPTION Draw a supercell, as requested by Nicolas Bock on the pymol-users mailing list (Subject: [PyMOL] feature request: supercell construction Date: 04/12/2010 10:12:17 PM (Mon, 12 Apr 2010 14:12:17 -0600)) USAGE supercell a, b, c [, object [, color [, name [, withmates]]]] ARGUMENTS a, b, c = integer: repeat cell in x,y,z direction a,b,c times {default: 1,1,1} object = string: name of object to take cell definition from color = string: color of cell {default: blue} name = string: name of the cgo object to create {default: supercell} withmates = bool: also create symmetry mates in displayed cells {default: 1} SEE ALSO show cell ''' import numpy from pymol import cgo if object is None: object = cmd.get_object_list()[0] withmates = int(withmates) sym = cmd.get_symmetry(object) cell_edges = sym[0:3] cell_angles = sym[3:6] basis = cellbasis(cell_angles, cell_edges) assert isinstance(basis, numpy.ndarray) ts = list() for i in range(int(a)): for j in range(int(b)): for k in range(int(c)): ts.append([i,j,k]) obj = [ cgo.BEGIN, cgo.LINES, ] groupname_fmt = prefix + ('%d_%d_%d' if any(int(i) > 9 for i in [a, b, c]) else '%d%d%d') for t in ts: shift = basis[0:3,0:3] * t shift = shift[:,0] + shift[:,1] + shift[:,2] for i in range(3): vi = basis[0:3,i] vj = [ numpy.array([0.,0.,0.]), basis[0:3,(i+1)%3], basis[0:3,(i+2)%3], basis[0:3,(i+1)%3] + basis[0:3,(i+2)%3] ] for j in range(4): obj.append(cgo.VERTEX) obj.extend((shift + vj[j]).tolist()) obj.append(cgo.VERTEX) obj.extend((shift + vj[j] + vi).tolist()) if withmates: groupname = groupname_fmt % tuple(t) symexpcell(groupname + '_', object, *t) cmd.group(groupname, groupname + '_*') obj.append(cgo.END) if name != 'none': cmd.delete(name) cmd.load_cgo(obj, name) cmd.color(color, name)
def Btn_SaveObject_Clicked(self, objtype): # Get the Drop Down List Selection Name ddlSelection = self.defaultOption.get() state = cmd.get_state() self.Set_Object_Variables(objtype) if ddlSelection == '' or self.Validate_ObjectSelection( ddlSelection, objtype, state): return Path = tkFileDialog.asksaveasfilename(filetypes=[('PDB File', '*.pdb') ], initialdir=self.savepath, title='Save the PDB File', initialfile=ddlSelection, defaultextension='.pdb') if len(Path) > 0: Path = os.path.normpath(Path) if General.validate_String(Path, '.pdb', True, False, True): self.DisplayMessage( " ERROR: Could not save the file because you entered an invalid name.", 2) return if self.top.ValidateSaveProject(Path, objtype): self.DisplayMessage( " ERROR: The file can only be saved at its default location", 2) return try: cmd.save(Path, ddlSelection, state) Name = os.path.basename(os.path.splitext(Path)[0]) cmd.load(Path, Name, state=1) cmd.refresh() if ddlSelection != Name: # as if the object was renamed, delete the object cmd.delete(ddlSelection) except: self.DisplayMessage( " ERROR: An error occured while saving the object.", 1) return self.VarPath.set(os.path.normpath(Path)) self.VarName.set(Name) self.VarProc.set('') self.top.SaveSessionFile = '' #self.VarMD5.set(General.hashfile(self.VarPath.get())) if objtype == 'Ligand': self.Reset_Ligand() self.DisplayMessage( ' Successfully saved and loaded the object: ' + self.VarName.get() + "'", 0)