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..."
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..."