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)