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 testSaveState(self, format, pymol_version):
if pymol_version > testing.PYMOL_VERSION[1]:
self.skipTest("version %f" % (pymol_version))
# for rms_cur (not all formats save all identifiers)
m = -1
cmd.set('retain_order')
# create a multistate object
cmd.fragment('ala', 'm1')
cmd.create('m1', 'm1', 1, 2)
cmd.create('m1', 'm1', 1, 3)
cmd.translate([5, 0, 0], 'm1', state=2)
cmd.translate([0, 5, 0], 'm1', state=3)
n_states = cmd.count_states('m1')
with testing.mktemp('.' + format) as filename:
if format == 'mae' and not pymol.invocation.options.incentive_product:
format = 'cms'
# explicit
for state in range(1, n_states + 1):
cmd.delete('m2')
cmd.save(filename, 'm1', state=state)
cmd.load(filename, 'm2', format=format)
rms = cmd.rms_cur('m1', 'm2', state, 1, matchmaker=m)
self.assertAlmostEqual(rms, 0.00, delta=1e-2)
# current state
for state in range(1, n_states + 1):
cmd.frame(state)
cmd.delete('m2')
cmd.save(filename, 'm1')
cmd.load(filename, 'm2', 1, format=format)
rms = cmd.rms_cur('m1', 'm2', state, 1, matchmaker=m)
self.assertAlmostEqual(rms, 0.00, delta=1e-2)
if format in ('mol', 'cms'):
# no multi support
return
# all states
cmd.delete('m2')
cmd.save(filename, 'm1', state=0)
cmd.load(filename, 'm2', 1, discrete=1, multiplex=0)
self.assertEqual(cmd.count_states('m2'), n_states)
for state in range(1, n_states + 1):
rms = cmd.rms_cur('m1',
'm2 and state %d' % state,
state,
state,
matchmaker=m)
self.assertAlmostEqual(rms, 0.00, delta=1e-2)
def testSaveState(self, format, pymol_version):
if pymol_version > testing.PYMOL_VERSION[1]:
self.skipTest("version %f" % (pymol_version))
# for rms_cur (not all formats save all identifiers)
m = -1
cmd.set('retain_order')
# create a multistate object
cmd.fragment('ala', 'm1')
cmd.create('m1', 'm1', 1, 2)
cmd.create('m1', 'm1', 1, 3)
cmd.translate([5, 0, 0], 'm1', state=2)
cmd.translate([0, 5, 0], 'm1', state=3)
n_states = cmd.count_states('m1')
with testing.mktemp('.' + format) as filename:
if format == 'mae' and not pymol.invocation.options.incentive_product:
format = 'cms'
# explicit
for state in range(1, n_states + 1):
cmd.delete('m2')
cmd.save(filename, 'm1', state=state)
cmd.load(filename, 'm2', format=format)
rms = cmd.rms_cur('m1', 'm2', state, 1, matchmaker=m)
self.assertAlmostEqual(rms, 0.00, delta=1e-2)
# current state
for state in range(1, n_states + 1):
cmd.frame(state)
cmd.delete('m2')
cmd.save(filename, 'm1')
cmd.load(filename, 'm2', 1, format=format)
rms = cmd.rms_cur('m1', 'm2', state, 1, matchmaker=m)
self.assertAlmostEqual(rms, 0.00, delta=1e-2)
if format in ('mol', 'cms'):
# no multi support
return
# all states
cmd.delete('m2')
cmd.save(filename, 'm1', state=0)
cmd.load(filename, 'm2', 1, discrete=1, multiplex=0)
self.assertEqual(cmd.count_states('m2'), n_states)
for state in range(1, n_states + 1):
rms = cmd.rms_cur('m1', 'm2 and state %d' % state,
state, state, matchmaker=m)
self.assertAlmostEqual(rms, 0.00, delta=1e-2)
def project(model, resi1_str, resi2_str, resi3_str, \
symQ, syms_for_use, syms_for_del, sym_d=3, \
segis_for_save='all', segis_for_del=''):
all_segis = prepare(model, resi1_str, resi2_str, resi3_str, segis_for_save, segis_for_del)
new_model, segi_count = make_segis(model, resi1, resi2, resi3, all_segis)
cmd.alter(new_model, \
'segi = new_segi(segi, sorted(all_segis))', \
space={'new_segi': new_segi, 'all_segis': all_segis, 'sorted': sorted})
if symQ:
cmd.symexp('{}_sym'.format(model), \
'{}_save'.format(model), \
'({}_save)'.format(model), \
sym_d)
for i in range(len(syms_for_use)):
cmd.alter('{}_sym{}'.format(model, syms_for_use[i]), 'segi=segi+"mod{}"'.format(i + 1))
merge(model, ['{}_save'.format(model)] + ['{}_sym{}'.format(model, s) for s in syms_for_use])
else: merge(model, ['{}_save'.format(model)])
for sym in syms_for_del:
cmd.delete('{}_sym{}'.format(model, sym))
cmd.alter('all', 'chain="A"')
cmd.save('{}_calc.cif'.format(model), '{}_calc'.format(model))
print(cmd.rms_cur('{}_calc'.format(model), '{}_sym'.format(model)))
def testFit(self):
cmd.fragment("gly", "m1")
cmd.create("m2", "m1")
rms = cmd.fit("m1", "m2")
self.assertEqual(rms, 0.0)
rms = cmd.rms("m1", "m2")
self.assertEqual(rms, 0.0)
rms = cmd.rms_cur("m1", "m2")
self.assertEqual(rms, 0.0)
def testFit(self):
cmd.fragment("gly", "m1")
cmd.create("m2", "m1")
rms = cmd.fit("m1", "m2")
self.assertEqual(rms, 0.0)
rms = cmd.rms("m1", "m2")
self.assertEqual(rms, 0.0)
rms = cmd.rms_cur("m1", "m2")
self.assertEqual(rms, 0.0)
def RMS_Calc(Ref_obj, OList):
RMSList = [0] * len(OList)
count = 0
for obj in OList:
rms_val = cmd.rms_cur(Ref_obj, obj)
RMSList[count] = str(rms_val)
count += 1
# RMS values of ref_obj compared to all other objects
return RMSList
def rotation(rot_str, i, num):
global UNK
# cmd.do('set retain_order,1')
cmd.do(rot_str)
# Save the rotation and the ligand
cmd.save(i + '_' + str(num) + 'rot.pdb', i)
# Save just the ligand
cmd.save(i + '_UNK' + str(num) + '.pdb', i + ' and resn ' + UNK)
# print("UNK Rotation: " + i + '_UNK' + str(num) + '.pdb')
# Calculates the RMS between the UNK and the obj1 UNK reference
rms_val = cmd.rms_cur('obj1 and resn ' + UNK, i + ' and resn ' + UNK)
return rms_val
def rmsdCA(refMol, tgtMol, puttyview="Y", bfactorca="CA"):
"""
Written up by Yufeng Tong 2020-01-29
Inspired by rmsdByRes Zhenting Gao on 7/28/2016
and by loadBfacts from PyMOLWiki
USAGE
rmsdCA refMol, tgtMol, puttyview="Y", bfactorca="CA"
Calculate the RMSD of Calpha and backbone for each residue pairs from
two chains of proteins with same residue numbers and close
conformations for the two structures. The two proteins can be
mutants. Only residue numbers but not identity are matched.
It will generate a putty representation of the target molecule by
default. You can specify whether to use the RMSD of Calpha or Backbone
for the coloring of the putty display.
I think it's not neccessary to calculate RMSD of the whole residue.
A CSV file is saved of the calculated RMSD of Calpha and backbone atoms.
A PDB file is saved with BFactor replaced by the RMSD.
Workflow
Read reference and target pdb files
1. Select two objects for comparison
2. Align two structures
3. rmsdByRes refMol, tgtMol
TODO:
1. Save output files to the folder pdb files are loaded.
2. Handle missing residues.
"""
# Create temporary objects, exclude alternative conformation B
cmd.delete("tgt_gzt rmsdPuttyScale")
cmd.create("ref_gzt", refMol + " and polymer and not alt B")
cmd.alter("ref_gzt", "chain='A'")
cmd.alter("ref_gzt", "segi=''")
cmd.create("tgt_gzt", tgtMol + " and polymer and not alt B")
cmd.alter("tgt_gzt", "chain='A'")
cmd.alter("tgt_gzt", "segi=''")
cmd.alter("tgt_gzt", "b=-1.0")
# parameters
outputText = ""
csvHeadline = ("refMol,refRes,refResID,target,residueName,residueId,"
"rmsdResCa,rmsdResBackbone\n")
outputFile = 'rmsd%s_%s.csv' % (bfactorca, tgtMol)
outputpdb = 'rmsdBFactor%s_%s.pdb' % (bfactorca, tgtMol)
bfactors = []
# select alpha carbon of selected residues in reference structure
calpha_ref = cmd.get_model("ref_gzt and name CA")
calpha_tgt = cmd.get_model("tgt_gzt and name CA")
# build an index dict of {resi : index}
ref_dict = {int(v.resi): k for k, v in enumerate(calpha_ref.atom)}
tgt_dict = {int(v.resi): k for k, v in enumerate(calpha_tgt.atom)}
# loop through residues in the target molecule and calculate per residue RMSDs.
for k in sorted(ref_dict):
if k in tgt_dict:
ref_atom = calpha_ref.atom[ref_dict[k]]
tgt_atom = calpha_tgt.atom[tgt_dict[k]]
rmsdResCA = cmd.rms_cur(
"ref_gzt and n. ca and i. " + ref_atom.resi,
"tgt_gzt and n. ca and i. " + tgt_atom.resi,
matchmaker=-1)
rmsdResBb = cmd.rms_cur(
"ref_gzt and n. ca+n+c+o and i. " + ref_atom.resi,
"tgt_gzt and n. ca+n+c+o and i. " + tgt_atom.resi,
matchmaker=-1)
if bfactorca == "bb":
bfactor = rmsdResBb
else:
bfactor = rmsdResCA
cmd.alter("%s and i. %s" % ("tgt_gzt", tgt_atom.resi),
"b=%s" % bfactor)
bfactors.append(bfactor)
outputText += "%s,%s,%s,%s,%s,%s,%.3f,%.3f\n" % (
refMol, ref_atom.resn, ref_atom.resi, tgtMol, tgt_atom.resn,
tgt_atom.resi, rmsdResCA, rmsdResBb)
print(outputText)
max_b, min_b = max(bfactors), min(bfactors)
print("RMSD: max:%.3f; min:%.3f" % (max_b, min_b))
if puttyview == "Y":
cmd.show_as("cartoon", "tgt_gzt")
cmd.cartoon("putty", "tgt_gzt")
cmd.set("cartoon_putty_scale_min", min_b, "tgt_gzt")
cmd.set("cartoon_putty_scale_max", max_b, "tgt_gzt")
cmd.set("cartoon_putty_transform", 0, "tgt_gzt")
cmd.spectrum("b", "rainbow", "tgt_gzt and n. CA")
cmd.ramp_new("rmsdPuttyScale", "tgt_gzt", [min_b, max_b], "rainbow")
cmd.recolor()
# Destroy temporary objects
cmd.delete("ref_gzt")
# Save data into csv and pdb
f = open(outputFile, 'w+')
f.write(csvHeadline)
f.write(outputText)
f.close()
cmd.save(outputpdb, "tgt_gzt")
print("Results are saved in %s and %s " % (outputFile, outputpdb))
def tmalign(mobile,
target,
args='',
exe='TMalign',
ter=0,
transform=1,
object=None,
quiet=0):
"""
DESCRIPTION
TMalign wrapper
Reference: Y. Zhang and J. Skolnick, Nucl. Acids Res. 2005 33, 2302-9
http://zhanglab.ccmb.med.umich.edu/TM-align/
USAGE
tmalign mobile, target [, args [, exe ]]
ARGUMENTS
mobile, target = string: atom selections
args = string: Extra arguments like -d0 5 -L 100
exe = string: Path to TMalign executable {default: TMalign}
ter = 0/1: If ter=0, then ignore chain breaks because TMalign will stop
at first TER record {default: 0}
SEE ALSO
tmscore, mmalign
"""
import subprocess
import tempfile
import os
import re
ter, quiet = int(ter), int(quiet)
mobile_filename = tempfile.mktemp('.pdb', 'mobile')
target_filename = tempfile.mktemp('.pdb', 'target')
matrix_filename = tempfile.mktemp('.txt', 'matrix')
mobile_ca_sele = '(%s) and (not hetatm) and name CA and alt +A' % mobile
target_ca_sele = '(%s) and (not hetatm) and name CA and alt +A' % target
if ter:
save = cmd.save
else:
save = save_pdb_without_ter
save(mobile_filename, mobile_ca_sele)
save(target_filename, target_ca_sele)
exe = cmd.exp_path(exe)
args = [exe, mobile_filename, target_filename, '-m', matrix_filename
] + args.split()
try:
process = subprocess.Popen(args, stdout=subprocess.PIPE)
lines = process.stdout.readlines()
except OSError:
print('Cannot execute "%s", please provide full path to TMscore or '
'TMalign executable' % exe)
raise CmdException
finally:
os.remove(mobile_filename)
os.remove(target_filename)
# TMalign >= 2012/04/17
if os.path.exists(matrix_filename):
lines += open(matrix_filename).readlines()
os.remove(matrix_filename)
r = None
re_score = re.compile(r'TM-score\s*=\s*(\d*\.\d*)')
rowcount = 0
matrix = []
line_it = iter(lines)
alignment = []
for line in line_it:
if 4 >= rowcount > 0:
if rowcount >= 2:
a = list(map(float, line.split()))
matrix.extend(a[2:5])
matrix.append(a[1])
rowcount += 1
elif line.lower().startswith(' -------- rotation matrix'):
rowcount = 1
elif line.startswith('(":" denotes'):
alignment = []
for i in range(3):
alignment.append(line_it.next().rstrip())
else:
match = re_score.search(line)
if match is not None:
r = float(match.group(1))
if not quiet:
print(line.rstrip())
if not quiet:
for i in range(0, len(alignment[0]) - 1, 78):
for line in alignment:
print(line[i:i + 78])
print('')
assert len(matrix) == 3 * 4
matrix.extend([0, 0, 0, 1])
if int(transform):
cmd.transform_selection('byobject (%s)' % mobile, matrix, homogenous=1)
# alignment object
if object is not None:
mobile_idx, target_idx = [], []
space = {'mobile_idx': mobile_idx, 'target_idx': target_idx}
cmd.iterate(mobile_ca_sele,
'mobile_idx.append("%s`%d" % (model, index))',
space=space)
cmd.iterate(target_ca_sele,
'target_idx.append("%s`%d" % (model, index))',
space=space)
for i, aa in enumerate(alignment[0]):
if aa == '-':
mobile_idx.insert(i, None)
for i, aa in enumerate(alignment[2]):
if aa == '-':
target_idx.insert(i, None)
if len(mobile_idx) == len(target_idx) == len(alignment[2]):
cmd.rms_cur(' '.join(idx
for (idx, m) in zip(mobile_idx, alignment[1])
if m in ':.'),
' '.join(idx
for (idx, m) in zip(target_idx, alignment[1])
if m in ':.'),
matchmaker=4,
object=object)
else:
print('Could not load alignment object')
if not quiet and r is not None:
print('Found in output TM-score = %.4f' % r)
return r
cmd.alter_state(a, "trg", "x=x+random()/2")
cmd.alter_state(a, "trg", "y=y+random()/2")
cmd.alter_state(a, "trg", "z=z+random()/2", quiet=0)
cmd.frame(1)
print "%8.3f" % cmd.fit("ref", "trg")
# asdf
for a in xrange(1, 14):
print a,
print "%8.3f" % cmd.fit("ref and resi %d" % a, "trg"),
print "%8.3f" % cmd.rms("ref", "trg"),
print "%8.3f" % cmd.rms_cur("ref", "trg")
cmd.frame(10)
print "%8.3f" % cmd.fit("ref", "trg")
for a in xrange(1, 14):
print a,
print "%8.3f" % cmd.fit("ref and resi %d" % a, "trg"),
print "%8.3f" % cmd.rms("ref", "trg"),
print "%8.3f" % cmd.rms_cur("ref", "trg")
a = 1
print "%8.3f" % cmd.fit("ref", "trg")
for b in xrange(1, 11):
cmd._dump_floats(cmd.intra_fit("trg and resi %d" % a, b))
def run_comparison(references=None, conformers=None):
references_file = args.references
conformers_file = args.conformers
print(' -- -- -- -- -- LOADING REFERENCES IN {} -- -- -- -- -- '.format(
references_file))
print(' -- -- -- -- -- LOADING CONFORMERS IN {} -- -- -- -- -- '.format(
conformers_file))
lowest_rmsd = []
#out_macro_refs = Chem.SDWriter('Macrocycles_references.sdf')
out_RMSD = Chem.SDWriter('Aligment_RMSD.sdf')
#out_macro_confs = Chem.SDWriter('Macrocycles_conformers.sdf')
print(' -- -- -- -- -- STARTING ANALYSIS -- -- -- -- -- ')
ref_index = 1
for ref in Chem.SDMolSupplier(references_file):
print(ref_index, ')', ref.GetProp('_Name').split('_')[0])
macrocycle_atoms = []
all_cycles = Chem.GetSymmSSSR(ref)
cycles_size = [i for i in all_cycles if len(i) >= 8]
for element in cycles_size:
macrocycle_atoms += list(element)
all_atoms = [i.GetIdx() for i in ref.GetAtoms()]
atoms_to_remove = (list(set(all_atoms) - set(macrocycle_atoms)))
macrocycle = Chem.RWMol(ref)
for i in sorted(atoms_to_remove, reverse=True):
macrocycle.RemoveAtom(i)
m_ref = macrocycle.GetMol()
m_ref.UpdatePropertyCache()
macrocycle_atoms = sorted(list(set(macrocycle_atoms)))
print('Initial Num Atoms:', len(all_atoms))
print('Macrocycle length:', len(macrocycle_atoms))
m_ref_smiles = Chem.MolFragmentToSmiles(ref,
macrocycle_atoms,
kekuleSmiles=True)
m_ref_smiles = Chem.MolFromSmiles(m_ref_smiles, sanitize=False)
ref_index = ref_index + 1
mol_index = 0
table = pd.DataFrame()
for mol in Chem.SDMolSupplier(conformers_file):
if ref.GetProp('_Name').split('_')[0] == mol.GetProp(
'_Name').split('_')[0]:
table.loc[mol_index, 'Conformer'] = [mol.GetProp('_Name')]
ref_atoms = ref.GetSubstructMatch(m_ref_smiles)
mol_atoms = mol.GetSubstructMatch(m_ref_smiles)
amap = zip(mol_atoms, ref_atoms)
rms_macrocycle = AllChem.GetBestRMS(mol, ref, map=[list(amap)])
mol.SetProp('RMSD_macrocycle', str(rms_macrocycle))
table.loc[mol_index, 'RMSD_macrocycle'] = [rms_macrocycle]
macrocycle_atoms = []
all_cycles = Chem.GetSymmSSSR(mol)
cycles_size = [i for i in all_cycles if len(i) >= 8]
for element in cycles_size:
macrocycle_atoms += list(element)
all_atoms = [i.GetIdx() for i in mol.GetAtoms()]
atoms_to_remove = (
list(set(all_atoms) - set(macrocycle_atoms)))
macrocycle = Chem.RWMol(mol)
for i in sorted(atoms_to_remove, reverse=True):
macrocycle.RemoveAtom(i)
m_mol = macrocycle.GetMol()
m_mol.UpdatePropertyCache()
#m_mol=Chem.MolFragmentToSmiles(mol,macrocycle_atoms,kekuleSmiles=True)
#m_mol=Chem.MolFromSmiles(m_mol,sanitize=False)
radious_macro = Descriptors3D.RadiusOfGyration(m_mol)
table.loc[mol_index, 'RoG_macrocycle'] = radious_macro
tt_macro = rdMolDescriptors.GetTopologicalTorsionFingerprint(
m_mol)
table.loc[mol_index,
'TF_macrocycle'] = [tt_macro.GetTotalVal()]
r_list = Chem.TorsionFingerprints.CalculateTorsionLists(m_ref)
r_angles = Chem.TorsionFingerprints.CalculateTorsionAngles(
m_ref, r_list[0], r_list[1])
c_list = Chem.TorsionFingerprints.CalculateTorsionLists(m_mol)
c_angles = Chem.TorsionFingerprints.CalculateTorsionAngles(
m_mol, c_list[0], c_list[1])
if len(r_angles) == len(c_angles):
torsion_macro = Chem.TorsionFingerprints.CalculateTFD(
r_angles, c_angles)
table.loc[mol_index, 'TFD_macrocycle'] = [torsion_macro]
else:
table.loc[mol_index, 'TFD_macrocycle'] = ['NA']
cmd.read_molstr(Chem.MolToMolBlock(ref), 'ref')
cmd.read_molstr(Chem.MolToMolBlock(mol), 'mol')
rmsd = cmd.rms_cur('ref', 'mol')
cmd.deselect()
cmd.delete('all')
mol.SetProp('RMSD_heavy_atoms', str(rmsd))
table.loc[mol_index, 'RMSD_heavy_atoms'] = [rmsd]
out_RMSD.write(mol)
radious = Descriptors3D.RadiusOfGyration(mol)
table.loc[mol_index, 'RoG_heavy_atoms'] = radious
tt = rdMolDescriptors.GetTopologicalTorsionFingerprint(mol)
table.loc[mol_index, 'TF_heavy_atoms'] = [tt.GetTotalVal()]
r_list = Chem.TorsionFingerprints.CalculateTorsionLists(ref)
r_angles = Chem.TorsionFingerprints.CalculateTorsionAngles(
ref, r_list[0], r_list[1])
c_list = Chem.TorsionFingerprints.CalculateTorsionLists(mol)
c_angles = Chem.TorsionFingerprints.CalculateTorsionAngles(
mol, c_list[0], c_list[1])
if len(r_angles) == len(c_angles):
torsion = Chem.TorsionFingerprints.CalculateTFD(
r_angles, c_angles)
table.loc[mol_index, 'TFD_heavy_atoms'] = [torsion]
else:
table.loc[mol_index, 'TFD_heavy_atoms'] = ['NA']
mol_index = mol_index + 1
if len(table.index) > 0:
sort = table.sort_values('RMSD_macrocycle', ascending=True)
sort = sort.reset_index(drop=True)
sort.to_csv(ref.GetProp('_Name') + '.csv')
sort['Nconf'] = len(sort.index)
print('Number of conformers analyzed:', len(sort.index))
print('data in file:', ref.GetProp('_Name') + '.csv')
print('-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n')
sort['Span_Rog_macrocycle'] = float(
max(sort['RoG_macrocycle']) - min(sort['RoG_macrocycle']))
sort['Span_Rog_heavy_atoms'] = float(
max(sort['RoG_heavy_atoms']) - min(sort['RoG_heavy_atoms']))
lowest_rmsd.append(sort.loc[0])
else:
print('No reference or conformers found in input files for {}'.
format(ref.GetProp('_Name')))
print(' ************************************ \n')
#out_macro_refs.close()
out_RMSD.close()
#out_macro_confs.close()
print('SAVING DATA OF LOWEST RMSD OF CONFORMERS')
summary = pd.DataFrame(lowest_rmsd)
summary = summary.reset_index(drop=True)
summary.to_csv('Lowest_RMSD_Data.csv')
print('Lowest RMSD Data in file: Lowest_RMSD_Data.csv')
print('***************************************************\n')
print('Structures in files: Alignment_RMSD.sdf')
print('***************************************************\n')
print(
'CALCULATION OF {} OUT OF {} REFERENCES DONE, FILES SAVED. THANK YOU FOR USING THIS SCRIPT \n'
.format(len(summary.index), len(Chem.SDMolSupplier(references_file))))
def optAlign( sel1, sel2 ):
"""
optAlign performs the Kabsch alignment algorithm upon the alpha-carbons of two selections.
Example: optAlign MOL1 and i. 20-40, MOL2 and i. 102-122
Example 2: optAlign 1GGZ and i. 4-146 and n. CA, 1CLL and i. 4-146 and n. CA
Two RMSDs are returned. One comes from the Kabsch algorithm and the other from
PyMol based upon your selections.
By default, this program will optimally align the ALPHA CARBONS of the selections provided.
To turn off this feature remove the lines between the commented "REMOVE ALPHA CARBONS" below.
@param sel1: First PyMol selection with N-atoms
@param sel2: Second PyMol selection with N-atoms
"""
cmd.reset()
# make the lists for holding coordinates
# partial lists
stored.sel1 = []
stored.sel2 = []
# full lists
stored.mol1 = []
stored.mol2 = []
# now put the coordinates into a list
# partials
# -- REMOVE ALPHA CARBONS
sel1 = sel1 + " and N. CA"
sel2 = sel2 + " and N. CA"
# -- REMOVE ALPHA CARBONS
cmd.iterate_state(1, selector.process(sel1), "stored.sel1.append([x,y,z])")
cmd.iterate_state(1, selector.process(sel2), "stored.sel2.append([x,y,z])")
# full molecule
mol1 = cmd.identify(sel1,1)[0][0]
mol2 = cmd.identify(sel2,1)[0][0]
cmd.iterate_state(1, mol1, "stored.mol1.append([x,y,z])")
cmd.iterate_state(1, mol2, "stored.mol2.append([x,y,z])")
K = kabsch()
U, T1, T2, RMSD, c1, c2 = K.align(stored.sel1, stored.sel2, [])
stored.mol2 = map(lambda v:[T2[0]+((v[0]*U[0][0])+(v[1]*U[1][0])+(v[2]*U[2][0])),T2[1]+((v[0]*U[0][1])+(v[1]*U[1][1])+(v[2]*U[2][1])),T2[2]+((v[0]*U[0][2])+(v[1]*U[1][2])+(v[2]*U[2][2]))],stored.mol2)
#stored.mol1 = map(lambda v:[ v[0]+T1[0], v[1]+T1[1], v[2]+T1[2] ], stored.mol1)
stored.mol1 = map(lambda v:[ v[0]+T1[0], v[1]+T1[1], v[2]+T1[2] ], stored.mol1)
cmd.alter_state(1,mol1,"(x,y,z)=stored.mol1.pop(0)")
cmd.alter_state(1,mol2,"(x,y,z)=stored.mol2.pop(0)")
cmd.alter( 'all',"segi=''")
cmd.alter('all', "chain=''")
print "RMSD=%f" % cmd.rms_cur(sel1, sel2)
print "MY RMSD=%f" % RMSD
cmd.hide('everything')
cmd.show('ribbon', sel1 + ' or ' + sel2)
cmd.color('gray70', mol1 )
cmd.color('paleyellow', mol2 )
cmd.color('red', 'visible')
cmd.show('ribbon', 'not visible')
cmd.center('visible')
cmd.orient()
cmd.zoom('visible')
def tmalign(mobile,
target,
mobile_state=1,
target_state=1,
args='',
exe='TMalign',
ter=0,
transform=1,
object=None,
quiet=0):
'''
DESCRIPTION
TMalign wrapper. You may also use this as a TMscore or MMalign wrapper
if you privide the corresponding executable with the "exe" argument.
Reference: Y. Zhang and J. Skolnick, Nucl. Acids Res. 2005 33, 2302-9
http://zhanglab.ccmb.med.umich.edu/TM-align/
ARGUMENTS
mobile, target = string: atom selections
mobile_state, target_state = int: object states {default: 1}
args = string: Extra arguments like -d0 5 -L 100
exe = string: Path to TMalign (or TMscore, MMalign) executable
{default: TMalign}
ter = 0/1: If ter=0, then ignore chain breaks because TMalign will stop
at first TER record {default: 0}
'''
import subprocess, tempfile, os, re
from .exporting import save_pdb_without_ter
ter, quiet = int(ter), int(quiet)
mobile_filename = tempfile.mktemp('.pdb', 'mobile')
target_filename = tempfile.mktemp('.pdb', 'target')
matrix_filename = tempfile.mktemp('.txt', 'matrix')
mobile_ca_sele = '(%s) and (not hetatm) and name CA and alt +A' % (mobile)
target_ca_sele = '(%s) and (not hetatm) and name CA and alt +A' % (target)
if ter:
save = cmd.save
else:
save = save_pdb_without_ter
save(mobile_filename, mobile_ca_sele, state=mobile_state)
save(target_filename, target_ca_sele, state=target_state)
exe = cmd.exp_path(exe)
args = [exe, mobile_filename, target_filename, '-m', matrix_filename
] + args.split()
try:
process = subprocess.Popen(args, stdout=subprocess.PIPE)
lines = process.stdout.readlines()
except OSError:
print(
'Cannot execute "%s", please provide full path to TMscore or TMalign executable'
% (exe))
raise CmdException
finally:
os.remove(mobile_filename)
os.remove(target_filename)
# TMalign >= 2012/04/17
if os.path.exists(matrix_filename):
lines += open(matrix_filename).readlines()
os.remove(matrix_filename)
r = None
re_score = re.compile(r'TM-score\s*=\s*(\d*\.\d*)')
rowcount = 0
matrix = []
line_it = iter(lines)
headercheck = False
alignment = []
for line in line_it:
if 4 >= rowcount > 0:
if rowcount >= 2:
a = list(map(float, line.split()))
matrix.extend(a[2:5])
matrix.append(a[1])
rowcount += 1
elif not headercheck and line.startswith(' * '):
a = line.split(None, 2)
if len(a) == 3:
headercheck = a[1]
elif line.lower().startswith(' -------- rotation matrix'):
rowcount = 1
elif line.startswith('(":" denotes'):
alignment = [line_it.next().rstrip() for i in range(3)]
else:
match = re_score.search(line)
if match is not None:
r = float(match.group(1))
if not quiet:
print(line.rstrip())
if not quiet:
for i in range(0, len(alignment[0]) - 1, 78):
for line in alignment:
print(line[i:i + 78])
print('')
assert len(matrix) == 3 * 4
matrix.extend([0, 0, 0, 1])
if int(transform):
for model in cmd.get_object_list('(' + mobile + ')'):
cmd.transform_object(model, matrix, state=0, homogenous=1)
# alignment object
if object is not None:
mobile_idx, target_idx = [], []
space = {'mobile_idx': mobile_idx, 'target_idx': target_idx}
cmd.iterate(mobile_ca_sele,
'mobile_idx.append("%s`%d" % (model, index))',
space=space)
cmd.iterate(target_ca_sele,
'target_idx.append("%s`%d" % (model, index))',
space=space)
for i, aa in enumerate(alignment[0]):
if aa == '-':
mobile_idx.insert(i, None)
for i, aa in enumerate(alignment[2]):
if aa == '-':
target_idx.insert(i, None)
if (len(mobile_idx) == len(target_idx) == len(alignment[2])):
cmd.rms_cur(' '.join(idx
for (idx, m) in zip(mobile_idx, alignment[1])
if m in ':.'),
' '.join(idx
for (idx, m) in zip(target_idx, alignment[1])
if m in ':.'),
cycles=0,
matchmaker=4,
object=object)
else:
print('Could not load alignment object')
if not quiet:
if headercheck:
print('Finished Program:', headercheck)
if r is not None:
print('Found in output TM-score = %.4f' % (r))
return r
def tmalign(mobile, target, args='', exe='TMalign', ter=0, transform=1, object=None, quiet=0):
'''
DESCRIPTION
TMalign wrapper
Reference: Y. Zhang and J. Skolnick, Nucl. Acids Res. 2005 33, 2302-9
http://zhanglab.ccmb.med.umich.edu/TM-align/
USAGE
tmalign mobile, target [, args [, exe ]]
ARGUMENTS
mobile, target = string: atom selections
args = string: Extra arguments like -d0 5 -L 100
exe = string: Path to TMalign executable {default: TMalign}
ter = 0/1: If ter=0, then ignore chain breaks because TMalign will stop
at first TER record {default: 0}
SEE ALSO
tmscore, mmalign
'''
import subprocess, tempfile, os, re
ter, quiet = int(ter), int(quiet)
mobile_filename = tempfile.mktemp('.pdb', 'mobile')
target_filename = tempfile.mktemp('.pdb', 'target')
mobile_ca_sele = '(%s) and (not hetatm) and name CA and alt +A' % (mobile)
target_ca_sele = '(%s) and (not hetatm) and name CA and alt +A' % (target)
if ter:
save = cmd.save
else:
save = save_pdb_without_ter
save(mobile_filename, mobile_ca_sele)
save(target_filename, target_ca_sele)
exe = cmd.exp_path(exe)
args = [exe, mobile_filename, target_filename] + args.split()
try:
process = subprocess.Popen(args, stdout=subprocess.PIPE)
except OSError:
print 'Cannot execute "%s", please provide full path to TMscore or TMalign executable' % (exe)
raise CmdException
r = None
re_score = re.compile(r'TM-score\s*=\s*(\d*\.\d*)')
rowcount = 0
matrix = []
line_it = iter(process.stdout)
for line in line_it:
if 4 >= rowcount > 0:
if rowcount >= 2:
a = map(float, line.split())
matrix.extend(a[2:5])
matrix.append(a[1])
rowcount += 1
elif line.lower().startswith(' -------- rotation matrix'):
rowcount = 1
elif line.startswith('(":" denotes'):
alignment = [line_it.next().rstrip() for i in range(3)]
else:
match = re_score.search(line)
if match is not None:
r = float(match.group(1))
if not quiet:
print line.rstrip()
if not quiet:
for i in range(0, len(alignment[0])-1, 78):
for line in alignment:
print line[i:i+78]
print ''
assert len(matrix) == 3*4
matrix.extend([0,0,0,1])
if int(transform):
cmd.transform_selection('byobject (%s)' % (mobile), matrix, homogenous=1)
# alignment object
if object is not None:
mobile_idx, target_idx = [], []
space = {'mobile_idx': mobile_idx, 'target_idx': target_idx}
cmd.iterate(mobile_ca_sele, 'mobile_idx.append("%s`%d" % (model, index))', space=space)
cmd.iterate(target_ca_sele, 'target_idx.append("%s`%d" % (model, index))', space=space)
for i, aa in enumerate(alignment[0]):
if aa == '-':
mobile_idx.insert(i, None)
for i, aa in enumerate(alignment[2]):
if aa == '-':
target_idx.insert(i, None)
if (len(mobile_idx) == len(target_idx) == len(alignment[2])):
cmd.rms_cur(
' '.join(idx for (idx, m) in zip(mobile_idx, alignment[1]) if m in ':.'),
' '.join(idx for (idx, m) in zip(target_idx, alignment[1]) if m in ':.'),
cycles=0, matchmaker=4, object=object)
else:
print 'Could not load alignment object'
if not quiet and r is not None:
print 'Found in output TM-score = %.4f' % (r)
os.remove(mobile_filename)
os.remove(target_filename)
return r
for a in xrange(1, 11):
cmd.create("trg", "ref", 1, a, quiet=0)
cmd.alter_state(a, "trg", "x=x+random()/2")
cmd.alter_state(a, "trg", "y=y+random()/2")
cmd.alter_state(a, "trg", "z=z+random()/2", quiet=0)
cmd.frame(1)
print "%8.3f" % cmd.fit("ref", "trg")
# asdf
for a in xrange(1, 14):
print a,
print "%8.3f" % cmd.fit("ref and resi %d" % a, "trg"),
print "%8.3f" % cmd.rms("ref", "trg"),
print "%8.3f" % cmd.rms_cur("ref", "trg")
cmd.frame(10)
print "%8.3f" % cmd.fit("ref", "trg")
for a in xrange(1, 14):
print a,
print "%8.3f" % cmd.fit("ref and resi %d" % a, "trg"),
print "%8.3f" % cmd.rms("ref", "trg"),
print "%8.3f" % cmd.rms_cur("ref", "trg")
a = 1
print "%8.3f" % cmd.fit("ref", "trg")
for b in xrange(1, 11):
cmd._dump_floats(cmd.intra_fit("trg and resi %d" % a, b))
cmd._dump_floats(cmd.intra_rms("trg", b))
native_pose = pose_from_pdb('3ixt.clean.pdb')
native_score = str(sf_dock(native_pose)) #load native complex for rmsd comparison
pymol_native_pose = '3ixt.clean.pdb'
cmd.load(pymol_native_pose,"native")
ofile.write("Native Score: " + native_score + '\n')
results = []
for file in sys.argv[2:]:
pose = pose_from_pdb(str(file))
score = str(sf_dock(pose))
cmd.load(file,"the_model")
cmd.align("native","the_model")
cmd.rms_cur('3ixt.clean','cleancomplex.5')
cmd.delete("the_model")
result = str(file) + ": " + score + " RMSD: " + str(rms)
results.append(result)
for x in range(len(results)):
ofile.write(results[x] + '\n')
ofile.close()
'''
ERROR: Error in core::pack::dunbrack::RotamericSingleResidueDunbrackLibrary::get_bbs_from_rsd():
Residues with rotamers dependent on a subset of backbone torsions must use NCAARotamerLibrarySpecifactions.
Could not get rotamer specification for ASN:AcetylatedNtermProteinFull.
#Add the header line to outfile.
outfile.write(', '.join(header))
outfile.write('\n')
#Load the "root" PDB file (ie. the file that will be compared to all other pdb files.)
cmd.load(rmsdroot, "root")
#Iterate over all files in the directory.
for filename in sorted(os.listdir(os.getcwd())):
#Initialize the list of scores.
score_vals = []
#If the file is a pdb file, load it as "decoy"
if filename.endswith(".pdb"):
cmd.load(filename, "decoy")
else: continue
#Calculate the RMSD between root and decoy over the atoms specified by selector.
rmsd = cmd.rms_cur("root and "+selector, "decoy and "+selector)
#Read the PDB file into lines.
lines=open(filename).readlines()
#Iterate over each scoreterm in scores.
for score_term in scores:
#Going backwards through the PDB file, find the line starting with the current scoreterm.
#Exit if the scoreterm isn't found in the file.
for line in reversed(lines):
if line.startswith('#'):# assumes all score terms are at the end of the file, no comments after them
sys.exit(score_term+" was not found in "+filename)
#Split the line into the term name and the score.
(this_term, score)=line.split()[:2]
#If the term matches the desired scoreterm, store the score in score_vals and break (continue to next term).
if this_term==score_term:
score_vals.append(score)
outfile.write(', '.join(header))
outfile.write('\n')
#Load the "root" PDB file (ie. the file that will be compared to all other pdb files.)
cmd.load(rmsdroot, "root")
#Iterate over all files in the directory.
for filename in sorted(os.listdir(os.getcwd())):
#Initialize the list of scores.
score_vals = []
#If the file is a pdb file, load it as "decoy"
if filename.endswith(".pdb"):
cmd.load(filename, "decoy")
else:
continue
#Calculate the RMSD between root and decoy over the atoms specified by selector.
rmsd = cmd.rms_cur("root and " + selector, "decoy and " + selector)
#Read the PDB file into lines.
lines = open(filename).readlines()
#Iterate over each scoreterm in scores.
for score_term in scores:
#Going backwards through the PDB file, find the line starting with the current scoreterm.
#Exit if the scoreterm isn't found in the file.
for line in reversed(lines):
if line.startswith(
'#'
): # assumes all score terms are at the end of the file, no comments after them
sys.exit(score_term + " was not found in " + filename)
#Split the line into the term name and the score.
(this_term, score) = line.split()[:2]
#If the term matches the desired scoreterm, store the score in score_vals and break (continue to next term).
def rmsdByRes(referenceProteinChain, sel, targetProteinChain):
"""
Update
Zhenting Gao on 7/28/2016
USAGE
rmsf referenceProteinChain, targetProteinChain, selection [,byres=0], [reference_state=1]
Calculate the RMSD for each residue pairs from two chains of the same protein from two crystal structures.
Workflow
Read reference and target pdb files
Align two structures
sel target, proA and chain A
#define target protein chain
sel refrence, proB and chain A
#define reference protein chain
align target, reference
#automatical alignment
Clean attributes
otherwise rms_cur will fail
"""
# Create temporary objects, exclude alternative conformation B
cmd.create("ref_gzt", referenceProteinChain + " and polymer and not alt B")
cmd.alter("ref_gzt", "chain='A'")
cmd.alter("ref_gzt", "segi=''")
cmd.create("target_gzt", targetProteinChain + " and polymer and not alt B")
cmd.alter("target_gzt", "chain='A'")
cmd.alter("target_gzt", "segi=''")
# cmd.align("target_gzt","ref_gzt",object="align")
# parameters
outputText = ""
res2Check = [
'HIS', 'ASP', 'ARG', 'PHE', 'GLN', 'GLU', 'LEU', 'ASN', 'TYR', 'VAL'
]
# select alpha carbon of selected residues in reference structure
calpha = cmd.get_model(sel + " and name CA and not alt B")
for g in calpha.atom:
# print g.resi+g.resn
if cmd.count_atoms("ref_gzt and polymer and resi " +
g.resi) == cmd.count_atoms(
"target_gzt and polymer and resi " + g.resi):
rmsdRes = cmd.rms_cur("ref_gzt and polymer and resi " + g.resi,
"target_gzt and polymer and resi " + g.resi)
rmsdResCa = cmd.rms_cur(
"ref_gzt and polymer and resi " + g.resi + " and name ca",
"target_gzt and polymer and resi " + g.resi + " and name ca")
rmsdResBackbone = cmd.rms_cur(
"ref_gzt and polymer and resi " + g.resi +
" and name ca+n+c+o", "target_gzt and polymer and resi " +
g.resi + " and name ca+n+c+o")
# calculate minimum rmsd
rmsdResMin = rmsdRes
if g.resn in res2Check:
flippedRes = flipAtomName("target_gzt and polymer and resi " +
g.resi)
rmsdFlippedRes = cmd.rms_cur(
"ref_gzt and polymer and resi " + g.resi, flippedRes)
if rmsdFlippedRes < rmsdRes:
rmsdResMin = rmsdFlippedRes
# print cmd.count_atoms("ref_gzt and polymer and resi "+g.resi),cmd.count_atoms("target_gzt and polymer and resi "+g.resi)
outputText += "%s,%s,%s,%.3f,%.3f,%.3f,%.3f\n" % (
targetProteinChain, g.resn, g.resi, rmsdRes, rmsdResCa,
rmsdResBackbone, rmsdResMin)
print outputText
# Destroy temporary objects
cmd.delete("ref_gzt target_gzt align res_gzt " + flippedRes)
# Save data into csv
outputFile = 'rmsdByRes_' + sel + '.csv'
f = open(outputFile, 'a')
if not is_non_zero_file(outputFile):
f.write(
"targe,residueName,residueId,allAtomRMSD,rmsdResCa,rmsdResBackbone,allAtomRMSDMin\n"
)
f.write(outputText)
f.close()
print "Results saved in " + outputFile
ofile = open('lig_rmsd_rel.txt', 'w')
native_complex = 'nat_relaxed.pdb'
for file in sys.argv[2:]:
if file != native_complex and file != 'natlig.pdb' and file != 'modlig.pdb':
print file
cmd.load(native_complex, 'native_complex')
cmd.load(file, 'model_complex')
cmd.align('native_complex', 'model_complex')
cmd.select('natlig', 'native_complex and chain P')
cmd.select('modlig', 'model_complex and chain C')
cmd.save('natlig.pdb', 'natlig')
cmd.save('modlig.pdb', 'modlig')
cmd.delete('model_complex')
cmd.delete('native_complex')
cmd.load('natlig.pdb', 'native_ligand')
cmd.load('modlig.pdb', 'model_ligand')
cmd.alter('all', 'chain=""')
cmd.alter('all', 'segi=""')
cmd.select('natligca', 'native_ligand and name ca')
cmd.select('modligca', 'model_ligand and name ca')
rms_ca = cmd.rms_cur('natligca', 'modligca')
ofile.write(file + ': ' + str(rms_ca) + '\n')
cmd.delete('native_ligand')
cmd.delete('model_ligand')
os.remove('natlig.pdb')
os.remove('modlig.pdb')
ofile.close()
def optAlign(sel1, sel2):
"""
optAlign performs the Kabsch alignment algorithm upon the alpha-carbons of two selections.
Example: optAlign MOL1 and i. 20-40, MOL2 and i. 102-122
Example 2: optAlign 1GGZ and i. 4-146 and n. CA, 1CLL and i. 4-146 and n. CA
Two RMSDs are returned. One comes from the Kabsch algorithm and the other from
PyMol based upon your selections.
By default, this program will optimally align the ALPHA CARBONS of the selections provided.
To turn off this feature remove the lines between the commented "REMOVE ALPHA CARBONS" below.
@param sel1: First PyMol selection with N-atoms
@param sel2: Second PyMol selection with N-atoms
"""
cmd.reset()
# make the lists for holding coordinates
# partial lists
stored.sel1 = []
stored.sel2 = []
# full lists
stored.mol1 = []
stored.mol2 = []
# now put the coordinates into a list
# partials
# -- REMOVE ALPHA CARBONS
sel1 = sel1 + " and N. CA"
sel2 = sel2 + " and N. CA"
# -- REMOVE ALPHA CARBONS
cmd.iterate_state(1, selector.process(sel1), "stored.sel1.append([x,y,z])")
cmd.iterate_state(1, selector.process(sel2), "stored.sel2.append([x,y,z])")
# full molecule
mol1 = cmd.identify(sel1, 1)[0][0]
mol2 = cmd.identify(sel2, 1)[0][0]
cmd.iterate_state(1, mol1, "stored.mol1.append([x,y,z])")
cmd.iterate_state(1, mol2, "stored.mol2.append([x,y,z])")
K = kabsch()
U, T1, T2, RMSD, c1, c2 = K.align(stored.sel1, stored.sel2, [])
stored.mol2 = map(
lambda v: [
T2[0] + ((v[0] * U[0][0]) + (v[1] * U[1][0]) +
(v[2] * U[2][0])), T2[1] +
((v[0] * U[0][1]) + (v[1] * U[1][1]) + (v[2] * U[2][1])), T2[2] + (
(v[0] * U[0][2]) + (v[1] * U[1][2]) + (v[2] * U[2][2]))
], stored.mol2)
#stored.mol1 = map(lambda v:[ v[0]+T1[0], v[1]+T1[1], v[2]+T1[2] ], stored.mol1)
stored.mol1 = map(lambda v: [v[0] + T1[0], v[1] + T1[1], v[2] + T1[2]],
stored.mol1)
cmd.alter_state(1, mol1, "(x,y,z)=stored.mol1.pop(0)")
cmd.alter_state(1, mol2, "(x,y,z)=stored.mol2.pop(0)")
cmd.alter('all', "segi=''")
cmd.alter('all', "chain=''")
print "RMSD=%f" % cmd.rms_cur(sel1, sel2)
print "MY RMSD=%f" % RMSD
cmd.hide('everything')
cmd.show('ribbon', sel1 + ' or ' + sel2)
cmd.color('gray70', mol1)
cmd.color('paleyellow', mol2)
cmd.color('red', 'visible')
cmd.show('ribbon', 'not visible')
cmd.center('visible')
cmd.orient()
cmd.zoom('visible')
def tmalign(mobile, target, mobile_state=1, target_state=1, args='',
exe='TMalign', ter=0, transform=1, object=None, quiet=0):
'''
DESCRIPTION
TMalign wrapper. You may also use this as a TMscore or MMalign wrapper
if you privide the corresponding executable with the "exe" argument.
Reference: Y. Zhang and J. Skolnick, Nucl. Acids Res. 2005 33, 2302-9
http://zhanglab.ccmb.med.umich.edu/TM-align/
ARGUMENTS
mobile, target = string: atom selections
mobile_state, target_state = int: object states {default: 1}
args = string: Extra arguments like -d0 5 -L 100
exe = string: Path to TMalign (or TMscore, MMalign) executable
{default: TMalign}
ter = 0/1: If ter=0, then ignore chain breaks because TMalign will stop
at first TER record {default: 0}
'''
import subprocess, tempfile, os, re
from .exporting import save_pdb_without_ter
ter, quiet = int(ter), int(quiet)
mobile_filename = tempfile.mktemp('.pdb', 'mobile')
target_filename = tempfile.mktemp('.pdb', 'target')
matrix_filename = tempfile.mktemp('.txt', 'matrix')
mobile_ca_sele = '(%s) and (not hetatm) and name CA and alt +A' % (mobile)
target_ca_sele = '(%s) and (not hetatm) and name CA and alt +A' % (target)
if ter:
save = cmd.save
else:
save = save_pdb_without_ter
save(mobile_filename, mobile_ca_sele, state=mobile_state)
save(target_filename, target_ca_sele, state=target_state)
exe = cmd.exp_path(exe)
args = [exe, mobile_filename, target_filename, '-m', matrix_filename] + args.split()
try:
process = subprocess.Popen(args, stdout=subprocess.PIPE,
universal_newlines=True)
lines = process.stdout.readlines()
except OSError:
print('Cannot execute "%s", please provide full path to TMscore or TMalign executable' % (exe))
raise CmdException
finally:
os.remove(mobile_filename)
os.remove(target_filename)
# TMalign >= 2012/04/17
if os.path.exists(matrix_filename):
lines += open(matrix_filename).readlines()
os.remove(matrix_filename)
r = None
re_score = re.compile(r'TM-score\s*=\s*(\d*\.\d*)')
rowcount = 0
matrix = []
line_it = iter(lines)
headercheck = False
alignment = []
for line in line_it:
if 4 >= rowcount > 0:
if rowcount >= 2:
a = list(map(float, line.split()))
matrix.extend(a[2:5])
matrix.append(a[1])
rowcount += 1
elif not headercheck and line.startswith(' * '):
a = line.split(None, 2)
if len(a) == 3:
headercheck = a[1]
elif line.lower().startswith(' -------- rotation matrix'):
rowcount = 1
elif line.startswith('(":" denotes'):
alignment = [next(line_it).rstrip() for i in range(3)]
else:
match = re_score.search(line)
if match is not None:
r = float(match.group(1))
if not quiet:
print(line.rstrip())
if not quiet:
for i in range(0, len(alignment[0])-1, 78):
for line in alignment:
print(line[i:i+78])
print('')
assert len(matrix) == 3*4
matrix.extend([0,0,0,1])
if int(transform):
for model in cmd.get_object_list('(' + mobile + ')'):
cmd.transform_object(model, matrix, state=0, homogenous=1)
# alignment object
if object is not None:
mobile_idx, target_idx = [], []
space = {'mobile_idx': mobile_idx, 'target_idx': target_idx}
cmd.iterate_state(mobile_state, mobile_ca_sele, 'mobile_idx.append("%s`%d" % (model, index))', space=space)
cmd.iterate_state(target_state, target_ca_sele, 'target_idx.append("%s`%d" % (model, index))', space=space)
for i, aa in enumerate(alignment[0]):
if aa == '-':
mobile_idx.insert(i, None)
for i, aa in enumerate(alignment[2]):
if aa == '-':
target_idx.insert(i, None)
if (len(mobile_idx) == len(target_idx) == len(alignment[2])):
cmd.rms_cur(
' '.join(idx for (idx, m) in zip(mobile_idx, alignment[1]) if m in ':.'),
' '.join(idx for (idx, m) in zip(target_idx, alignment[1]) if m in ':.'),
cycles=0, matchmaker=4, object=object)
else:
print('Could not load alignment object')
if not quiet:
if headercheck:
print('Finished Program:', headercheck)
if r is not None:
print('Found in output TM-score = %.4f' % (r))
return r
def rms_current(obj1,select1,obj2,select2):
"""
DESCRIPTION
"rms_current" allows the superpositioning of object1 onto object2 using
the atoms in selection1 and selection2 (side chains are ignored). The
residue names, residue numbers chain identifiers, segment identifiers,
and alt ids of selection1 are changed to match those in selection2,
temporarily. This allows the normal "rms_cur" command to work. They are
reset after "rms_cur" is run and two new selections are created showing
the selected atoms.
Be careful when creating your selection strings. Within the
selections, do not include the object name because the chain, residue
name, residue number etc. of selection1 of object1 are converted to
match those in selection2. If the object names are included in the
selections, no atoms will be selected since an atom cannot exist in
both object1 and object2 at the same time.
It is important that the beginning residue numbers specify the
aligned residues, but the ending numbers are not critical. The
shorter of the two selections is used in the rms_cur calculation.
USAGE
rms_current object1, selection1, object2, selection2
DO NOT include object names in selections!
EXAMPLES
rms_current 1xuu, c. a & (i. 296-309 or i. 335-340), 1ame, i. 8-21 or i. 47-52
"""
list_m = []
list_n = []
backbone = 'n. n+ca+c+o &! r. hoh+wat'
select1 = '(%s) & %s' % (select1,backbone)
select2 = '(%s) & %s' % (select2,backbone)
m=cmd.get_model("%s & %s" % (obj1,select1))
n=cmd.get_model("%s & %s" % (obj2,select2))
# for the atoms to be used in rms_cur:
# store id, chain, resn, resi, name, segi, alt
for at in m.atom:
list_m.append((at.id,at.chain,at.resn,at.resi,at.name,at.segi, at.alt))
for at in n.atom:
list_n.append((at.id,at.chain,at.resn,at.resi,at.name,at.segi, at.alt))
if len(m.atom) <= len(n.atom):
total = len(m.atom)
else:
total = len(n.atom)
# set a new segi for the atoms to be used in rms_cur command and to allow resetting later
seg_rms="1rms"
# change the chain,resn,resi,segi and alt of select1 to match select2
for i in range(total):
cmd.do("alter %s & id %s, chain='%s'" % (obj1,list_m[i][0],list_n[i][1]))
cmd.do("alter %s & id %s, resn='%s'" % (obj1,list_m[i][0],list_n[i][2]))
cmd.do("alter %s & id %s, resi=%s" % (obj1,list_m[i][0],list_n[i][3]))
cmd.do("alter %s & id %s, segi='%s'" % (obj1,list_m[i][0],seg_rms))
cmd.do("alter %s & id %s, alt='%s'" % (obj1,list_m[i][0],list_n[i][6]))
# change the segid for obj2 and select2
cmd.do("alter %s & id %s, segi='%s'" % (obj2,list_n[i][0],seg_rms))
print "Calculating RMS between %s and %s\n to %s and %s" % (obj1,select1,obj2,select2)
print "Altered to:"
print "%s & %s & segi %s\n" % (obj1,select2,seg_rms),
print "%s & %s & segi %s\n" % (obj2,select2,seg_rms),
print "--------------------------------------------\n"
rms = cmd.rms_cur("%s & %s & segi %s" % (obj1,select2,seg_rms),"%s & %s & segi %s" % (obj2,select2,seg_rms) ,quiet=0)
cmd.delete("%s_rms" % obj1)
cmd.delete("%s_rms" % obj2)
# create new objects to show the rms atoms
cmd.create("%s_rms" % obj1, "%s & %s & segi %s" % (obj1,select2,seg_rms))
cmd.create("%s_rms" % obj2, "%s & %s & segi %s" % (obj2,select2,seg_rms))
# reset chain,resn,resi,segi & alt of obj1 & select1 from stored list
for atoms_m in list_m:
cmd.do("alter %s & id %s, chain='%s'" % (obj1,atoms_m[0],atoms_m[1]))
cmd.do("alter %s & id %s, resn='%s'" % (obj1,atoms_m[0],atoms_m[2]))
cmd.do("alter %s & id %s, resi=%s" % (obj1,atoms_m[0],atoms_m[3]))
cmd.do("alter %s & id %s, segi='%s'" % (obj1,atoms_m[0],atoms_m[5]))
cmd.do("alter %s & id %s, alt='%s'" % (obj1,atoms_m[0],atoms_m[6]))
# reset segi of obj2 & select2 from stored list
for atoms_n in list_n:
cmd.do("alter %s & id %s, segi='%s'" % (obj2,atoms_n[0],atoms_n[5]))
print "RMSD for selection %s of %s onto \n selection %s of %s = %6.3f" % (select1, obj1, select2, obj2, rms)
