def align(inputs):
""""""
try:
ref_pdb, ref_mol, other_pdb, input_dir = inputs
ref = Protein.from_file(os.path.join(input_dir, f"{ref_pdb}.pdb"))
other_path = os.path.join(input_dir, f"{other_pdb}.pdb")
other = Protein.from_file(other_path)
if ref_mol:
ref_mol_obj = [
lig for lig in ref.ligands
if lig.identifier.split(":")[1] == ref_mol
][0]
ref_bind_site = Protein.BindingSiteFromMolecule(
protein=ref, molecule=ref_mol_obj, distance=12)
else:
ref_bind_site = None
chain_superposition = Protein.ChainSuperposition()
# other chains already striped
rms, X = chain_superposition.superpose(ref.chains[0],
other.chains[0],
binding_site1=ref_bind_site)
with io.MoleculeWriter(other_path) as w:
w.write(other)
return rms
except:
return 999
def align_references(self):
"""
For all the EnsembleResults in the MultipleEnsemble, aligns the reference structure of each EnsembleResult to that
of the reference result of the MultipleEnsemble
:return:
"""
# Get the binding sites of the reference structure for each ensemble
self.reference_ensemble.reference_binding_site = self.get_binding_site(
self.reference_ID)
for key, ens in self.ensembles.items():
print(key, ens.reference_ID)
ens.reference_binding_site = self.get_binding_site(
ens.reference_ID)
ref_bs = self.reference_ensemble.reference_binding_site
self.reference_ensemble._save_protein(ref_bs)
rmsds = []
for key, ens in self.ensembles.items():
chain_superposition = Protein.ChainSuperposition(
self.alignment_settings)
(rmsd, transformation) = chain_superposition.superpose(
ref_bs.protein.chains[0],
ens.reference_binding_site.protein.chains[0], ref_bs)
#ens.process_ensemble_proteins()
rmsds.append("RMSD ref: {} {} query: {} {} = {:6.4f}".format(
self.reference_ensemble.ensemble_ID,
self.reference_ensemble.reference_ID["ID"], ens.ensemble_ID,
ens.reference_ID["ID"], rmsd))
print(rmsds)
self.aligned_references = True
self.ensemble_reference_RMSD = rmsds
def align_ensemble(self, bs_list):
"""
Aligns all elements of the ensemble to the reference structure
:param list bs_list: python list of :class: 'ccdc.Protein.BindingSiteFromListOfResidues' instances
:return: list of aligned :class: 'ccdc.Protein.BindingSiteFromListOfResidues instances'
"""
print("Aligning ensemble proteins for {}".format(self.ensemble_ID))
# Keep track of the RMSDs between the reference and the ensemble members
rmsd_list = []
# Copy the binding site to avoid changing it during superposition - investigate if actually needed.
e_ref_bs = self.reference_binding_site
for bs in bs_list:
print(bs.identifier)
chain_superposition = Protein.ChainSuperposition(
self.alignment_settings)
try:
(rmsd, transformation) = chain_superposition.superpose(
e_ref_bs.protein.chains[0],
bs.protein.chains[
0], # change to bs.protein.chains[0] if using binding site
e_ref_bs)
except RuntimeError as e:
print("alignment failed for protein {}".format(bs.identifier))
rmsd_list.append(rmsd)
# Add RMSD column to the protein dataframe
self.protein_data["RMSD"] = rmsd_list
self.aligned = True
return bs_list
def _align_proteins(reference, reference_chain, targets):
"""
align proteins by chain
:param `ccdc.protein.Protein` reference: align to me
:param str reference_chain: align to this chain
:param list targets: list of `ccdc.protein.Protein`
:return tup: list(:class:`ccdc.protein.Protein`) and list (:classa`ccdc.molecule.Molecule`)
"""
print("Aligning proteins to {}, chain {}...".format(
reference.identifier, reference_chain))
aligned_prots = []
aligned_ligands = []
reference = Protein.from_file(reference.fname)
reference.add_hydrogens()
for t in tqdm(targets):
prot = Protein.from_file(t.fname)
prot.detect_ligand_bonds()
prot.add_hydrogens()
for l in prot.ligands:
if str(t.clustered_ligand) == str(
l.identifier.split(":")[1][0:3]):
try:
bs = Protein.BindingSiteFromMolecule(protein=prot,
molecule=l,
distance=6)
chain = bs.residues[0].identifier.split(":")[0]
except:
break
break
else:
continue
if not chain:
print("\n {} failed! No chain detected".format(
t.identifier))
break
try:
binding_site_superposition = Protein.ChainSuperposition()
(bs_rmsd,
bs_transformation) = binding_site_superposition.superpose(
reference[reference_chain], prot[chain])
aligned_prots.append(prot)
for lig in prot.ligands:
if str(t.clustered_ligand) == str(
lig.identifier.split(":")[1][0:3]):
if chain == str(lig.identifier.split(":")[0]):
aligned_ligands.append(lig)
except IndexError:
print("\n {} failed!".format(t.identifier))
continue
return aligned_prots, aligned_ligands
def _align(reference, target, reference_chain='A', target_chain='A'):
"""
sequence based alignment of target to reference
:return:
"""
target.detect_ligand_bonds()
target.add_hydrogens()
binding_site_superposition = Protein.ChainSuperposition()
binding_site_superposition.superpose(reference[reference_chain],
target[target_chain])
return target
def run_one(self, target_chain, mol_writer):
'''Superpose a target chain onto the reference chain
:param target_chain: The target chain dictionary
:param mol_writer: Superposition file writer
'''
target_protein = self.load_target(target_chain['pdb_id'])
print('Target protein {} chain {} identity {}% similarity {}%'.format(
target_protein.identifier, target_protein[target_chain['chain_id']].identifier,
target_chain['identity'], target_chain['similarity']))
binding_site_superposition = Protein.ChainSuperposition()
if self.args.sequence_alignment_tool is not None:
binding_site_superposition.settings.sequence_search_tool = self.args.sequence_search_tool
binding_site_superposition.settings.sequence_alignment_tool = self.args.sequence_alignment_tool
binding_site_superposition.settings.superposition_atoms = self.args.superposition_atoms
if self.reference_binding_site is not None:
(bs_rmsd, bs_transformation) = binding_site_superposition.superpose(
self.reference_protein[self.reference_chain_id],
target_protein[target_chain['chain_id']],
self.reference_binding_site)
target_chain['rmsd'] = '{:.4f}'.format(bs_rmsd)
print('Binding site RMSD is: {}'.format(target_chain['rmsd']))
print('Transformation matrix is: {}'.format(bs_transformation))
else:
(chain_rmsd, chain_transformation) = binding_site_superposition.superpose(
self.reference_protein[self.reference_chain_id],
target_protein[target_chain['chain_id']])
target_chain['rmsd'] = '{:.4f}'.format(chain_rmsd)
print('Chain RMSD is: {}'.format(target_chain['rmsd']))
print('Transformation matrix is: {}'.format(chain_transformation))
if self.superposition_output == 'full_protein':
target_molecule = target_protein
else:
target_molecule = Protein.BindingSiteFromMolecule(
target_protein, self.reference_ligand, self.args.radius_around_ligand
)
target_entry = Entry.from_molecule(target_molecule,
rmsd='{}'.format(target_chain['rmsd']),
identity='{}%'.format(target_chain['identity']),
similarity='{}%'.format(target_chain['similarity']))
mol_writer.write_entry(target_entry)