def rmsUpdateB(objA, alnAri, objB, alnBri):
for x in range(len(alnAri)):
s1 = objA + " and n. CA and i. " + alnAri[x]
s2 = objB + " and n. CA and i. " + alnBri[x]
rmsd = cmd.rms_cur(s1, s2, matchmaker=4)
cmd.alter( s1, "b = " + str(rmsd))
cmd.alter( s2, "b = " + str(rmsd))
cmd.sort(objA); cmd.sort(objB)
def rmsUpdateB(objA, alnAri, objB, alnBri):
for x in range(len(alnAri)):
s1 = objA + " and n. CA and i. " + alnAri[x]
s2 = objB + " and n. CA and i. " + alnBri[x]
rmsd = cmd.rms_cur(s1, s2, matchmaker=4)
cmd.alter( s1, "b = " + str(rmsd))
cmd.alter( s2, "b = " + str(rmsd))
cmd.sort(objA); cmd.sort(objB)
def protein_assign_charges_and_radii(obj_name,_self=cmd):
pymol=_self._pymol
cmd=_self
from chempy.champ import assign
# apply a few kludges
# convent Seleno-methionine to methionine
cmd.alter(obj_name+"///MSE/SE","elem='S';name='SD'",quiet=1)
cmd.alter(obj_name+"///MSE/","resn='MET'",quiet=1)
cmd.flag("ignore",obj_name,"clear")
# remove alternate conformers
cmd.remove(obj_name+" and not alt ''+A")
cmd.alter(obj_name,"alt=''")
cmd.sort(obj_name)
cmd.fix_chemistry(obj_name,obj_name,1)
# make sure all atoms are included...
cmd.alter(obj_name,"q=1.0",quiet=1)
print " Util: Fixing termini and assigning formal charges..."
assign.missing_c_termini(obj_name,quiet=1,_self=_self)
while not assign.formal_charges(obj_name,quiet=1,_self=_self):
print " WARNING: unrecognized or incomplete residues are being deleted:"
cmd.iterate("(byres ("+obj_name+" and flag 23)) and flag 31",
'print " "+model+"/"+segi+"/"+chain+"/"+resn+"`"+resi+"/"',quiet=1)
cmd.remove("byres ("+obj_name+" and flag 23)") # get rid of residues that weren't assigned
assign.missing_c_termini(obj_name,quiet=1,_self=_self)
print " Util: Assigning Amber 99 charges and radii..."
cmd.h_add(obj_name)
if not assign.amber99(obj_name,quiet=1,_self=_self):
print " WARNING: some unassigned atoms are being deleted:"
cmd.iterate("byres ("+obj_name+" and flag 23)",
'print " "+model+"/"+segi+"/"+chain+"/"+resn+"`"+resi+"/"+name+"? ["+elem+"]"',quiet=1)
cmd.remove(obj_name+" and flag 23") # get rid of any atoms that weren't assigned
# show the user what the net charges are...
formal = sum_formal_charges(obj_name,quiet=0,_self=_self)
partial = sum_partial_charges(obj_name,quiet=0,_self=_self)
if round(formal)!=round(partial):
print " WARNING: formal and partial charge sums don't match -- there is a problem!"
def do_help(self,args=None):
"""List available commands with "help" or detailed help with "help cmd".
"""
all_names=dir(self)
if args == None:
cmd=[name[3:] for name in all_names if 'do_' in name]
cmd.sort()
print 'More detailed help with "help cmd"'
print 'Available commands:'
print '==================='
print ' '.join(cmd)
else:
cmd=getattr(self,'do_'+args)
print cmd.__doc__
def UIBased(categoryList, cmdList, undo_steps):
os.system('clear') # CLEAR SCREEN
UIBasedHelp()
while True:
userInput = raw_input("Please enter a command: ") # Reading the user input
step_count = len(undo_steps)
os.system('clear') # CLEAR SCREEN
userCommand = cmd.getCommand(userInput) # Extracting the COMMAND from the user input
remainderAfterCommand = cmd.getRemainder(userInput) # Extracting the remainder after the command
files.checkIntegrityOfTheFiles(categoryList) # Checking that the files are in good condition
if userCommand == "exit": # In case the user wants to terminate the program, this allows him to do so
return
elif userCommand == "add":
sum, category = UIAdd(categoryList)
userInput = str(userCommand) + " " + str(sum) + " " + str(category)
print cmd.add(userInput, categoryList, undo_steps, step_count)
elif userCommand == "insert":
day, sum, category = UIInsert(categoryList)
userInput = str(userCommand) + " " + str(day) + " " + str(sum) + " " + str(category)
print cmd.insert(userInput, categoryList, undo_steps, 1, step_count)
elif userCommand == "remove":
userInput = str(userCommand) + " " + UIRemove(categoryList)
print cmd.remove(userInput, categoryList, undo_steps, step_count)
elif userCommand == "list":
userInput = str(userCommand) + " " + UIList(categoryList)
cmd.printFunc(cmd.list(userInput, categoryList))
elif userCommand == "sum":
userInput = str(userCommand) + " " + UISum(categoryList)
print cmd.suma(userInput, categoryList)
elif userCommand == "max":
userInput = str(userCommand) + " " + UIMax()
print cmd.maxi(userInput, categoryList)
elif userCommand == "sort":
userInput = str(userCommand) + " " + UISort(categoryList)
cmd.printFunc(cmd.sort(userInput, categoryList))
elif userCommand == "filter":
userInput = str(userCommand) + " " + UIFilter(categoryList)
print cmd.filter(userInput, categoryList, undo_steps, step_count)
elif userCommand == "undo":
print cmd.undo(userInput, categoryList, undo_steps, step_count)
elif userCommand == "help":
cmd.userHelp(cmdList)
elif userCommand == "clear":
os.system('clear')
else:
print(" '" + userInput + "' not recognized. \"~:help\"")
def displacementUpdateB(objA, alnAri, objB, alnBri):
### If residue is unassigned in one of the pdb files, we reset its value
for x in range(len(alnAri)):
s1 = objA + " and name CA and resi " + alnAri[x]
cmd.alter( s1, "b = " + str(-0.01))
for x in range(len(alnBri)):
s2 = objB + " and name CA and resi " + alnBri[x]
cmd.alter( s2, "b = " + str(-0.01))
cmd.sort(objA); cmd.sort(objB)
for x in range(len(alnAri)):
s1 = objA + " and name CA and resi " + alnAri[x]
s2 = objB + " and name CA and resi " + alnAri[x]
### Names starting with __ (underscores) are normally hidden by PyMOL
tempObject = "__tempObject"
Displacement = cmd.distance(tempObject, s1, s2)
cmd.alter( s1, "b = " + str(Displacement))
cmd.alter( s2, "b = " + str(Displacement))
cmd.delete(tempObject)
cmd.sort(objA); cmd.sort(objB)
def displacementUpdateBAll(objA, alnAri, objB, alnBri):
print "This will take a while to go through the for loops. Give me around 3-5 minutes..."
### If residue is unassigned in one of the pdb files, we reset its value
for x in range(len(alnAri)):
s1 = objA + " and resi " + alnAri[x][0] + " and name " + str(alnAri[x][1])
cmd.alter( s1, "b = " + str(-0.01))
for x in range(len(alnBri)):
s2 = objB + " and resi " + alnBri[x][0] + " and name " + alnBri[x][1]
cmd.alter( s2, "b = " + str(-0.01))
cmd.sort(objA); cmd.sort(objB)
for x in range(len(alnAri)):
s1 = objA + " and resi " + alnAri[x][0] + " and name " + alnAri[x][1]
s2 = objB + " and resi " + alnAri[x][0] + " and name " + alnAri[x][1]
### Names starting with __ (underscores) are normally hidden by PyMOL
tempObject = "__tempObject"
Displacement = cmd.distance(tempObject, s1, s2)
cmd.alter( s1, "b = " + str(Displacement))
cmd.alter( s2, "b = " + str(Displacement))
cmd.delete(tempObject)
cmd.sort(objA); cmd.sort(objB)
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..."
