def testSaveRef(self, format):
# for rms_cur (not all formats save all identifiers)
m = -1
cmd.set('retain_order')
cmd.fragment('ala', 'm1')
cmd.copy('m2', 'm1')
cmd.copy('m3', 'm1')
cmd.rotate('y', 90, 'm2')
cmd.align('m3', 'm2')
# with ref=m3
with testing.mktemp('.' + format) as filename:
cmd.save(filename, 'm2', ref='m3')
cmd.load(filename, 'm4')
self.assertAlmostEqual(cmd.rms_cur('m4', 'm1', matchmaker=m), 0.00, delta=1e-2)
self.assertAlmostEqual(cmd.rms_cur('m4', 'm2', matchmaker=m), 1.87, delta=1e-2)
# without ref
with testing.mktemp('.' + format) as filename:
cmd.save(filename, 'm2')
cmd.load(filename, 'm5')
self.assertAlmostEqual(cmd.rms_cur('m5', 'm2', matchmaker=m), 0.00, delta=1e-2)
self.assertAlmostEqual(cmd.rms_cur('m5', 'm1', matchmaker=m), 1.87, delta=1e-2)
def testSaveRef(self, format):
# for rms_cur (not all formats save all identifiers)
m = -1
cmd.set('retain_order')
cmd.fragment('ala', 'm1')
cmd.copy('m2', 'm1')
cmd.copy('m3', 'm1')
cmd.rotate('y', 90, 'm2')
cmd.align('m3', 'm2')
# with ref=m3
with testing.mktemp('.' + format) as filename:
cmd.save(filename, 'm2', ref='m3')
cmd.load(filename, 'm4')
self.assertAlmostEqual(cmd.rms_cur('m4', 'm1', matchmaker=m), 0.00, delta=1e-2)
self.assertAlmostEqual(cmd.rms_cur('m4', 'm2', matchmaker=m), 1.87, delta=1e-2)
# without ref
with testing.mktemp('.' + format) as filename:
cmd.save(filename, 'm2')
cmd.load(filename, 'm5')
self.assertAlmostEqual(cmd.rms_cur('m5', 'm2', matchmaker=m), 0.00, delta=1e-2)
self.assertAlmostEqual(cmd.rms_cur('m5', 'm1', matchmaker=m), 1.87, delta=1e-2)
def getRMSD(motifName, queryPDBCode, motifPDBCode):
#querySubsetName = 'match_in_{0}'.format(queryPDBCode)
querySubsetName = 'match_in_%s'%(queryPDBCode)
cmd.select(querySubsetName, motifName)
cmd.hide('everything', 'all')
cmd.fetch(motifPDBCode, async=0, path=glb.FETCH_PATH)
#motifSubsetName = 'match_in_{0}'.format(motifPDBCode)
motifSubsetName = 'match_in_%s'%(motifPDBCode)
cmd.select(motifSubsetName, '%s and (%s)' % (motifPDBCode,
glb.MOTIFS[motifName]['loci']))
cmd.hide('everything', 'all')
#aligns and gets the rmsd of the alignment by all atoms
dataAll = cmd.align(motifSubsetName, querySubsetName)
#aligns and gets the rmsd of the alignment by C alpha atoms
cmd.select(querySubsetName, motifName+" and name ca")
cmd.select(motifSubsetName, '%s and (%s) and name %s' % (motifPDBCode,
glb.MOTIFS[motifName]['loci'], "ca"))
dataAlpha = cmd.align(motifSubsetName, querySubsetName)
#aligns and gets the rmsd of the alignment by C alpha and C beta atoms
cmd.select(querySubsetName, motifName+" and name ca,cb")
cmd.select(motifSubsetName, '%s and (%s) and name %s' % (motifPDBCode,
glb.MOTIFS[motifName]['loci'], "ca,cb"))
dataAlphaBeta = cmd.align(motifSubsetName, querySubsetName)
rmsds = []
rmsds.append(dataAll[0])
rmsds.append(dataAlpha[0])
rmsds.append(dataAlphaBeta[0])
cmd.delete(motifName)
return rmsds
def test(self, matrix_mode):
cmd.viewport(100, 100)
cmd.set('matrix_mode', matrix_mode)
cmd.set('ambient', 1.0)
cmd.read_pdbstr(v_pdbstr_anisou, 'm1', zoom=0)
cmd.read_pdbstr(v_pdbstr_rotated, 'm2', zoom=0)
self._rep()
cmd.set_view(views[0])
ref = self.get_imagearray()
self.assertImageHasColor('yellow')
cmd.align('m1', 'm2')
cmd.set_view(views[1])
self.assertImageEqual(ref,
count=100,
delta=1,
msg='ANISOU not aligned on display')
pdbstr = cmd.get_pdbstr('m1')
cmd.delete('*')
cmd.read_pdbstr(pdbstr, 'm1', zoom=0)
self._rep()
self.assertImageEqual(ref, count=100, msg='ANISOU not aligned in PDB')
def sewalign(first,second):
#hide waters
cmd.hide("(solvent and (all))")
#hide hydrogens
cmd.hide( 'sticks', 'elem H' )
cmd.hide( 'lines', 'elem H' )
#show cartoon
cmd.show("cartoon" ,"all")
#create duplicate of first
first_copy = first + "_copy"
cmd.copy(first_copy, first)
#select first 14 residues
cmd.select('node_9_selection', '(obj *_9_* and resi 1-14)')
cmd.select('node_12_selection', '(obj *_12_* and resi 1-14)')
cmd.select('node_15_selection', '(obj *_15_* and resi 1-14)')
alignment_1 = cmd.align(first, 'node_9_selection')
print alignment_1[0]
alignment_2 = cmd.align(second, 'node_12_selection')
print alignment_2[0]
alignment_3 = cmd.align(first_copy, 'node_15_selection')
print alignment_3[0]
def revert(self):
v = cmd.get_view()
cmd.remove(self.rdes.obj+" and not chain A")
m = cmd.get_model(self.rdes.obj)
n = self.oldcrd
if not n:
cmd.create("tmp12345",self.rnat.sel())
cmd.align("tmp12345",self.rdes.sel())
n = cmd.get_model("tmp12345").atom
cmd.delete("tmp12345")
di,ni = 0,0
while m.atom[di].resi != str(self.rdes.resi): di += 1
dj = di
while m.atom[dj].resi == str(self.rdes.resi): dj += 1
if self.oldcrd: self.oldcrd = None
else: self.oldcrd = m.atom[di:dj]
m.atom = m.atom[:di] + n + m.atom[dj:]
for i in range(di,di+len(n)):
m.atom[i].resi = str(self.rdes.resi)
m.atom[i].chain = str(self.rdes.chain)
cmd.load_model(m,self.rdes.obj,1)
cmd.save("tmp.pdb",self.rdes.obj)
cmd.delete(self.rdes.obj)
cmd.load("tmp.pdb",self.rdes.obj,1)
cmd.show('car',self.rdes.obj)
cmd.show('lines')
redopent(self.rdes.obj)
cmd.set_view(v)
print "revert removing "+"".join(self.aas)+" from aas!"
self.aas = [getaa('A',self.rdes.resi,self.manager.d.obj)]
def loadpair(file):
id = file.split('/')[-1][:4]
loadcenters(file,id+'nat')
loadcenters(file[:-17]+'_decoy_sasa_centers.pdb',id+'decoy')
d = id+'decoy'
n = id+'nat'
cmd.align(n,d)
def align_all(target=None,
mobile_selection='name ca',
target_selection='name ca',
cutoff=2,
cycles=5,
cgo_object=0):
"""
Aligns all models in a list to one target
usage:
align_all [target][target_selection=name ca][mobile_selection=name ca][cutoff=2][cycles=5][cgo_object=0]
where target specifies the model id you want to align all others against,
and target_selection, mobile_selection, cutoff and cycles are options
passed to the align command.
By default the selection is all C-alpha atoms and the cutoff is 2 and the
number of cycles is 5.
Setting cgo_object to 1, will cause the generation of an alignment object for
each object. They will be named like <object>_on_<target>, where <object> and
<target> will be replaced by the real object and target names.
Example:
align_all target=name1, mobile_selection=c. b & n. n+ca+c+o,target_selection=c. a & n. n+ca+c+o
"""
cutoff = int(cutoff)
cycles = int(cycles)
cgo_object = int(cgo_object)
object_list = cmd.get_names()
object_list.remove(target)
rmsd = {}
rmsd_list = []
for i in range(len(object_list)):
if cgo_object:
objectname = 'align_%s_on_%s' % (object_list[i], target)
rms = cmd.align('%s & %s' % (object_list[i], mobile_selection),
'%s & %s' % (target, target_selection),
cutoff=cutoff,
cycles=cycles,
object=objectname)
else:
rms = cmd.align('%s & %s' % (object_list[i], mobile_selection),
'%s & %s' % (target, target_selection),
cutoff=cutoff,
cycles=cycles)
rmsd[object_list[i]] = rms[0]
rmsd_list.append((rms[0], object_list[i]))
rmsd_list.sort()
# loop over dictionary and print out matrix of final rms values
print "Aligning against:", target
for object_name in object_list:
print "%s: %6.3f" % (object_name, rmsd[object_name])
for r in rmsd_list:
print "%6.3f %s" % r
def ligands_where_are_you(pdb, align_to, in_dir, out_dir):
# load the pdb and align to reference 1AQL
pdbe = join(in_dir, pdb + ".pdb")
cmd.load(r"{}".format(pdbe),"{}".format(pdb))
#cmd.align("""{} and chain A""".format(pdb), """{} and chain A""".format(align_to))
cmd.align(pdb, align_to)
cmd.save((os.path.join(out_dir,pdb + ".pdb")), pdb)
cmd.delete(pdb)
def align_chain(ref, query, chain, out):
pymol.finish_launching()
cmd.delete('all')
cmd.load(ref)
cmd.load(query)
ref_name = ref.split('/')[-1].split('.')[0]
query_name = query.split('/')[-1].split('.')[0]
cmd.align(query_name + ' and chain ' + chain, ref_name + ' and chain ' + chain)
cmd.save(out, query_name)
def mican(mobile, target, option=""):
'''
DESCRIPTION
Align two (ligand) selections based on mican algorithm.
ARGUMENTS
mobile = str: atom selection of mobile object
target = str: atom selection of target object
EXAMPLE
fetch 3zcf 4n8t, bsync=0
mcsalign /3zcf//A/HEC, /4n8t//A/HEM
zoom /4n8t//A/HEM, animate=2, buffer=3
'''
import subprocess
import tempfile
import os
with tempfile.TemporaryDirectory() as dname:
# print tmp dir name
print("Temporary directory =" + dname)
# make sure you have mican in PATH
# directly giving 'execute' full path below is good alternative
# For example : execute = "/usr/bin/mican"
execute = "mican"
tmptarget = dname + "/target.pdb"
tmpmobile = dname + "/mobile.pdb"
tmpout = dname + "/aligned.pdb"
# save pdb for mican
cmd.save(tmptarget, target)
cmd.save(tmpmobile, mobile)
modeoption = "-" + option
option2 = "-o"
outfile = tmpout
mican = [execute, tmpmobile, tmptarget, option2, outfile]
for op in option.split():
if(op == "-o"):
print("option -o is reserved")
raise CmdException
mican.append(op)
proc=subprocess.run(mican,stdout = subprocess.PIPE)
print(proc.stdout.decode("utf8")) # print result to pymol console
cmd.load(outfile, "aligned")
cmd.split_states("aligned")
cmd.select("mobileback",mobile + " and backbone")
cmd.align("mobileback", "aligned_0001 and backbone")
# use cmd pair_fit if you think align is not good
# print("Using cmd.align instead of cmd.pair_fit")
# pymol.cmd.pair_fit("mobileback", "aligned_0001 and backbone")
cmd.delete("mobileback")
cmd.delete("aligned")
cmd.delete("aligned_0001")
cmd.delete("aligned_0002")
def align_and_color(moving, fixed, maximum=None, native_color="blue"):
if maximum == "0":
maximum = None
alignment_name = "alignment_" + moving
cmd.align(moving, fixed, object=alignment_name, cycles=0)
cmd.disable(alignment_name)
rmsd_b(moving + " & " + alignment_name, fixed + " & " + alignment_name)
cmd.color(native_color, fixed)
cmd.spectrum("b", "green_red", moving, 0, maximum)
def align_and_color(moving, fixed, maximum=None, native_color="blue"):
if maximum == "0":
maximum = None
alignment_name = "alignment_" + moving
cmd.align(moving, fixed, object=alignment_name, cycles=0)
cmd.disable(alignment_name)
rmsd_b(moving + " & " + alignment_name, fixed + " & " + alignment_name)
cmd.color(native_color, fixed)
cmd.spectrum("b", "green_red", moving, 0, maximum)
def Mutagenesis(kinase1, model, template,peptide_instance):
"""superposition the model and template, remove template and leave peptide behind """
"""replace peptide with instance peptide"""
list_name = peptide_instance
with open(input_data_folder+list_name,'r') as f:
instances = f.readlines()
instance = [x.strip() for x in instances]
print "your peptide: ", instance
for pep in instance:
cmd.delete('all')
cmd.fetch(model) # model_candidate, ex.chk1,chk2...
cmd.remove("hetatm") #remove the nonstandard residues
cmd.fetch(template) #mutagenesis template, ex.2phk
peptide_template = cmd.get_fastastr( "/"+template+'//B') #get the peptide from the template and generate another one for mutagenesis
peptide_template = peptide_template + 'G' #peptide of 2phk is 7 amino acid long, when our input peptide is 8 aa, we need to plus one character
for aa in peptide_template[6:].lower(): #creat template_peptide for mutagenesis
cmd._alt(aa)
firstaa = AAcode_1_to_3(peptide_template[6]) #translate template_peptide to 3 letter
low_firstaa = firstaa[0].lower()
cmd.alter(low_firstaa, 'chain = "B"') #select this template_peptide
cmd.show_as("cartoon")
cmd.align(model, template) #superpostion of model and template
cmd.align(low_firstaa,template) #superpostion of template_peptide and template
remove_part = "("+template+" and not resn ATP"+")"
cmd.select("remove_part",remove_part)
cmd.remove("remove_part") #remove the template except for ATP, there are only model and template_peptide
cmd.remove("resn hoh") #remove water
cmd.wizard("mutagenesis")
peptide_position = 0
for i in pep:
#the peptide_position starting point depends the first position of mutagenesis peptide
#pymol's peptide start from 1, not 0
mutagenesis_template = '/'+low_firstaa+ '///' + str(peptide_position + 2) # because of 2phk start at 2nd of peptide
#mutagenesis_template = '/' + template + '//B/' + str(peptide_position + 2)
cmd.get_wizard().do_select(mutagenesis_template) # select peptide position of mutation
replace_aminoacid = AAcode_1_to_3(pep)[peptide_position]
cmd.get_wizard().set_mode(replace_aminoacid) # select which residue want to mutate to
cmd.get_wizard().apply()
peptide_position += 1
filename = kinase1 + '_' + model + 'model_' + template + 'muta_' + pep + '.pdb' #build the canonical name
cmd.save(filename)
ATPchange(filename) #change ATP naming to the format of ATP.params
cmd.wizard(None)
return
def testSaveAln(self):
cmd.fab('ACDEFGH', 'm1')
cmd.fab('ACDFGH', 'm2')
cmd.align('m1', 'm2', cycles=0, object='aln')
with testing.mktemp('.aln') as filename:
cmd.save(filename)
with open(filename) as handle:
lines = list(handle)
self.assertEqual(lines[0].split(), ['CLUSTAL'])
self.assertEqual(lines[1].split(), [])
self.assertEqual(lines[2].split(), ['m1', 'ACDEFGH'])
self.assertEqual(lines[3].split(), ['m2', 'ACD-FGH'])
def testSaveAln(self):
cmd.fab('ACDEFGH', 'm1')
cmd.fab('ACDFGH', 'm2')
cmd.align('m1', 'm2', cycles=0, object='aln')
with testing.mktemp('.aln') as filename:
cmd.save(filename)
with open(filename) as handle:
lines = list(handle)
self.assertEqual(lines[0].split(), ['CLUSTAL'])
self.assertEqual(lines[1].split(), [])
self.assertEqual(lines[2].split(), ['m1', 'ACDEFGH'])
self.assertEqual(lines[3].split(), ['m2', 'ACD-FGH'])
def focus(self):
self.manager.m = self
if self.manager.prevm: cmd.hide('sticks',self.manager.prevm.rdes.sel())
if self.manager.prevm: cmd.color('green',self.manager.prevm.rdes.sel()+" and elem C")
fr = self.rnat.obj+" and name n+ca+c and resi %i-%i"%(self.rnat.resi-10,self.rnat.resi+10)
to = self.rdes.obj+" and name n+ca+c and resi %i-%i"%(self.rdes.resi-10,self.rdes.resi+10)
cmd.align(fr,to)
cmd.show('sticks',self.rdes.sel())
cmd.color('white',self.rdes.sel()+" and elem C")
cmd.center(self.rdes.sel())
v = list(cmd.get_view())
v[11] = -80.0
cmd.set_view(tuple(v))
cmd.clip('slab',50,self.rdes.sel())
def loadPackingPDB(file,name=None,native=None):
"""
usage: loadPackingPDB <file> , [<name for object>]
loads a foo_packing.pdb file and colors it all pretty-like
creates two selections along with the loaded object called
NAMEcavities and NAMEprotein which are the heteratoms representing
holes and everything else, respectively. Names can get pretty long,
by pymol lets you do good stuff like "select NA*cav*", which will
match a selection called NAMEISREALLYLONGcavities.
"""
if name is None:
name = name = os.path.basename(file)
if name.endswith('.gz'):
name = name[:-3]
if name.endswith('.pdb'):
name = name[:-4]
if name.endswith('.'):
name = name[:-1]
if name.endswith("_packing"):
name = name[:-8]
zload(file,name)
cmd.hide('everything',name)
if native is not None:
cmd.align(name,native)
cmd.zoom(native)
useRosettaRadii()
cavselname = name+"cavities"
protselname = name+"protein"
cmd.select(cavselname, "resn CAV and b > 0.1 and %s"%(name) )
cmd.select(protselname,"(not resn CAV) and %s"%(name) )
useTempRadii(cavselname)
useOccColors(cavselname)
cmd.color("white",protselname)
cmd.show('spheres', cavselname )
cmd.show("cartoon",protselname)
cmd.show("lines",protselname)
cmd.select("none")
cmd.delete("sele*")
cmd.move('z',-50)
return name
def showpack(self):
print self.toggle['sph']
#cmd.hide('spheres','not '+self.manager.d.bupsel)
cmd.hide('spheres')
if self.toggle['sph']:
self.toggle['sph'] = False
return
fr = self.rnat.obj+" and name n+ca+c and resi %i-%i"%(self.rnat.resi-10,self.rnat.resi+10)
to = self.rdes.obj+" and name n+ca+c and resi %i-%i"%(self.rdes.resi-10,self.rdes.resi+10)
cmd.align(fr,to)
cmd.center(self.rdes.sel()+" or "+self.rnat.sel())
#cmd.show('sticks',self.rnat.sel())
cmd.show('spheres',"byres ((not "+self.rnat.obj+") within 6 of "+self.rdes.sel()+")")
self.toggle['sph'] = True
def loadPackingPDB(file, name=None, native=None):
"""
usage: loadPackingPDB <file> , [<name for object>]
loads a foo_packing.pdb file and colors it all pretty-like
creates two selections along with the loaded object called
NAMEcavities and NAMEprotein which are the heteratoms representing
holes and everything else, respectively. Names can get pretty long,
by pymol lets you do good stuff like "select NA*cav*", which will
match a selection called NAMEISREALLYLONGcavities.
"""
if name is None:
name = name = os.path.basename(file)
if name.endswith('.gz'):
name = name[:-3]
if name.endswith('.pdb'):
name = name[:-4]
if name.endswith('.'):
name = name[:-1]
if name.endswith("_packing"):
name = name[:-8]
zload(file, name)
cmd.hide('everything', name)
if native is not None:
cmd.align(name, native)
cmd.zoom(native)
useRosettaRadii()
cavselname = name + "cavities"
protselname = name + "protein"
cmd.select(cavselname, "resn WSS and %s" % (name))
cmd.select(protselname, "(not resn WSS) and %s" % (name))
useTempRadii(cavselname)
useOccColors(cavselname)
cmd.color("white", protselname)
cmd.show('spheres', cavselname)
cmd.show("cartoon", protselname)
cmd.show("lines", protselname)
cmd.select("none")
cmd.delete("sele*")
cmd.move('z', -50)
return name
def testAlignMissingCoords(self):
filename = self.datafile('1t46-frag.pdb')
cmd.load(filename, 'm1')
cmd.remove('m1 & resi 600-605')
cmd.load(filename, 'm1', state=2)
cmd.load(filename, 'm2')
cmd.remove('m2 & resi 620-625')
cmd.load(filename, 'm2', state=2)
cmd.align('m1', 'm2', object='aln', mobile_state=1, target_state=1, cycles=0)
self.assertIn('aln', cmd.get_names())
def testGetRawAlignment(self):
from collections import defaultdict
cmd.fab('ACDEGGKLMN', 'm1')
cmd.fab('CDEFFGGK', 'm2')
cmd.fab('ASDEKLMNFY', 'm3')
cmd.align('m2 & guide', 'm1 & guide', cycles=0, object='aln')
cmd.align('m3 & guide', 'm1 & guide', cycles=0, object='aln')
cmd.disable('m2')
# expecting alignment:
# m1 ACDE--GGKLMN--
# m2 -CDEFFGGK-----
# m3 ASDE----KLMQFY
guideids = defaultdict(list)
cmd.iterate('guide', 'guideids[model].append(index)', space=locals())
idx = lambda m, i: (m, guideids[m][i])
aln_expect = [
[idx('m1', 0), idx('m3', 0)],
[idx('m1', 1), idx('m2', 0),
idx('m3', 1)],
[idx('m1', 2), idx('m2', 1),
idx('m3', 2)],
[idx('m1', 3), idx('m2', 2),
idx('m3', 3)],
[
idx('m1', 4),
idx('m2', 5),
],
[
idx('m1', 5),
idx('m2', 6),
],
[idx('m1', 6), idx('m2', 7),
idx('m3', 4)],
[idx('m1', 7), idx('m3', 5)],
[idx('m1', 8), idx('m3', 6)],
[idx('m1', 9), idx('m3', 7)],
]
dictify = lambda aln: [dict(col) for col in aln]
aln_expect = dictify(aln_expect)
aln = cmd.get_raw_alignment('aln', 0)
self.assertEqual(dictify(aln), aln_expect)
# remove m2 from alignment
for d in aln_expect:
d.pop('m2', None)
aln = cmd.get_raw_alignment('aln', 1)
self.assertEqual(dictify(aln), aln_expect)
def ie_build_file(fname, align='true', ortho='true', hide='true',
zoom='true', col='[0.5, 0.5, 0.5]', scale='1'):
if to_bool(ortho):
cmd.set('orthoscopic', 'true')
cmd.load(fname)
if to_bool(align):
object_list = cmd.get_names()
target = object_list.pop()
for obj in object_list:
cmd.align(obj, target)
if to_bool(hide):
cmd.hide('everything')
ie_build_all(col, scale)
if to_bool(zoom):
cmd.zoom()
def prepare_data(arg1):
cmd.load("%s_r_b.pdb" % arg1, zoom=0)
cmd.load("%s_l_b.pdb" % arg1, zoom=0)
cmd.load("%s_r_u.pdb" % arg1, zoom=0)
cmd.load("%s_l_u.pdb" % arg1, zoom=0)
save_surface("%s_r_b" % arg1)
save_surface("%s_l_b" % arg1)
save_surface("%s_r_u" % arg1)
save_surface("%s_l_u" % arg1)
cmd.align("%s_r_b" % arg1, "%s_r_u" % arg1, object="ra")
cmd.align("%s_l_b" % arg1, "%s_l_u" % arg1, object="la")
cmd.save("receptor.aln", "ra")
cmd.save("ligand.aln", "la")
def testSaveAlnNucleic(self):
cmd.load(self.datafile('1rna.cif'))
cmd.create('m1', 'chain A and not resi 6-7')
cmd.create('m2', 'chain B')
cmd.alter('m1 and resi 1', 'resn = "DT"') # mimic DNA
cmd.alter('m2 and resi 20', 'resn = "UNK"') # mimic nonstd residue
cmd.align('m1', 'm2', cycles=0, object='aln')
with testing.mktemp('.aln') as filename:
cmd.save(filename)
with open(filename) as handle:
lines = list(handle)
self.assertEqual(lines[0].split(), ['CLUSTAL'])
self.assertEqual(lines[1].split(), [])
self.assertEqual(lines[2].split(), ['m1', 'TUAUA--UAUAUAA'])
self.assertEqual(lines[3].split(), ['m2', 'UUAUA?AUAUAUAA'])
def testSaveAlnNucleic(self):
cmd.load(self.datafile('1rna.cif'))
cmd.create('m1', 'chain A and not resi 6-7')
cmd.create('m2', 'chain B')
cmd.alter('m1 and resi 1', 'resn = "DT"') # mimic DNA
cmd.alter('m2 and resi 20', 'resn = "UNK"') # mimic nonstd residue
cmd.align('m1', 'm2', cycles=0, object='aln')
with testing.mktemp('.aln') as filename:
cmd.save(filename)
with open(filename) as handle:
lines = list(handle)
self.assertEqual(lines[0].split(), ['CLUSTAL'])
self.assertEqual(lines[1].split(), [])
self.assertEqual(lines[2].split(), ['m1', 'TUAUA--UAUAUAA'])
self.assertEqual(lines[3].split(), ['m2', 'UUAUA?AUAUAUAA'])
def return_aligned_res():
cmd.align("thermo", "meso", object='aln')
raw_aln = cmd.get_raw_alignment('aln')
idx2resi = {}
cmd.iterate('aln',
'idx2resi[model, index] = resi',
space={'idx2resi': idx2resi})
raw_res = []
for idx1, idx2 in raw_aln:
raw_res.append((idx2resi[idx1], idx2resi[idx2]))
aligned_res = []
for (a, b) in raw_res:
if (a, b) not in aligned_res:
aligned_res.append((a, b))
return aligned_res
def alignallrms(sele):
r = {}
for i in cmd.get_object_list():
r[i] = cmd.align("fr52re", i)[0]
for k, v in r.items():
if v < 2:
print k, v
def sa(intra=False, rainbow=True):
"""
Superimpose all open models onto the first one.
This may not work well with selections.
Option intra can be set to True to enable intra_fit first, for working with multi-state (nmr) pdbs.
[Thanks to Kyle Beauchamp for this one]
"""
AllObj = cmd.get_names("all")
for x in AllObj:
print(AllObj[0], x)
if intra == True:
cmd.intra_fit(x)
if rainbow == True:
cmd.util.chainbow(x)
cmd.align(x, AllObj[0])
cmd.zoom()
def sa(intra=False,rainbow=True):
"""
Superimpose all open models onto the first one.
This may not work well with selections.
Option intra can be set to True to enable intra_fit first, for working with multi-state (nmr) pdbs.
[Thanks to Kyle Beauchamp for this one]
"""
AllObj=cmd.get_names("all")
for x in AllObj:
print(AllObj[0],x)
if intra==True:
cmd.intra_fit(x)
if rainbow==True:
cmd.util.chainbow(x)
cmd.align(x,AllObj[0])
cmd.zoom()
def drawAnnote(self, axis, x, y, annote):
if (x, y) in self.drawnAnnotations:
markers = self.drawnAnnotations[(x, y)]
for m in markers:
m.set_visible(not m.get_visible())
self.axis.figure.canvas.draw()
else:
"""
Mark data point and show data
"""
t = axis.text(
x,
y,
"(%3.2f, %3.2f) - %s" % (x, y, annote),
)
m = axis.scatter([x], [y], marker='d', c='r', zorder=100)
self.drawnAnnotations[(x, y)] = (t, m)
self.axis.figure.canvas.draw()
# hide previous structures and load decoy
# since native was loaded already, colour is always different
cmd.hide("all")
cmd.load(self.native_name + '/' + annote + '.pdb')
# show, align, and zoom
cmd.show("cartoon", self.native_name + ", " + annote)
result = cmd.align(self.native_name, annote)
cmd.zoom(self.native_name)
print("Align of {} and {}, rmsd: {}".format(self.native_name, annote,
result[0]))
def align_all( subset = [] ):
"""
Superimpose all open models onto the first one.
This may not work well with selections.
"""
print """This returns a list with 7 items:
RMSD after refinement
Number of aligned atoms after refinement
Number of refinement cycles
RMSD before refinement
Number of aligned atoms before refinement
Raw alignment score
Number of residues aligned """
AllObj=cmd.get_names("all")
for x in AllObj[1:]:
#print(AllObj[0],x)
subset_tag = ''
if isinstance( subset, int ):
subset_tag = ' and resi %d' % subset
elif isinstance( subset, list ) and len( subset ) > 0:
subset_tag = ' and resi %d' % (subset[0])
for m in range( 1,len(subset)): subset_tag += '+%d' % subset[m]
elif isinstance( subset, str ) and len( subset ) > 0:
subset_tag = ' and %s' % subset
values = cmd.align(x+subset_tag,AllObj[0]+subset_tag)
print AllObj[0], x, ' '.join([str(v) for v in values]), '-- RMSD', values[3], ' of ', values[6], 'residues'
cmd.zoom()
def align_all( subset = [] ):
"""
Superimpose all open models onto the first one.
This may not work well with selections.
This function is probably taken from https://daslab.stanford.edu/site_data/docs_pymol_rhiju.pdf
"""
print("""This returns a list with 7 items:
RMSD after refinement
Number of aligned atoms after refinement
Number of refinement cycles
RMSD before refinement
Number of aligned atoms before refinement
Raw alignment score
Number of residues aligned """)
AllObj=cmd.get_names("all")
for x in AllObj[1:]:
#print(AllObj[0],x)
subset_tag = ''
if isinstance( subset, int ):
subset_tag = ' and resi %d' % subset
elif isinstance( subset, list ) and len( subset ) > 0:
subset_tag = ' and resi %d' % (subset[0])
for m in range( 1,len(subset)): subset_tag += '+%d' % subset[m]
elif isinstance( subset, str ) and len( subset ) > 0:
subset_tag = ' and %s' % subset
values = cmd.align(x+subset_tag,AllObj[0]+subset_tag)
print(AllObj[0], x, ' '.join([str(v) for v in values]), '-- RMSD', values[3], ' of ', values[6], 'residues')
cmd.zoom()
def load(self):
self.manager.d = self
self.manager.m = None
self.manager.m = None # to also set prevm = None
# cmd.delete(self.manager.prevd.obj)
# cmd.delete(self.manager.prevd.pid)
# print self.manager.d.obj
# print self.manager.prevd.obj
# sys.exit()
cmd.delete("all")
cmd.load(self.getloadname(),self.obj,1)
cmd.remove(self.obj+" and not chain A")
cmd.fetch(self.pid)
cmd.remove("het or hydro")
cmd.color('gray',self.pid+' and elem C')
self.scores['rms'] = cmd.align(self.pid,self.obj+" and chain A")[0]
cmd.hide('ev')
cmd.show('lines')
cmd.show("car")
#cmd.disable(self.pid)
redopent(self.obj)
self.recalc_design_pos()
self.read_data_dir('avg_deg')
self.read_data_dir('ddG')
self.read_data_dir('rot_boltz')
self.read_bup()
self.read_tot_scores()
self.read_res_scores()
cmd.orient(self.obj+" or pnt*")
self.manager.m = self.remembermm
if self.manager.m: self.manager.m.focus()
if self.remembermv: cmd.set_view(self.remembermv)
def align_all(subset=[]):
"""
Superimpose all open models onto the first one.
This may not work well with selections.
This function is taken from rnapdbtool(:P) and before the function is probably taken form: https://daslab.stanford.edu/site_data/docs_pymol_rhiju.pdf
"""
print("""This returns a list with 7 items:
RMSD after refinement
Number of aligned atoms after refinement
Number of refinement cycles
RMSD before refinement
Number of aligned atoms before refinement
Raw alignment score
Number of residues aligned """)
AllObj = cmd.get_names("all")
for x in AllObj[1:]:
#print(AllObj[0],x)
subset_tag = ''
if isinstance(subset, int):
subset_tag = ' and resi %d' % subset
elif isinstance(subset, list) and len(subset) > 0:
subset_tag = ' and resi %d' % (subset[0])
for m in range(1, len(subset)):
subset_tag += '+%d' % subset[m]
elif isinstance(subset, str) and len(subset) > 0:
subset_tag = ' and %s' % subset
values = cmd.align(x + subset_tag, AllObj[0] + subset_tag)
print(AllObj[0], x, ' '.join([str(v) for v in values]), '-- RMSD',
values[3], ' of ', values[6], 'residues')
cmd.zoom()
def getnative():
v = cmd.get_view()
nats = []
for obj in cmd.get_object_list():
if len(obj) == 4:
nats.append(obj)
continue
pid = obj[:4]
if pid in nats:
continue
print "fetching native", pid
cmd.fetch(pid)
cmd.remove(pid + " and not chain A")
cmd.remove(pid + " and resn HOH")
cmd.align(pid, obj)
cmd.set_view(v)
def align_all(target=None,mobile_selection='name ca',target_selection='name ca',cutoff=2, cycles=5,cgo_object=0):
"""
Aligns all models in a list to one target
usage:
align_all [target][target_selection=name ca][mobile_selection=name ca][cutoff=2][cycles=5][cgo_object=0]
where target specifies the model id you want to align all others against,
and target_selection, mobile_selection, cutoff and cycles are options
passed to the align command.
By default the selection is all C-alpha atoms and the cutoff is 2 and the
number of cycles is 5.
Setting cgo_object to 1, will cause the generation of an alignment object for
each object. They will be named like <object>_on_<target>, where <object> and
<target> will be replaced by the real object and target names.
Example:
align_all target=name1, mobile_selection=c. b & n. n+ca+c+o,target_selection=c. a & n. n+ca+c+o
"""
cutoff = int(cutoff)
cycles = int(cycles)
cgo_object = int(cgo_object)
object_list = cmd.get_names()
object_list.remove(target)
rmsd = {}
rmsd_list = []
for i in range(len(object_list)):
if cgo_object:
objectname = 'align_%s_on_%s' % (object_list[i],target)
rms = cmd.align('%s & %s'%(object_list[i],mobile_selection),'%s & %s'%(target,target_selection),cutoff=cutoff,cycles=cycles,object=objectname)
else:
rms = cmd.align('%s & %s'%(object_list[i],mobile_selection),'%s & %s'%(target,target_selection),cutoff=cutoff,cycles=cycles)
rmsd[object_list[i]] = rms[0]
rmsd_list.append((rms[0],object_list[i]))
rmsd_list.sort()
# loop over dictionary and print out matrix of final rms values
print "Aligning against:",target
for object_name in object_list:
print "%s: %6.3f" % (object_name,rmsd[object_name])
for r in rmsd_list:
print "%6.3f %s" % r
def bssa(
sel1,
sel2,
polymer1="polymer",
polymer2="polymer",
radius=4,
method="overlap",
verbose=1,
):
"""
Bind site similarity analysis.
Align the sequence of both selections and compute similarity
coefficients between two sites.
OPTIONS
sel1 Selection or object 1.
sel2 Selection or object 2.
polymer1 protein of sel1.
polymer2 protein of sel2.
radius Radius to look for nearby aminoacids.
method 'overlap' or 'sorensen–dice'
EXAMPLES
bssa *CS.000_*, *CS.002_*, radius=4
bssa *D.001*, *D.002*, polymer1='obj1', polymer2='obj2'
bssa 6y84.Bs.001, 6y84.B.004, method=sorensen-dice
"""
sel1 = f"(polymer and ({polymer1})) within {radius} of ({sel1})"
sel2 = f"(polymer and ({polymer2})) within {radius} of ({sel2})"
pm.align(sel1, sel2, object='aln')
n1 = pm.count_atoms(sel1)
n2 = pm.count_atoms(sel2)
inter = len(pm.get_raw_alignment('aln'))
pm.delete('aln')
if method == "overlap":
coef = inter / min(n1, n2)
elif method == "sorensen-dice":
coef = 2 * inter / (n1 + n2)
else:
raise Exception("Not supported method.")
if verbose:
print("Similarity coefficient =", coef)
return coef
def superpose_in_pymol(self,
mobile_selection,
fixed_selection,
save_superposed_structure=True,
output_directory=None):
"""
Superpose 'mobile' to 'fixed' in PyMOL.
"""
if not output_directory:
output_directory = self.pymod.structures_dirpath
if hasattr(cmd, "super"): # 'super' is sequence-independent.
cmd.super(mobile_selection, fixed_selection)
else: # PyMOL 0.99 does not have 'cmd.super'.
cmd.align(mobile_selection, fixed_selection)
if save_superposed_structure:
cmd.save(os.path.join(output_directory, mobile_selection + ".pdb"),
mobile_selection)
def redoA(sel="not sub", N=None):
cmd.delete("sub*")
cmd.hide("ev", sel + " and not chain A")
v = cmd.get_view()
chains = list(set(a.chain for a in cmd.get_model("name ca").atom))
chains.sort()
if N:
chains = chains[:N]
for c in chains:
if c == "A":
continue
cmd.create("sub" + c, sel + " and chain A")
cmd.align("sub" + c, sel + " and chain " + c)
cmd.alter("sub" + c, "chain = '%s'" % c)
color_by_chain()
cmd.set_view(v)
print charge(sel + " and chain A")
def align_all(cycles=5, filename="_rmsd_.csv"):
"""
Args:
cycles (int): maximum number of outlier rejection cycles {default: 5}
Returns:
Prints a table of ref vs models with 7 items:
RaR RMSD after refinement
#AA Number of aligned atoms after refinement
CoR Number of refinement cycles
RbR RMSD before refinement
#AbR Number of aligned atoms before refinement
RS Raw alignment score
AR Number of residues aligned
and saves the table to filename as csv
old version:
1_solution_0_rpr 1_santalucia_1_rpr 5.60600471496582 958 4 5.763411521911621 974 416.0 46 -- RMSD 5.76 of 46 residues
"""
molecules = cmd.get_names_of_type("object:molecule")
ref = molecules.pop(0)
print("""
RaR RMSD after refinement
#AA Number of aligned atoms after refinement
CoR Number of refinement cycles
RbR RMSD before refinement
#AbR Number of aligned atoms before refinement
RS Raw alignment score
AR Number of residues aligned
""")
report = []
header = 'Ref Model RaR #AA CoR RbR #AbR RS AR'
print(header)
txt = 'Ref,Model,RMSD after refinement,Number of aligned atoms after refinement, Number of refinement cycles, RMSD before refinement, Number of aligned atoms before refinement, Raw alignment score, Number of residues aligned\n'
for molecule in molecules:
values = cmd.align(molecule, ref, cycles=cycles)
l = ([
ref[:20].ljust(20), molecule[:20].ljust(20),
str(round(values[0], 2)).ljust(4),
str(round(values[1], 2)).ljust(4),
str(round(values[2], 2)).ljust(4),
str(round(values[3], 2)).ljust(4),
str(round(values[4], 2)).ljust(4),
str(round(values[5])).ljust(4),
str(round(values[6], 2)).ljust(4)
])
print(' '.join(l))
txt += ','.join([x.strip() for x in l]) + '\n'
report.append([ref, molecule, values[3], values[6]])
with open(filename, 'w') as f:
f.write(txt)
def testAlign(self):
cmd.load(self.datafile("1oky-frag.pdb"), "m1")
cmd.load(self.datafile("1t46-frag.pdb"), "m2")
cycles = 2
r = cmd.align("m1", "m2", object="aln", cycles=cycles, transform=0)
self.assertAlmostEqual(r[0], 1.52563, delta=1e-4)
self.assertEqual(r[1], 177)
self.assertEqual(r[1], cmd.count_atoms("aln") / 2)
self.assertEqual(r[2], cycles)
def superalign(target, ligand_recogniser):
receptors = cmd.get_names(selection='not *{}*'.format(ligand_recogniser))
cmd.create('target', '{}'.format(target))
for r in receptors:
ligands = cmd.get_names(
selection='{}_*{}*'.format(r, ligand_recogniser))
for l in ligands:
cmd.create('{}_superaligned'.format(l), 'None')
cmd.create('TMP', '{} or {}'.format(r, l))
cmd.align('TMP and name ca', 'target')
# states = cmd.count_states('{}_superaligned'.format(r))
# states += 1
# cmd.create('{}_superaligned'.format(r), 'TMP and resname UNL', '0', '{}'.format(states))
cmd.create('{}_superaligned'.format(l), 'TMP and resname UNL')
cmd.delete('TMP')
cmd.delete('{}'.format(l))
cmd.delete('{}'.format(r))
def testAlign(self):
cmd.load(self.datafile("1oky-frag.pdb"), "m1")
cmd.load(self.datafile("1t46-frag.pdb"), "m2")
cycles = 2
r = cmd.align("m1", "m2", object="aln", cycles=cycles, transform=0)
self.assertAlmostEqual(r[0], 1.52563, delta=1e-4)
self.assertEqual(r[1], 177)
self.assertEqual(r[1], cmd.count_atoms("aln") / 2)
self.assertEqual(r[2], cycles)
def join_states(name, selection='all', discrete=-1, zoom=0, quiet=1):
'''
DESCRIPTION
The reverse of split_states
ARGUMENTS
name = string: name of object to create or modify
selection = string: atoms to include in the new object
discrete = -2: match atoms by sequence alignment
discrete = -1: Assume identical input objects (matching all atom
identifiers) but also check for missing atoms and only include atoms
that are present in all input objects {default}
discrete = 0: Assume identical input objects
discrete = 1: Input object may be (totally) different
'''
discrete, quiet = int(discrete), int(quiet)
if discrete == -2:
_assert_package_import()
from .selecting import wait_for
aln_obj = cmd.get_unused_name('_')
models = cmd.get_object_list('(' + selection + ')')
for i in range(len(models)):
if discrete == -1 and i > 0:
cmd.remove('(%s) and not (alt A+ and (%s) in (%s))' %
(name, name, models[i]))
cmd.create(name, '(%s) in (%s)' % (models[i], name), 1, i + 1, 0,
0, quiet)
elif discrete == -2 and i > 0:
cmd.align(models[i], name, cycles=0, transform=0, object=aln_obj)
wait_for(aln_obj)
cmd.remove('(%s) and not (%s)' % (name, aln_obj))
cmd.create(name, name, 1, i + 1, 0, 0, quiet)
cmd.update(name, '(%s) and (%s)' % (models[i], aln_obj), i + 1, 1,
0, quiet)
cmd.delete(aln_obj)
else:
cmd.create(name, models[i], 1, i + 1, discrete == 1, 0, quiet)
if int(zoom):
cmd.zoom(name, state=0)
def align_all( subset = [] ):
"""
Superimpose all open models onto the first one.
This may not work well with selections.
"""
AllObj=cmd.get_names("all")
for x in AllObj[1:]:
print(AllObj[0],x)
subset_tag = ''
if isinstance( subset, int ):
subset_tag = ' and resi %d' % subset
elif isinstance( subset, list ) and len( subset ) > 0:
subset_tag = ' and resi %d' % (subset[0])
for m in range( 1,len(subset)): subset_tag += '+%d' % subset[m]
elif isinstance( subset, str ) and len( subset ) > 0:
subset_tag = ' and %s' % subset
cmd.align(x+subset_tag,AllObj[0]+subset_tag)
cmd.zoom()
def testAlignMissingCoords(self):
filename = self.datafile('1t46-frag.pdb')
cmd.load(filename, 'm1')
cmd.remove('m1 & resi 600-605')
cmd.load(filename, 'm1', state=2)
cmd.load(filename, 'm2')
cmd.remove('m2 & resi 620-625')
cmd.load(filename, 'm2', state=2)
cmd.align('m1',
'm2',
object='aln',
mobile_state=1,
target_state=1,
cycles=0)
self.assertIn('aln', cmd.get_names())
def diff(sele1, sele2, byres=1, name=None, operator='in', quiet=0):
'''
DESCRIPTION
Difference between two molecules
ARGUMENTS
sele1 = string: atom selection
sele2 = string: atom selection
byres = 0/1: report residues, not atoms (does not affect selection)
{default: 1}
operator = in/like/align: operator to match atoms {default: in}
SEE ALSO
symdiff
'''
byres, quiet = int(byres), int(quiet)
if name is None:
name = cmd.get_unused_name('diff')
if operator == 'align':
alnobj = cmd.get_unused_name('__aln')
cmd.align(sele1, sele2, cycles=0, transform=0, object=alnobj)
sele = '(%s) and not %s' % (sele1, alnobj)
cmd.select(name, sele)
cmd.delete(alnobj)
else:
sele = '(%s) and not ((%s) %s (%s))' % (sele1, sele1, operator, sele2)
cmd.select(name, sele)
if not quiet:
if byres:
seleiter = 'byca ' + name
expr = 'print "/%s/%s/%s/%s`%s" % (model,segi,chain,resn,resi)'
else:
seleiter = name
expr = 'print "/%s/%s/%s/%s`%s/%s" % (model,segi,chain,resn,resi,name)'
cmd.iterate(seleiter, expr)
return name
def diff(sele1, sele2, byres=1, name=None, operator='in', quiet=0):
'''
DESCRIPTION
Difference between two molecules
ARGUMENTS
sele1 = string: atom selection
sele2 = string: atom selection
byres = 0/1: report residues, not atoms (does not affect selection)
{default: 1}
operator = in/like/align: operator to match atoms {default: in}
SEE ALSO
symdiff
'''
byres, quiet = int(byres), int(quiet)
if name is None:
name = cmd.get_unused_name('diff')
if operator == 'align':
alnobj = cmd.get_unused_name('__aln')
cmd.align(sele1, sele2, cycles=0, transform=0, object=alnobj)
sele = '(%s) and not %s' % (sele1, alnobj)
cmd.select(name, sele)
cmd.delete(alnobj)
else:
sele = '(%s) and not ((%s) %s (%s))' % (sele1, sele1, operator, sele2)
cmd.select(name, sele)
if not quiet:
if byres:
seleiter = 'byca ' + name
expr = 'print "/%s/%s/%s/%s`%s" % (model,segi,chain,resn,resi)'
else:
seleiter = name
expr = 'print "/%s/%s/%s/%s`%s/%s" % (model,segi,chain,resn,resi,name)'
cmd.iterate(seleiter, expr)
return name
def align_all(subset=[]):
"""
Superimpose all open models onto the first one.
This may not work well with selections.
"""
AllObj = cmd.get_names("all")
for x in AllObj[1:]:
print(AllObj[0], x)
subset_tag = ''
if isinstance(subset, int):
subset_tag = ' and resi %d' % subset
elif isinstance(subset, list) and len(subset) > 0:
subset_tag = ' and resi %d' % (subset[0])
for m in range(1, len(subset)):
subset_tag += '+%d' % subset[m]
elif isinstance(subset, str) and len(subset) > 0:
subset_tag = ' and %s' % subset
cmd.align(x + subset_tag, AllObj[0] + subset_tag)
cmd.zoom()
def rmsdx(cycles=5, matrix_fn='matrix.txt'):
"""
Args:
cycles (int): refinement cycles of PyMOL align, default: 5
matrix_fn (string): a file to save the matrix
matrix is pretty much saved in space-separated values
so you can load it to pandas with
df = pd.read_csv('matrix.txt', sep=' ', index_col=False)
df = df.set_index(df.columns)
print(df)
Bact_7DCO_S Bact_5gm6_S
Bact_7DCO_S 0.000 0.562
Returns:
string: matrix
and matrix_fn file ;-)
"""
models = cmd.get_names_of_type("object:molecule")
print(' # of models:', len(models))
f = open(matrix_fn, 'w')
#t = '# ' # for numpy
t = '' # for pandas
for r1 in models:
# print r1,
t += str(r1) + ' ' # here ' ' could be changed to , or \t
t = t.strip() + '\n'
c = 1
for r1 in models:
for r2 in models:
if r1 == r2:
rmsd = 0
else:
print(r1, r2)
values = cmd.align(r1, r2, cycles=cycles)
# RaR [1] RbR [3]
# RaR #AA CoR RbR #AbR RS AR'
# (0.668652355670929, 241, 5, 1.1646124124526978, 293, 199.0, 38)
rmsd = round(values[0], 3)
t += str(rmsd) + ' '
#print('...', c, r1)
c += 1
t += '\n'
f.write(t)
f.close()
print(t.strip()) # matrix
return t
def perform_alignment(template, test_pdb, output_file="output_rmsd.csv"):
"""
Perform and alignment using PyMOL's python API
"""
opened_file = open(output_file, "a")
cmd.load(template, "template")
cmd.load(test_pdb, "other")
rms = cmd.align("template", "other")[0]
to_write_row = template[0:-4] + "," + test_pdb[0:-4] + "," + str(
rms) + "\n"
opened_file.write(to_write_row)
cmd.delete("other")
def test(self):
cmd.read_pdbstr(v_pdbstr_anisou, 'm1')
with testing.mktemp('.mae') as maefilename:
cmd.save(maefilename, 'm1')
cmd.delete('*')
cmd.load(maefilename, 'm1')
self.assertEqual(cmd.get_pdbstr('m1'), v_pdbstr_anisou)
cmd.read_pdbstr(v_pdbstr_rotated, 'm2')
cmd.align('m1', 'm2')
with testing.mktemp('.mae') as maefilename:
cmd.save(maefilename, 'm1')
cmd.delete('*')
cmd.load(maefilename, 'm1')
# Attention: Not sure if rotation is numerically stable across
# platforms. Fuzzy comparison might be needed.
self.assertEqual(cmd.get_pdbstr('m1'), v_pdbstr_rotated)
def join_states(name, selection="all", discrete=-1, zoom=0, quiet=1):
"""
DESCRIPTION
The reverse of split_states
ARGUMENTS
name = string: name of object to create or modify
selection = string: atoms to include in the new object
discrete = -2: match atoms by sequence alignment
discrete = -1: Assume identical input objects (matching all atom
identifiers) but also check for missing atoms and only include atoms
that are present in all input objects {default}
discrete = 0: Assume identical input objects
discrete = 1: Input object may be (totally) different
"""
discrete, quiet = int(discrete), int(quiet)
if discrete == -2:
from .selecting import wait_for
aln_obj = cmd.get_unused_name("_")
models = cmd.get_object_list("(" + selection + ")")
for i in range(len(models)):
if discrete == -1 and i > 0:
cmd.remove("(%s) and not (alt A+ and (%s) in (%s))" % (name, name, models[i]))
cmd.create(name, "(%s) in (%s)" % (models[i], name), 1, i + 1, 0, 0, quiet)
elif discrete == -2 and i > 0:
cmd.align(models[i], name, cycles=0, transform=0, object=aln_obj)
wait_for(aln_obj)
cmd.remove("(%s) and not (%s)" % (name, aln_obj))
cmd.create(name, name, 1, i + 1, 0, 0, quiet)
cmd.update(name, "(%s) and (%s)" % (models[i], aln_obj), i + 1, 1, 0, quiet)
cmd.delete(aln_obj)
else:
cmd.create(name, models[i], 1, i + 1, discrete == 1, 0, quiet)
if int(zoom):
cmd.zoom(name, state=0)
def test(self, matrix_mode):
cmd.viewport(100,100)
cmd.set('matrix_mode', matrix_mode)
cmd.set('ambient', 1.0)
cmd.read_pdbstr(v_pdbstr_anisou, 'm1', zoom=0)
cmd.read_pdbstr(v_pdbstr_rotated, 'm2', zoom=0)
self._rep()
cmd.set_view(views[0])
ref = self.get_imagearray()
self.assertImageHasColor('yellow')
cmd.align('m1', 'm2')
cmd.set_view(views[1])
self.assertImageEqual(ref, count=100, delta=1, msg='ANISOU not aligned on display')
pdbstr = cmd.get_pdbstr('m1')
cmd.delete('*')
cmd.read_pdbstr(pdbstr, 'm1', zoom=0)
self._rep()
self.assertImageEqual(ref, count=100, msg='ANISOU not aligned in PDB')
def alignedSequence():
if not os.path.isdir("/Users/michaelHumphrey/FilesWithSequences"):
os.mkdir("/Users/michaelHumphrey/FilesWithSequences")
files = glob("/Users/michaelHumphrey/homologousToOGC/*.pdb")
files.sort()
for i in files:
cmd.load(i)
protObjName = i[(len(i) - 8):]
protObj = re.sub('\.pdb$', '', protObjName)
alignObjectName = '%s_on_domainA' % (protObj)
rmsd = cmd.align(protObj, 'domainA', object=alignObjectName)
stored.residues = []
stored.resi = []
cmd.iterate('(%s & n. ca)' % (alignObjectName), 'stored.residues.append(resn)')
cmd.iterate('(%s & n. ca)' % (alignObjectName), 'stored.resi.append(resi)')
stored.resiFirstHalf = []
stored.resiSecondHalf = []
for rez1 in range(len(stored.resi)/2):
stored.resiFirstHalf.append(stored.resi[rez1])
for rez2 in range((len(stored.resi)/2), len(stored.resi)):
stored.resiSecondHalf.append(stored.resi[rez2])
stored.residuesFirstHalf = []
stored.residuesSecondHalf = []
for residues1 in range(len(stored.residues)/2):
stored.residuesFirstHalf.append(stored.residues[residues1])
for residues2 in range((len(stored.residues)/2), len(stored.residues)):
stored.residuesSecondHalf.append(stored.residues[residues2])
aminoAcids = ['ALA', 'ARG', 'ASN', 'ASP', 'CYS', 'GLN' , 'GLU', 'GLY', 'HIS', 'ILE', 'LEU', 'LYS', 'MET', 'PHE', 'PRO', 'SER', 'THR', 'TRP', 'TYR', 'VAL']
domainAResidueCount = [0] * len(aminoAcids)
otherPDBResiduesCount = [0] * len(aminoAcids)
for k in range(len(stored.residuesFirstHalf)):
for j in range(len(aminoAcids)):
if stored.residuesFirstHalf[k] == aminoAcids[j]:
domainAResidueCount[j] += 1
for k in range(len(stored.residuesSecondHalf)):
for j in range(len(aminoAcids)):
if stored.residuesSecondHalf[k] == aminoAcids[j]:
otherPDBResiduesCount[j] += 1
sequencesFile = open(os.path.join("/Users/michaelHumphrey/FilesWithSequences", "sequencesFile.txt"), "a")
sequencesFile.write('%s\t%s\n' % (alignObjectName, rmsd[0]))
for resid1, re1, resid2, re2 in zip(stored.residuesFirstHalf, stored.resiFirstHalf, stored.residuesSecondHalf, stored.resiSecondHalf):
sequencesFile.write("%s\t%s\t%s\t%s\n" % (resid1, re1, resid2, re2))
sequencesFile.write('\n')
for residues1, residues2, residues3, residues4 in zip(aminoAcids, domainAResidueCount, aminoAcids, otherPDBResiduesCount):
sequencesFile.write("%s\t%s\t%s\t%s\n" % (residues1, residues2, residues3, residues4))
sequencesFile.write('\n')
sequencesFile.close()
cmd.delete(protObj)
cmd.delete(alignObjectName)
def gdt_ts(mobile, target, cutoffs='1 2 4 8', quiet=1):
'''
DESCRIPTION
Global Distance Test Total Score (GDT_TS)
'''
cutoffs = list(map(float, cutoffs.split()))
quiet = int(quiet)
mobile = '(' + mobile + ') and guide'
target = '(' + target + ') and guide'
ts = 0
N = min(cmd.count_atoms(mobile), cmd.count_atoms(target))
for cutoff in cutoffs:
x = cmd.align(mobile, target, cutoff=cutoff, transform=0)
p = float(x[1]) / N
if not quiet:
print(' GDT_TS: GDT_P%.1f = %.2f' % (cutoff, p))
ts += p
ts /= len(cutoffs)
if not quiet:
print(' GDT_TS: Total Score = %.2f' % (ts))
return ts
def dyndom(mobile, target, window=5, domain=20, ratio=1.0, exe='', transform=1,
quiet=1, mobile_state=1, target_state=1, match='align', preserve=0):
'''
DESCRIPTION
DynDom wrapper
DynDom is a program to determine domains, hinge axes and hinge bending
residues in proteins where two conformations are available.
http://fizz.cmp.uea.ac.uk/dyndom/
USAGE
dyndom mobile, target [, window [, domain [, ratio ]]]
'''
import tempfile, subprocess, os, shutil, sys
from .exporting import save_pdb_without_ter
window, domain, ratio = int(window), int(domain), float(ratio)
transform, quiet = int(transform), int(quiet)
mobile_state, target_state = int(mobile_state), int(target_state)
mm = MatchMaker(
'(%s) & polymer & state %d' % (mobile, mobile_state),
'(%s) & polymer & state %d' % (target, target_state), match)
chains = cmd.get_chains(mm.mobile)
if len(chains) != 1:
print('mobile selection must be single chain')
raise CmdException
chain1id = chains[0]
chains = cmd.get_chains(mm.target)
if len(chains) != 1:
print('target selection must be single chain')
raise CmdException
chain2id = chains[0]
if not exe:
from . import which
exe = which('DynDom', 'dyndom')
if not exe:
print(' Error: Cannot find DynDom executable')
raise CmdException
else:
exe = cmd.exp_path(exe)
tempdir = tempfile.mkdtemp()
try:
filename1 = os.path.join(tempdir, 'mobile.pdb')
filename2 = os.path.join(tempdir, 'target.pdb')
commandfile = os.path.join(tempdir, 'command.txt')
infofile = os.path.join(tempdir, 'out_info')
save_pdb_without_ter(filename1, mm.mobile, state=mobile_state)
save_pdb_without_ter(filename2, mm.target, state=target_state)
f = open(commandfile, 'w')
f.write('title=out\nfilename1=%s\nchain1id=%s\nfilename2=%s\nchain2id=%s\n' \
'window=%d\ndomain=%d\nratio=%.4f\n' % (filename1, chain1id,
filename2, chain2id, window, domain, ratio))
f.close()
process = subprocess.Popen([exe, commandfile], cwd=tempdir,
universal_newlines=True,
stderr=subprocess.STDOUT, stdout=subprocess.PIPE)
for line in process.stdout:
if not quiet:
sys.stdout.write(line)
if process.poll() != 0:
raise CmdException('"%s" failed with status %d' % (exe, process.returncode))
cmd.color('gray', mobile)
fixed_name = dyndom_parse_info(infofile, mm.mobile, quiet)
except OSError:
print('Cannot execute "%s", please provide full path to DynDom executable' % (exe))
raise CmdException
finally:
if not int(preserve):
shutil.rmtree(tempdir)
elif not quiet:
print(' Not deleting temporary directory:', tempdir)
if transform and fixed_name is not None:
cmd.align(fixed_name, target)
def loadInterfacePDB(file,name=None,native=None,wt=None):
print " Loading interface PDB %s"%(file)
if name is None:
name = name = os.path.basename(file)
if name.endswith('.pdb'):
name = name[:-4]
# Call Will's packing PDB loading function
# Note: proteins will be cartoons, cavities will be spheres
# Rosetta radii will be enabled
name = loadPackingPDB(file,name,native)
cavselname = name+"cavities"
protselname = name+"protein"
cmd.hide("lines",protselname)
backbone_colorlist = ['green', 'yellow', 'violet', 'cyan', \
'salmon', 'lime', 'slate', 'magenta', 'orange', 'marine', \
'olive', 'forest', 'firebrick', 'chocolate' ]
curr_bb_color = 0
carbon_colorlist = ['teal', 'wheat', 'grey', 'pink' ]
curr_carbon_color = 0
# Derive selections for the interface, color by chain
cmd.select("interface", "none")
cmd.select("heavy_interface", "none")
selectPolarProtons("polar_protons")
selectApolarProtons("apolar_protons")
alphabet = list(('abcdefghijklmnopqrstuvwxyz').upper())
for letter in alphabet:
chainname = "chain"+letter
cmd.select( chainname, "chain %s and not hetatm and not symbol w"%(letter) )
# Check whether any protein atoms exist with this chain ID
# JK Later, put in a special "non-interface" case for L/H antibody chains
if cmd.count_atoms("chain%s"%(letter))>0:
interfacename = "interface"+letter
cmd.select("not_this_chain", "not hetatm and not symbol w and not %s"%(chainname) )
cmd.select(interfacename, "byres %s and (not_this_chain around 4.0)"%(chainname) )
cmd.select("heavy_%s"%(interfacename), "%s and not apolar_protons"%(interfacename))
cmd.select("interface", "interface or %s"%(interfacename) )
cmd.select("heavy_interface", "heavy_interface or heavy_%s"%(interfacename) )
cmd.delete("not_this_chain")
cmd.color(backbone_colorlist[curr_bb_color], chainname)
curr_bb_color = curr_bb_color+1
if(curr_bb_color == len(backbone_colorlist)):
curr_bb_color = 0
colorCPK(interfacename,carbon_colorlist[curr_carbon_color])
curr_carbon_color = curr_carbon_color+1
if(curr_carbon_color == len(carbon_colorlist)):
curr_carbon_color = 0
cmd.color("white", "%s and polar_protons"%(interfacename))
else:
cmd.delete(chainname)
cmd.delete("apolar_protons")
cmd.delete("polar_protons")
# Show the interface in sticks, colored cpk
#cmd.hide( "cartoon", "interface" )
cmd.show( "sticks", "heavy_interface" )
cmd.zoom("interface")
cmd.show( "cartoon", "(not interface) or byres(neighbor(interface)) or byres(neighbor(byres(neighbor(interface))))" )
# Show interface waters as small purple spheres
cmd.select( "interface_water", "(symbol w or resn HOH) and (interface around 8.0)")
if cmd.count_atoms("interface_water")>0:
# Put the waters in a separate object, so that we can scale their radii
newwatername = name+"waters"
cmd.create(newwatername, "interface_water")
cmd.remove("interface_water")
cmd.color("purple", newwatername)
cmd.show( "spheres", newwatername )
#cmd.set( "sphere_scale", 0.5, newwatername )
cmd.set( "sphere_scale", 0.1, newwatername )
else:
cmd.delete("interface_water")
# Show interface ligands as pink sticks
cmd.select( "interface_hetero", "(not symbol w and not resn HOH) and (hetatm and not symbol w and not resn WSS) and (interface around 4.5)")
if cmd.count_atoms("interface_hetero")>0:
cmd.color("pink", "interface_hetero")
cmd.show( "sticks", "interface_hetero" )
else:
cmd.delete("interface_hetero")
cmd.select("none")
cmd.load( wt, "wt" )
cmd.create( "wt_A", "wt and chain A" )
cmd.create( "wt_B", "wt and chain B" )
cmd.select("none")
cmd.create( "des_A", "not wt and chain A" )
cmd.show( "surface", "des_A" )
cmd.create( "des_B", "not wt and chain B")
cmd.show( "surface", "des_B" )
cmd.align( "wt_A", "des_A" )
cmd.align( "wt_B", "des_B" )
# cmd.show( "lines", "wt_A" )
# cmd.show( "lines", "wt_B" )
cmd.set( "transparency", 1 )
cmd.zoom("interface")
return name
