def rmsd_ligands_ralign(self): parser=Bio.PDB.PDBParser() mat=[] for i,complex1name in enumerate(self.complexes.keys()): print complex1name complex1=self.complexes[complex1name] r1=complex1.receptor l1=complex1.ligand row=[] for j,complex2name in enumerate(self.complexes.keys()): print complex2name if i==j: row.append(float(0)) continue complex2=self.complexes[complex2name] r2=complex2.receptor l2=complex2.ligand cmd.align(complex1name+' and chain '+r1,complex2name+' and chain '+r2) outobj1=complex1name.split('_')[0]+'_ligand' cmd.create(outobj1,complex1name+' and chain '+l1) cmd.save(outobj1+'.pdb',outobj1) outobj2=complex2name.split('_')[0]+'_ligand' cmd.create(outobj2,complex2name+' and chain '+l2) cmd.save(outobj2+'.pdb',outobj2) structure1=parser.get_structure(outobj1,outobj1+'.pdb') model1=structure1[0] ligand1=model1[l1] structure2=parser.get_structure(outobj2,outobj2+'.pdb') model2=structure2[0] ligand2=model2[l2] distances=[] l1_residues=dict() l2_residues=dict() for res1 in ligand1: pos1=str(res1.get_id()[1]) l1_residues[pos1]=res1 for res2 in ligand2: pos2=str(res2.get_id()[1]) l2_residues[pos2]=res2 for pos1 in l1_residues.keys(): try: res2=l2_residues[pos1] except KeyError: continue res1=l1_residues[pos1] try: x1,y1,z1=res1['CA'].get_coord() x2,y2,z2=res2['CA'].get_coord() except KeyError: continue distance=((float(x2-x1))**2+(float(y2-y1))**2+(float(z2-z1))**2)**0.5 distances.append(distance) rmsd=sum([d**2 for d in distances])**0.5 row.append(rmsd) mat.append(row) self.rmsd_ligands_ralign=mat print "done"
def protein_vacuum_esp(selection, mode=2, border=10.0, quiet = 1, _self=cmd): pymol=_self._pymol cmd=_self if ((string.split(selection)!=[selection]) or selection not in cmd.get_names('objects')): print " Error: must provide an object name" raise cmd.QuietException obj_name = selection + "_e_chg" map_name = selection + "_e_map" pot_name = selection + "_e_pot" cmd.disable(selection) cmd.delete(obj_name) cmd.delete(map_name) cmd.delete(pot_name) cmd.create(obj_name,"((polymer and ("+selection+ ") and (not resn A+C+T+G+U)) or ((bymol (polymer and ("+ selection+"))) and resn NME+NHE+ACE)) and (not hydro)") # try to just get protein... protein_assign_charges_and_radii(obj_name,_self=_self) ext = cmd.get_extent(obj_name) max_length = max(abs(ext[0][0] - ext[1][0]),abs(ext[0][1] - ext[1][1]),abs(ext[0][2]-ext[1][2])) + 2*border # compute an grid with a maximum dimension of 50, with 10 A borders around molecule, and a 1.0 A minimum grid sep = max_length/50.0 if sep<1.0: sep = 1.0 print " Util: Calculating electrostatic potential..." if mode==0: # absolute, no cutoff cmd.map_new(map_name,"coulomb",sep,obj_name,border) elif mode==1: # neutral, no cutoff cmd.map_new(map_name,"coulomb_neutral",sep,obj_name,border) else: # local, with cutoff cmd.map_new(map_name,"coulomb_local",sep,obj_name,border) cmd.ramp_new(pot_name, map_name, selection=obj_name,zero=1) cmd.hide("everything",obj_name) cmd.show("surface",obj_name) cmd.set("surface_color",pot_name,obj_name) cmd.set("surface_ramp_above_mode",1,obj_name)
def ColorByDisplacementCA(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 if AlignedWhite=='yes': cmd.iterate(tObj1 + " and n. CA and not " + aln, "stored.alnAres.append(resi)") cmd.iterate(tObj2 + " and n. CA and not " + aln, "stored.alnBres.append(resi)") else: cmd.iterate(tObj1 + " and n. CA", "stored.alnAres.append(resi)") cmd.iterate(tObj2 + " and n. CA", "stored.alnBres.append(resi)") ### Change the B-factors for EACH object displacementUpdateB(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 n. CA and not " + aln, "stored.alnAnb.append(b)" ) cmd.iterate(tObj2 + " and n. CA and not " + aln, "stored.alnBnb.append(b)" ) else: ### Or Iterate over all objects with CA cmd.iterate(tObj1 + " and n. CA", "stored.alnAnb.append(b)" ) cmd.iterate(tObj2 + " and n. CA", "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 for x in range(len(stored.alnAres)): cmd.alter(objSel1 + " and n. CA and i. " + str(stored.alnAres[x]), "b = " + str(stored.alnAnb[x])) for x in range(len(stored.alnBres)): cmd.alter(objSel2 + " and n. CA and i. " + str(stored.alnBres[x]), "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 "\nColorByDisplacementCA 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("cartoon", 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 (Displacment values) # cmd.spectrum("b", 'rainbow', "((" + objSel1 + " and n. CA) or (n. CA and " + objSel2 +" )) and not notUsedForAln+ResNotInBothPDB") cmd.spectrum("b", 'rainbow', "((" + objSel1 + " and n. CA) or (n. CA and " + 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..."
def colorByRMSD(objSel1, objSel2, doAlign="True", doPretty=None): """ colorByRMSD -- align two structures and show the structural deviations in color to more easily see variable regions. PARAMS objSel1 (valid PyMOL object or selection) The first object to align. objSel2 (valid PyMOL object or selection) The second object to align doAlign (boolean, either True or False) Should this script align your proteins or just leave them as is? If doAlign=True then your original proteins are aligned. If False, then they are not. Regardless, the B-factors are changed. DEFAULT: True doPretty (boolean, either True or False) If doPretty=True then a simple representation is created to highlight the differences. If False, then no changes are made. DEFAULT: False RETURNS None. SIDE-EFFECTS Modifies the B-factor columns in your original structures. """ # First create backup copies; names starting with __ (underscores) are # normally hidden by PyMOL tObj1, tObj2, aln = "__tempObj1", "__tempObj2", "__aln" if strTrue(doAlign): # perform the alignment cmd.create( tObj1, objSel1 ) cmd.create( tObj2, objSel2 ) cmd.super( tObj1, tObj2, object=aln ) cmd.matrix_copy(tObj1, objSel1) else: # perform the alignment cmd.create( tObj1, objSel1 ) cmd.create( tObj2, objSel2 ) cmd.super( tObj1, tObj2, 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=-10") 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 = [], [] # Get the residue identifiers from the alignment object "aln" cmd.iterate(tObj1 + " and n. CA and " + aln, "stored.alnAres.append(resi)") cmd.iterate(tObj2 + " and n. CA and " + aln, "stored.alnBres.append(resi)") # Change the B-factors for EACH object rmsUpdateB(tObj1,stored.alnAres,tObj2,stored.alnBres) # Store the NEW B-factors stored.alnAnb, stored.alnBnb = [], [] cmd.iterate(tObj1 + " and n. CA and " + aln, "stored.alnAnb.append(b)" ) cmd.iterate(tObj2 + " and n. CA and " + aln, "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 for x in range(len(stored.alnAres)): cmd.alter(objSel1 + " and n. CA and i. " + str(stored.alnAres[x]), "b = " + str(stored.alnAnb[x])) for x in range(len(stored.alnBres)): cmd.alter(objSel2 + " and n. CA and i. " + str(stored.alnBres[x]), "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 "\nColorByRMSD completed successfully." print "The MINIMUM RMSD value is: "+str(min(stored.allRMSDval)) print "The MAXIMUM RMSD value is: "+str(max(stored.allRMSDval)) if doPretty!=None: # Showcase what we did cmd.orient() cmd.hide("all") cmd.show_as("cartoon", objSel1 + " or " + objSel2) # Select the residues not used for alignment; they still have their B-factors as "-10" cmd.select("notUsedForAln", "b < 0") # White-wash the residues not used for alignment cmd.color("white", "notUsedForAln") # Color the residues used for alignment according to their B-factors (RMSD values) cmd.spectrum("b", 'rainbow', "((" + objSel1 + " and n. CA) or (n. CA and " + objSel2 +" )) and not notUsedForAln") # 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 below. cmd.delete("notUsedForAln") # cmd.disable("notUsedForAln") print "\nObjects are now colored by C-alpha RMS deviation." print "All residues with RMSD values greater than the maximum are colored white..."