def applyTMAlign (substruct): p_dir_dataset = pathManage.dataset(substruct) l_folder = listdir(p_dir_dataset) for ref_folder in l_folder: if len (ref_folder) != 4: continue l_pdbfile = listdir(p_dir_dataset + ref_folder + "/") p_pdb_ref = pathManage.findPDBRef(p_dir_dataset + ref_folder + "/") for pdbfile in l_pdbfile: # try if PDB not ligand if len(pdbfile.split ("_")[0]) != 4 or not search (".pdb", pdbfile): continue # same alignment elif p_dir_dataset + ref_folder + "/" + pdbfile == p_pdb_ref: continue else: p_file_pdb = p_dir_dataset + ref_folder + "/" + pdbfile p_dir_align = pathManage.alignmentOutput(substruct + "/" + p_pdb_ref.split ("/")[-1][:-4] + "__" + p_file_pdb.split ("/")[-1][:-4]) # superimpose runOtherSoft.runTMalign(p_file_pdb, p_pdb_ref, p_dir_align) return 1
def applyTMAlign(substruct): p_dir_dataset = pathManage.dataset(substruct) l_folder = listdir(p_dir_dataset) for ref_folder in l_folder: if len(ref_folder) != 4: continue l_pdbfile = listdir(p_dir_dataset + ref_folder + "/") p_pdb_ref = pathManage.findPDBRef(p_dir_dataset + ref_folder + "/") for pdbfile in l_pdbfile: # try if PDB not ligand if len(pdbfile.split("_")[0]) != 4 or not search(".pdb", pdbfile): continue # same alignment elif p_dir_dataset + ref_folder + "/" + pdbfile == p_pdb_ref: continue else: p_file_pdb = p_dir_dataset + ref_folder + "/" + pdbfile p_dir_align = pathManage.alignmentOutput( substruct + "/" + p_pdb_ref.split("/")[-1][:-4] + "__" + p_file_pdb.split("/")[-1][:-4]) # superimpose runOtherSoft.runTMalign(p_file_pdb, p_pdb_ref, p_dir_align) return 1
def searchReplacement (smile, PDB_query, PDB_ref, name_ligand, in_cycle = 0) : metal_find = searchMetal (smile) if metal_find != 0 : p_dir_dataset = pathManage.dataset(name_ligand + "/" + PDB_ref) l_PDB_query = pathManage.findPDBQueryDataset(p_dir_dataset) for p_query in l_PDB_query : if search (PDB_query, p_query): p_PDB_query = p_query break if "p_PDB_query" in locals() : l_atom_parsed = parsePDB.loadCoordSectionPDB(p_query) l_ions_PDB = parsePDB.retrieveListIon(l_atom_parsed) if metal_find in l_ions_PDB : l_atom_ion = parsePDB.retrieveLigand(l_atom_parsed, metal_find) filout = open (p_dir_dataset + str(metal_find) + "_" + p_query.split("/")[-1], "w") for atom_ion in l_atom_ion : writePDBfile.coordinateSection(filout, atom_ion, recorder = "HETATM", header = str(metal_find), connect_matrix = 0) filout.close () return "metal", metal_find if in_cycle == 0: if searchRing(smile) == 1 : return "cycle","" if searchP(smile) == 1 : return "P", "" elif searchB(smile) == 1 : return "B","" elif searchF (smile) == 1 : return "F", "" elif searchCl (smile) == 1 : return "Cl", "" elif searchBr (smile) == 1 : return "Br", "" elif searchBe (smile) == 1 : return "Be", "" elif searchNO2 (smile) == 1 : return "NO2", "" elif searchSulfonyl(smile) == 1: return "SO2","" elif searchS (smile) == 1 : return "S", "" elif searchCON (smile) == 1 : return "CON","" elif searchCarboxy (smile) == 1 : return "COO","" elif searchConly(smile) == 1 : return "onlyC", "" elif searchCandO (smile) == 1 : return "C+O", "" elif searchCandN (smile) == 1 : return "C+N", "" elif searchCandOandN (smile) == 1 : return "C+O+N", "" return "other" ,""
def datasetPreparation (ligand_ID, clean = 1): p_dir_dataset = pathManage.dataset(ligand_ID) l_folder = listdir(p_dir_dataset) indent = 0 for ref_folder in l_folder : # file include in dataset folder if len (ref_folder) != 4: continue l_pdbfile = listdir(p_dir_dataset + ref_folder + "/") indent = indent + 1 print ref_folder, indent # clean repertory -> only PDB ref and PDB l_pdbfile = listdir(p_dir_dataset + ref_folder + "/") if clean == 1 : for pdbfile in l_pdbfile : p_file_pdb = p_dir_dataset + ref_folder + "/" + pdbfile if not search (".pdb", pdbfile ) or search ("subref", pdbfile) or len (pdbfile.split("_")[0]) == 3: remove (p_file_pdb) l_pdbfile = listdir(p_dir_dataset + ref_folder + "/") for pdbfile in l_pdbfile : p_file_pdb = p_dir_dataset + ref_folder + "/" + pdbfile # extract ligand in PDB l_ligand = parsePDB.retrieveListLigand(p_file_pdb) # print l_ligand if l_ligand == []: continue else: l_atom_pdb_parsed = parsePDB.loadCoordSectionPDB(p_file_pdb) for name_ligand in l_ligand : l_lig_parsed = parsePDB.retrieveLigand(l_atom_pdb_parsed, name_ligand) if l_lig_parsed == [] : continue p_filout_ligand = p_dir_dataset + ref_folder + "/" + name_ligand + "_" + path.split(p_file_pdb)[1] writePDBfile.coordinateSection(p_filout_ligand , l_lig_parsed[0], "HETATM", header=0 , connect_matrix = 1) # ligand_ID write for shaep # print p_dir_dataset + ref_folder + "/" p_lig_ref = pathManage.findligandRef(p_dir_dataset + ref_folder + "/", ligand_ID) if p_lig_ref == 0: continue # print p_lig_ref lig_ref_parsed = parsePDB.loadCoordSectionPDB(p_lig_ref) d_l_atom_substruct = substructTools.retrieveSubstruct(lig_ref_parsed, ligand_ID) # case with AMP without phosphate if d_l_atom_substruct == {}: continue # write ligand_ID for subs in d_l_atom_substruct.keys (): p_filout_substruct = p_dir_dataset + ref_folder + "/subref_" + subs + "_" + ref_folder + ".pdb" writePDBfile.coordinateSection(p_filout_substruct , d_l_atom_substruct [subs], "HETATM", header=0 , connect_matrix = 1) return 1
def ionIdentification(name_ligand): """ step 4 search in the close environment if metal is here compute distance and angles """ # in folder p_dir_dataset = pathManage.dataset(name_ligand) p_filout = pathManage.result(name_ligand) + "ionsAnalysis.txt" ionSearch.analyseIons(p_dir_dataset, name_ligand, p_filout)
def classifRefProtein(pr_dataset, l_lig, thresold_identity=30.0, thresold_similarity=30.0): pr_out = pathManage.result("clasifRef") # case fasta file pr_align_seq = pathManage.generatePath(pr_out + "alignSeq/") l_p_fasta = [] for lig in l_lig: pr_dataset = pathManage.dataset(lig) l_file_by_lig = listdir(pr_dataset) l_pr_ref_by_lig = [pr_dataset + x for x in l_file_by_lig] for pr_ref_by_lig in l_pr_ref_by_lig: PDB_folder = pr_ref_by_lig.split("/")[-1] try: l_file = listdir(pr_ref_by_lig) except: continue for file_ref in l_file: if search("^" + PDB_folder, file_ref): PDB_ID = file_ref[0:-4] PDB_ID = PDB_ID[0:4].lower() + PDB_ID[4:] # PDB ID with chain associated p_fasta = downloadFile.importFasta( PDB_ID, pr_align_seq, dir_by_PDB=0, debug=1, fastaGlobal="/home/borrel/Yue_project/pdb_seqres.txt") l_p_fasta.append(p_fasta) break d_outNeedle = applyNeedleList(l_p_fasta, pr_align_seq) # writeMatrix writeMatrixFromDico(d_outNeedle, pr_out + "matrixSimilarSeq", "similarity") writeMatrixFromDico(d_outNeedle, pr_out + "matrixIDSeq", "identity") #Group reference -> l 209 p_group_id = GroupRef( d_outNeedle, "identity", pr_out + "groupIdentity" + "_" + str(thresold_identity) + ".txt", thresold_identity, l_lig) p_group_sim = GroupRef( d_outNeedle, "similarity", pr_out + "groupSimilarity" + "_" + str(thresold_similarity) + ".txt", thresold_similarity, l_lig) # merge not alone prot MergeGroup(p_group_id) MergeGroup(p_group_sim)
def ionIdentification (name_ligand): """ step 4 search in the close environment if metal is here compute distance and angles """ # in folder p_dir_dataset = pathManage.dataset(name_ligand) p_filout = pathManage.result(name_ligand) + "ionsAnalysis.txt" ionSearch.analyseIons (p_dir_dataset, name_ligand, p_filout)
def builtDatasetGlobal(p_list_ligand, ligand_ID, thresold_RX=2.5, thresold_blast=1e-4, verbose=1): # directory with dataset p_dir_dataset = pathManage.dataset(ligand_ID) # directory with result p_dir_result = pathManage.result(ligand_ID + "/datasetBuilding") # first extract reference d_dataset = extractReference(p_list_ligand, p_dir_dataset, p_dir_result, ligand_ID) # file with name and family analysis.familyPDBRef(d_dataset, p_dir_dataset + "family_PDB.txt") if verbose: toolViewStructDataset(d_dataset) # select reference # remove RX and same chain p_dir_align = pathManage.result(ligand_ID + "/datasetBuilding/aligmentRef") filterReferenceByOne(d_dataset, p_dir_align, ligand_ID, thresold_RX=thresold_RX) if verbose: toolViewStructDataset(d_dataset) # conserve only unique protein filterGlobalDataset(d_dataset, p_dir_align) if verbose: toolViewStructDataset(d_dataset) # run blast by sequence conserved p_dir_blast = pathManage.result(ligand_ID + "/datasetBuilding/blast") RunBlast.globalRun(d_dataset, p_dir_blast) if verbose: toolViewStructDataset(d_dataset) # filter by e-value and RX filterBlastResult(d_dataset, p_dir_dataset, ligand_ID, thresold_RX=thresold_RX, thresold_blast=thresold_blast) if verbose: toolViewStructDataset(d_dataset) # clean folder dataset cleanFolderDataset(d_dataset, p_dir_dataset)
def builtDatasetGlobal (p_list_ligand, ligand_ID, thresold_RX = 2.5, thresold_blast = 1e-4, verbose = 1 ): # directory with dataset p_dir_dataset = pathManage.dataset(ligand_ID) # directory with result p_dir_result = pathManage.result(ligand_ID + "/datasetBuilding") # first extract reference d_dataset = extractReference (p_list_ligand, p_dir_dataset, p_dir_result, ligand_ID) # file with name and family analysis.familyPDBRef (d_dataset, p_dir_dataset + "family_PDB.txt") if verbose : toolViewStructDataset (d_dataset) # select reference # remove RX and same chain p_dir_align = pathManage.result(ligand_ID + "/datasetBuilding/aligmentRef") filterReferenceByOne (d_dataset, p_dir_align, ligand_ID, thresold_RX = thresold_RX) if verbose : toolViewStructDataset (d_dataset) # conserve only unique protein filterGlobalDataset (d_dataset, p_dir_align) if verbose : toolViewStructDataset (d_dataset) # run blast by sequence conserved p_dir_blast = pathManage.result(ligand_ID + "/datasetBuilding/blast") RunBlast.globalRun (d_dataset, p_dir_blast) if verbose : toolViewStructDataset (d_dataset) # filter by e-value and RX filterBlastResult (d_dataset, p_dir_dataset,ligand_ID, thresold_RX = thresold_RX, thresold_blast = thresold_blast) if verbose : toolViewStructDataset (d_dataset) # clean folder dataset cleanFolderDataset (d_dataset, p_dir_dataset)
def classifRefProtein (pr_dataset, l_lig, thresold_identity = 30.0, thresold_similarity = 30.0): pr_out = pathManage.result("clasifRef") # case fasta file pr_align_seq = pathManage.generatePath(pr_out + "alignSeq/") l_p_fasta = [] for lig in l_lig : pr_dataset = pathManage.dataset(lig) l_file_by_lig = listdir(pr_dataset) l_pr_ref_by_lig =[pr_dataset + x for x in l_file_by_lig] for pr_ref_by_lig in l_pr_ref_by_lig : PDB_folder = pr_ref_by_lig.split ("/")[-1] try : l_file = listdir(pr_ref_by_lig) except : continue for file_ref in l_file : if search("^" + PDB_folder, file_ref) : PDB_ID = file_ref[0:-4] PDB_ID = PDB_ID[0:4].lower () + PDB_ID[4:] # PDB ID with chain associated p_fasta = downloadFile.importFasta(PDB_ID, pr_align_seq, dir_by_PDB = 0, debug = 1, fastaGlobal = "/home/borrel/Yue_project/pdb_seqres.txt") l_p_fasta.append (p_fasta) break d_outNeedle = applyNeedleList (l_p_fasta, pr_align_seq) # writeMatrix writeMatrixFromDico (d_outNeedle, pr_out + "matrixSimilarSeq", "similarity" ) writeMatrixFromDico (d_outNeedle, pr_out + "matrixIDSeq", "identity" ) #Group reference -> l 209 p_group_id = GroupRef (d_outNeedle, "identity", pr_out + "groupIdentity" +"_" + str (thresold_identity) + ".txt", thresold_identity, l_lig) p_group_sim = GroupRef (d_outNeedle, "similarity", pr_out + "groupSimilarity" +"_" + str (thresold_similarity) + ".txt", thresold_similarity, l_lig) # merge not alone prot MergeGroup (p_group_id) MergeGroup (p_group_sim)
def analysisBS (name_lig, ID_seq = '0.0', debug = 1): pr_result = pathManage.result(name_lig) pr_out = pathManage.result(name_lig + "/sameBS") # log files p_log_file = pr_out + "log.txt" filout_log = open (p_log_file, "w") # dictionnar with files d_file_BS = {} d_file_BS["global"] = open (pr_out + name_lig + "_", "w") d_file_BS["global"].write ("name_bs\tRMSD_prot\tRMSD_BS_ca\tRMSD_BS_all\tD_max\tl_at_BS\tidentic\n") d_file_BS["summary"] = open (pr_out + "summary.txt", "w") pr_dataset = pathManage.dataset(name_lig) l_folder_ref = listdir(pr_result) nb_BS = 0 nb_BS_filtered = 0 nb_same_BS = 0 for PDB_ref in l_folder_ref : if debug : print PDB_ref if len (PDB_ref) != 4 : continue p_pdb_ref = pathManage.findPDBRef(pr_dataset + PDB_ref + "/") l_p_query = pathManage.findPDBQueryTransloc (pathManage.result(name_lig) + PDB_ref + "/") if debug : print l_p_query for p_query in l_p_query : # read TM Align if debug : print p_query.split ("/")[-1][7:-4] p_TMalign = pathManage.alignmentOutput(name_lig) + p_pdb_ref.split ("/")[-1][0:-4] + "__" + p_query.split ("/")[-1][7:-4] + "/RMSD" try : score_align = parseTMalign.parseOutputTMalign(p_TMalign) except : filout_log.write ("ERROR TM align " + p_TMalign + "\n") continue nb_BS = nb_BS + 1 if score_align["IDseq"] >= ID_seq : nb_BS_filtered = nb_BS_filtered + 1 l_p_substruct_ref = pathManage.findSubstructRef (pr_dataset + PDB_ref + "/", name_lig) # sub BS for p_substruct_ref in l_p_substruct_ref : struct_substitued = p_substruct_ref.split ("_")[-2] # write header if not struct_substitued in d_file_BS.keys () : d_file_BS[struct_substitued] = open (pr_out + name_lig + "_" + struct_substitued + "_", "w") d_file_BS[struct_substitued].write ("name_bs\tRMSD_prot\tRMSD_BS_ca\tRMSD_BS_all\tD_max\tl_at_BS\tidentic\n") RMSD_bs = analysis.computeRMSDBS (p_pdb_ref, p_query, p_substruct_ref, pr_out) if RMSD_bs != [] : d_file_BS[struct_substitued].write (p_substruct_ref.split("/")[-1][0:-4] + "_*_" + p_query.split ("/")[-1][0:-4] + "\t" + str(score_align["RMSD"]) + "\t" + str(RMSD_bs[1]) + "\t" + str(RMSD_bs[0]) + "\t" + str(RMSD_bs[2]) + "\t" + str(RMSD_bs[-2]) + "\t" + str(RMSD_bs[-1]) + "\n") p_ligand_ref = pathManage.findligandRef(pr_dataset + PDB_ref + "/", name_lig) RMSD_bs_lig = analysis.computeRMSDBS (p_pdb_ref, p_query, p_ligand_ref, pr_out) if RMSD_bs_lig != [] : d_file_BS["global"].write (p_ligand_ref.split("/")[-1][0:-4] + "_*_" + p_query.split ("/")[-1][0:-4] + "\t" + str(score_align["RMSD"]) + "\t" + str(RMSD_bs_lig[1]) + "\t" + str(RMSD_bs_lig[0]) + "\t" + str(RMSD_bs_lig[2]) + "\t" + str(RMSD_bs_lig[-2]) + "\t" + str(RMSD_bs_lig[-1]) + "\n") if RMSD_bs_lig [-1] == 1 : nb_same_BS = nb_same_BS + 1 # write summary d_file_BS["summary"].write ("BS global: " + str (nb_BS) + "\n") d_file_BS["summary"].write ("BS - IDseq " + str (ID_seq) + "%: " + str (nb_BS_filtered) + "\n") d_file_BS["summary"].write ("BS - same atom number: " + str (nb_same_BS) + "\n") filout_log.close () # close files and run histograms for k_dico in d_file_BS.keys () : p_file = d_file_BS[k_dico].name d_file_BS[k_dico].close () if name_lig == "ATP" : runOtherSoft.RhistogramRMSD(p_file, max_RMSD = 5.0) elif name_lig == "ADP" : runOtherSoft.RhistogramRMSD(p_file, max_RMSD = 4.0) elif name_lig == "AMP" : runOtherSoft.RhistogramRMSD(p_file, max_RMSD = 4.0) else : runOtherSoft.RhistogramRMSD(p_file, max_RMSD = 3.5) return 1
def retrieveSubstructSuperimposed(name_lig, thresold_BS=4.5, thresold_superimposed_ribose=2.5, thresold_superimposed_pi=3, thresold_shaep=0.4): # ouput p_dir_dataset = pathManage.dataset(name_lig) p_dir_result = pathManage.result(name_lig) l_folder_ref = listdir(p_dir_dataset) # log control p_log = open(p_dir_result + "log_superimposed.txt", "w") # control extraction d_control = {} d_control["pr ref"] = 0 d_control["lig query"] = 0 d_control["subref"] = {} d_control["subref empty"] = {} d_control["out sheap"] = {} filout_control = open(p_dir_result + "quality_extraction.txt", "w") # stock smile code d_smile = {} # sheap control d_filout_sheap = {} d_filout_sheap["list"] = [p_dir_result + "shaep_global.txt"] d_filout_sheap["global"] = open(p_dir_result + "shaep_global.txt", "w") d_filout_sheap["global"].write( "name\tbest_similarity\tshape_similarity\tESP_similarity\n") for ref_folder in l_folder_ref: # control folder reference name if len(ref_folder) != 4: p_log.write("[ERROR folder] -> " + ref_folder + "\n") continue # reference p_lig_ref = pathManage.findligandRef(p_dir_dataset + ref_folder + "/", name_lig) try: lig_ref_parsed = parsePDB.loadCoordSectionPDB(p_lig_ref, "HETATM") # print len (lig_ref_parsed) except: p_log.write("[ERROR ligand ref] -> " + p_lig_ref + "\n") continue #control d_control["pr ref"] = d_control["pr ref"] + 1 # output by reference p_dir_result_ref = pathManage.result(name_lig + "/" + ref_folder) d_filout_superimposed = {} d_filout_superimposed["global"] = open( p_dir_result_ref + "all_ligand_aligned.pdb", "w") d_filout_superimposed["sheap"] = open( p_dir_result_ref + "all_ligand_aligned_" + str(thresold_shaep) + ".pdb", "w") # write lig ref -> connect matrix corrrect in all reference and all sheap writePDBfile.coordinateSection(d_filout_superimposed["global"], lig_ref_parsed, "HETATM", connect_matrix=1) writePDBfile.coordinateSection(d_filout_superimposed["sheap"], lig_ref_parsed, "HETATM", connect_matrix=1) # inspect folder dataset l_pdbfile = listdir(p_dir_dataset + ref_folder + "/") for pdbfile in l_pdbfile: # no ligand file if len(pdbfile.split("_")) == 1: continue pdbfile = pdbfile[:-4] # remove extention if len(pdbfile.split("_")[0]) == 3 and len(pdbfile.split( "_")[1]) == 4 and pdbfile.split("_")[1] != ref_folder: p_lig = p_dir_dataset + ref_folder + "/" + pdbfile + ".pdb" if p_lig_ref != p_lig: # pass case where ligand replace same ligand -> does not need run if pdbfile.split("_")[0] == name_lig: p_log.write("[REMOVE] -> same ligand substituate") continue # parsed ligand query lig_parsed = parsePDB.loadCoordSectionPDB(p_lig, "HETATM") # find matrix of rotation p_matrix = pathManage.findMatrix(p_lig_ref, p_lig, name_lig) # control file matrix exist if not path.exists(p_matrix): p_log.write("[ERROR] -> Matrix transloc " + p_lig_ref + " " + p_lig + " " + name_lig + "\n") continue # control d_control["lig query"] = d_control["lig query"] + 1 # find the path of complex used p_complex = p_dir_dataset + ref_folder + "/" + p_lig.split( "/")[-1][4:] # ligand rotated -> change the referentiel superposeStructure.applyMatrixLigand(lig_parsed, p_matrix) # use substruct l_p_substruct_ref = pathManage.findSubstructRef( pathManage.dataset(name_lig) + ref_folder + "/", name_lig) for p_substruct_ref in l_p_substruct_ref: # ribose or phosphate struct_type = p_substruct_ref.split("_")[-2] substruct_parsed = parsePDB.loadCoordSectionPDB( p_substruct_ref, "HETATM") l_atom_substituate = neighborSearch.searchNeighborAtom( substruct_parsed, lig_parsed, struct_type, p_log, thresold_superimposed_ribose= thresold_superimposed_ribose, thresold_superimposed_pi=thresold_superimposed_pi) # control find if len(l_atom_substituate) == 0: if not struct_type in d_control[ "subref empty"].keys(): d_control["subref empty"][struct_type] = 1 else: d_control["subref empty"][ struct_type] = d_control["subref empty"][ struct_type] + 1 continue else: if not struct_type in d_control["subref"].keys(): d_control["subref"][struct_type] = 1 else: d_control["subref"][struct_type] = d_control[ "subref"][struct_type] + 1 # write PDB file, convert smile p_substituate_pdb = p_dir_result_ref + "substituent_" + pdbfile.split( "_")[0] + "_" + pdbfile.split( "_")[1] + "_" + struct_type + ".pdb" writePDBfile.coordinateSection(p_substituate_pdb, l_atom_substituate, recorder="HETATM", header=0, connect_matrix=1) # sheap reference on part of ligand p_sheap = runOtherSoft.runShaep( p_substruct_ref, p_substituate_pdb, p_substituate_pdb[0:-4] + ".hit", clean=0) val_sheap = parseShaep.parseOutputShaep(p_sheap) if val_sheap == {}: p_log.write("[ERROR] -> ShaEP " + p_substituate_pdb + " " + p_substruct_ref + "\n") if not struct_type in d_control[ "out sheap"].keys(): d_control["out sheap"][struct_type] = 1 else: d_control["out sheap"][ struct_type] = d_control["out sheap"][ struct_type] + 1 continue # control thresold sheap if not struct_type in d_filout_sheap.keys(): d_filout_sheap[struct_type] = {} d_filout_sheap[struct_type] = open( p_dir_result + "shaep_global_" + struct_type + ".txt", "w") d_filout_sheap[struct_type].write( "name\tbest_similarity\tshape_similarity\tESP_similarity\n" ) d_filout_sheap["list"].append( p_dir_result + "shaep_global_" + struct_type + ".txt") # to improve with python function # write value in ShaEP control d_filout_sheap[struct_type].write( ref_folder + "_" + str(pdbfile.split("_")[1]) + "_" + struct_type + "_" + str(pdbfile.split("_")[0]) + "\t" + str(val_sheap["best_similarity"]) + "\t" + str(val_sheap["shape_similarity"]) + "\t" + str(val_sheap["ESP_similarity"]) + "\n") d_filout_sheap["global"].write( ref_folder + "_" + str(pdbfile.split("_")[1]) + "_" + struct_type + "_" + str(pdbfile.split("_")[0]) + "\t" + str(val_sheap["best_similarity"]) + "\t" + str(val_sheap["shape_similarity"]) + "\t" + str(val_sheap["ESP_similarity"]) + "\n") # rename file substituent with shaEP value rename( p_substituate_pdb, p_substituate_pdb[:-4] + "_" + str(val_sheap["best_similarity"]) + ".pdb") # rename and change the file name p_substituate_pdb = p_substituate_pdb[:-4] + "_" + str( val_sheap["best_similarity"]) + ".pdb" # write all substruct in global file writePDBfile.coordinateSection( d_filout_superimposed["global"], lig_parsed, recorder="HETATM", header=str(p_lig.split("/")[-1]) + "_" + str(val_sheap["best_similarity"]), connect_matrix=1) # control sheap thresold if float(val_sheap["best_similarity"] ) >= thresold_shaep: # write subligand superimposed selected in global files writePDBfile.coordinateSection( d_filout_superimposed["sheap"], lig_parsed, recorder="HETATM", header=str(p_lig.split("/")[-1]) + "_" + str(val_sheap["best_similarity"]), connect_matrix=1) ############ # write BS # ############ # not only protein superimposed -> also ion and water l_atom_complex = parsePDB.loadCoordSectionPDB( p_complex) superposeStructure.applyMatrixProt( l_atom_complex, p_matrix) p_file_cx = p_dir_result_ref + "CX_" + p_lig.split( "/")[-1] # write CX writePDBfile.coordinateSection( p_file_cx, l_atom_complex, recorder="ATOM", header=p_lig.split("/")[-1], connect_matrix=0) # search atom in BS l_atom_binding_site = [] for atom_complex in l_atom_complex: for atom_substruct in lig_parsed: if parsePDB.distanceTwoatoms( atom_substruct, atom_complex) <= thresold_BS: if not atom_complex in l_atom_binding_site: l_atom_binding_site.append( deepcopy(atom_complex)) # 3. retrieve complet residue l_atom_BS_res = parsePDB.getResidues( l_atom_binding_site, l_atom_complex) # 4. write binding site p_binding = p_dir_result_ref + "BS_" + p_lig.split( "/")[-1] writePDBfile.coordinateSection( p_binding, l_atom_BS_res, "ATOM", p_binding, connect_matrix=0) # smile code substituate analysis # Step smile -> not conversion if shaep not validate smile_find = runOtherSoft.babelConvertPDBtoSMILE( p_substituate_pdb) if not struct_type in d_smile.keys(): d_smile[struct_type] = {} d_smile[struct_type][smile_find] = {} d_smile[struct_type][smile_find][ "count"] = 1 d_smile[struct_type][smile_find]["PDB"] = [ pdbfile.split("_")[1] ] d_smile[struct_type][smile_find][ "ligand"] = [pdbfile.split("_")[0]] d_smile[struct_type][smile_find]["ref"] = [ ref_folder ] else: if not smile_find in d_smile[ struct_type].keys(): d_smile[struct_type][smile_find] = {} d_smile[struct_type][smile_find][ "count"] = 1 d_smile[struct_type][smile_find][ "PDB"] = [pdbfile.split("_")[1]] d_smile[struct_type][smile_find][ "ligand"] = [ pdbfile.split("_")[0] ] d_smile[struct_type][smile_find][ "ref"] = [ref_folder] else: d_smile[struct_type][smile_find][ "count"] = d_smile[struct_type][ smile_find]["count"] + 1 d_smile[struct_type][smile_find][ "PDB"].append( pdbfile.split("_")[1]) d_smile[struct_type][smile_find][ "ligand"].append( pdbfile.split("_")[0]) d_smile[struct_type][smile_find][ "ref"].append(ref_folder) else: if not struct_type in d_control[ "out sheap"].keys(): d_control["out sheap"][struct_type] = 1 else: d_control["out sheap"][ struct_type] = d_control["out sheap"][ struct_type] + 1 tool.closeDicoFile(d_filout_superimposed) # sheap control tool.closeDicoFile(d_filout_sheap) for p_file_sheap in d_filout_sheap["list"]: runOtherSoft.RhistogramMultiple(p_file_sheap) # write list of smile for substruct in d_smile.keys(): p_list_smile = pathManage.result( name_lig) + "list_" + substruct + "_" + str( thresold_shaep) + "_smile.txt" filout_smile = open(p_list_smile, "w") for smile_code in d_smile[substruct].keys(): l_lig = d_smile[substruct][smile_code]["ligand"] l_PDB = d_smile[substruct][smile_code]["PDB"] l_ref = d_smile[substruct][smile_code]["ref"] filout_smile.write( str(smile_code) + "\t" + str(d_smile[substruct][smile_code]["count"]) + "\t" + " ".join(l_PDB) + "\t" + " ".join(l_ref) + "\t" + " ".join(l_lig) + "\n") filout_smile.close() p_log.close() # control filout_control.write("NB ref: " + str(d_control["pr ref"]) + "\n") filout_control.write("Ligand query: " + str(d_control["lig query"]) + "\n") for k in d_control["subref"].keys(): filout_control.write("LSR " + str(k) + ": " + str(d_control["subref"][k]) + "\n") for k in d_control["subref empty"].keys(): filout_control.write("NB LSR empty " + str(k) + ": " + str(d_control["subref empty"][k]) + "\n") for k in d_control["out sheap"].keys(): filout_control.write("LSR out by sheap " + str(k) + ": " + str(d_control["out sheap"][k]) + "\n") filout_control.write("**********************\n\n") for k in d_control["subref"].keys(): filout_control.write("LSR keep" + str(k) + ": " + str(d_control["subref"][k] - d_control["out sheap"][k]) + "\n") filout_control.close() return 1
def retrieveSubstructSuperimposed (name_lig, thresold_BS = 4.5, thresold_superimposed_ribose = 2.5, thresold_superimposed_pi = 3, thresold_shaep = 0.4): # ouput p_dir_dataset = pathManage.dataset(name_lig) p_dir_result = pathManage.result(name_lig ) l_folder_ref = listdir(p_dir_dataset) # log control p_log = open(p_dir_result + "log_superimposed.txt", "w") # control extraction d_control = {} d_control["pr ref"] = 0 d_control["lig query"] = 0 d_control["subref"] = {} d_control["subref empty"] = {} d_control["out sheap"] = {} filout_control = open (p_dir_result + "quality_extraction.txt", "w") # stock smile code d_smile = {} # sheap control d_filout_sheap = {} d_filout_sheap ["list"] = [p_dir_result + "shaep_global.txt"] d_filout_sheap["global"] = open (p_dir_result + "shaep_global.txt", "w") d_filout_sheap["global"].write ("name\tbest_similarity\tshape_similarity\tESP_similarity\n") for ref_folder in l_folder_ref : # control folder reference name if len (ref_folder) != 4 : p_log.write ("[ERROR folder] -> " + ref_folder + "\n") continue # reference p_lig_ref = pathManage.findligandRef(p_dir_dataset + ref_folder + "/", name_lig) try: lig_ref_parsed = parsePDB.loadCoordSectionPDB(p_lig_ref, "HETATM") # print len (lig_ref_parsed) except: p_log.write ("[ERROR ligand ref] -> " + p_lig_ref + "\n") continue #control d_control["pr ref"] = d_control["pr ref"] + 1 # output by reference p_dir_result_ref = pathManage.result(name_lig + "/" + ref_folder) d_filout_superimposed = {} d_filout_superimposed["global"] = open (p_dir_result_ref + "all_ligand_aligned.pdb", "w") d_filout_superimposed["sheap"] = open (p_dir_result_ref + "all_ligand_aligned_" + str (thresold_shaep) + ".pdb", "w") # write lig ref -> connect matrix corrrect in all reference and all sheap writePDBfile.coordinateSection(d_filout_superimposed["global"], lig_ref_parsed, "HETATM", connect_matrix = 1) writePDBfile.coordinateSection(d_filout_superimposed["sheap"], lig_ref_parsed, "HETATM", connect_matrix = 1) # inspect folder dataset l_pdbfile = listdir(p_dir_dataset + ref_folder + "/") for pdbfile in l_pdbfile : # no ligand file if len (pdbfile.split ("_")) == 1 : continue pdbfile = pdbfile[:-4] # remove extention if len(pdbfile.split ("_")[0]) == 3 and len(pdbfile.split ("_")[1]) == 4 and pdbfile.split ("_")[1] != ref_folder: p_lig = p_dir_dataset + ref_folder + "/" + pdbfile + ".pdb" if p_lig_ref != p_lig : # pass case where ligand replace same ligand -> does not need run if pdbfile.split ("_")[0] == name_lig : p_log.write ("[REMOVE] -> same ligand substituate") continue # parsed ligand query lig_parsed = parsePDB.loadCoordSectionPDB(p_lig, "HETATM") # find matrix of rotation p_matrix = pathManage.findMatrix(p_lig_ref, p_lig, name_lig) # control file matrix exist if not path.exists(p_matrix) : p_log.write ("[ERROR] -> Matrix transloc " + p_lig_ref + " " + p_lig + " " + name_lig + "\n") continue # control d_control["lig query"] = d_control["lig query"] + 1 # find the path of complex used p_complex = p_dir_dataset + ref_folder + "/" + p_lig.split ("/")[-1][4:] # ligand rotated -> change the referentiel superposeStructure.applyMatrixLigand(lig_parsed, p_matrix) # use substruct l_p_substruct_ref = pathManage.findSubstructRef (pathManage.dataset(name_lig) + ref_folder + "/" , name_lig) for p_substruct_ref in l_p_substruct_ref : # ribose or phosphate struct_type = p_substruct_ref.split ("_")[-2] substruct_parsed = parsePDB.loadCoordSectionPDB(p_substruct_ref, "HETATM") l_atom_substituate = neighborSearch.searchNeighborAtom(substruct_parsed, lig_parsed, struct_type, p_log, thresold_superimposed_ribose = thresold_superimposed_ribose, thresold_superimposed_pi = thresold_superimposed_pi) # control find if len (l_atom_substituate) == 0 : if not struct_type in d_control["subref empty"].keys () : d_control["subref empty"][struct_type] = 1 else : d_control["subref empty"][struct_type] = d_control["subref empty"][struct_type] + 1 continue else : if not struct_type in d_control["subref"].keys () : d_control["subref"][struct_type] = 1 else : d_control["subref"][struct_type] = d_control["subref"][struct_type] + 1 # write PDB file, convert smile p_substituate_pdb = p_dir_result_ref + "substituent_" + pdbfile.split ("_")[0] + "_" + pdbfile.split ("_")[1] + "_" + struct_type + ".pdb" writePDBfile.coordinateSection(p_substituate_pdb, l_atom_substituate, recorder="HETATM", header=0, connect_matrix = 1) # sheap reference on part of ligand p_sheap = runOtherSoft.runShaep (p_substruct_ref, p_substituate_pdb, p_substituate_pdb[0:-4] + ".hit", clean = 0) val_sheap = parseShaep.parseOutputShaep (p_sheap) if val_sheap == {} : p_log.write ("[ERROR] -> ShaEP " + p_substituate_pdb + " " + p_substruct_ref + "\n") if not struct_type in d_control["out sheap"].keys () : d_control["out sheap"][struct_type] = 1 else : d_control["out sheap"][struct_type] = d_control["out sheap"][struct_type] + 1 continue # control thresold sheap if not struct_type in d_filout_sheap.keys () : d_filout_sheap[struct_type] = {} d_filout_sheap[struct_type] = open (p_dir_result + "shaep_global_" + struct_type + ".txt", "w") d_filout_sheap[struct_type].write ("name\tbest_similarity\tshape_similarity\tESP_similarity\n") d_filout_sheap["list"].append (p_dir_result + "shaep_global_" + struct_type + ".txt") # to improve with python function # write value in ShaEP control d_filout_sheap[struct_type].write (ref_folder + "_" + str(pdbfile.split ("_")[1]) + "_" + struct_type + "_" + str (pdbfile.split ("_")[0]) + "\t" + str(val_sheap["best_similarity"]) + "\t" + str(val_sheap["shape_similarity"]) + "\t" + str(val_sheap["ESP_similarity"]) + "\n") d_filout_sheap["global"].write (ref_folder + "_" + str(pdbfile.split ("_")[1]) + "_" + struct_type + "_" + str (pdbfile.split ("_")[0]) + "\t" + str(val_sheap["best_similarity"]) + "\t" + str(val_sheap["shape_similarity"]) + "\t" + str(val_sheap["ESP_similarity"]) + "\n") # rename file substituent with shaEP value rename(p_substituate_pdb, p_substituate_pdb[:-4] + "_" + str (val_sheap["best_similarity"]) + ".pdb") # rename and change the file name p_substituate_pdb = p_substituate_pdb[:-4] + "_" + str (val_sheap["best_similarity"]) + ".pdb" # write all substruct in global file writePDBfile.coordinateSection(d_filout_superimposed["global"], lig_parsed, recorder= "HETATM", header = str(p_lig.split ("/")[-1]) + "_" + str (val_sheap["best_similarity"]) , connect_matrix = 1) # control sheap thresold if float(val_sheap["best_similarity"]) >= thresold_shaep : # write subligand superimposed selected in global files writePDBfile.coordinateSection(d_filout_superimposed["sheap"], lig_parsed, recorder= "HETATM", header = str(p_lig.split ("/")[-1]) + "_" + str (val_sheap["best_similarity"]) , connect_matrix = 1) ############ # write BS # ############ # not only protein superimposed -> also ion and water l_atom_complex = parsePDB.loadCoordSectionPDB(p_complex) superposeStructure.applyMatrixProt(l_atom_complex, p_matrix) p_file_cx = p_dir_result_ref + "CX_" + p_lig.split ("/")[-1] # write CX writePDBfile.coordinateSection(p_file_cx, l_atom_complex, recorder="ATOM", header= p_lig.split ("/")[-1], connect_matrix = 0) # search atom in BS l_atom_binding_site = [] for atom_complex in l_atom_complex : for atom_substruct in lig_parsed : if parsePDB.distanceTwoatoms (atom_substruct, atom_complex) <= thresold_BS : if not atom_complex in l_atom_binding_site : l_atom_binding_site.append (deepcopy(atom_complex)) # 3. retrieve complet residue l_atom_BS_res = parsePDB.getResidues(l_atom_binding_site, l_atom_complex) # 4. write binding site p_binding = p_dir_result_ref + "BS_" + p_lig.split ("/")[-1] writePDBfile.coordinateSection(p_binding, l_atom_BS_res, "ATOM", p_binding, connect_matrix = 0) # smile code substituate analysis # Step smile -> not conversion if shaep not validate smile_find = runOtherSoft.babelConvertPDBtoSMILE(p_substituate_pdb) if not struct_type in d_smile.keys () : d_smile[struct_type] = {} d_smile[struct_type][smile_find] = {} d_smile[struct_type][smile_find]["count"] = 1 d_smile[struct_type][smile_find]["PDB"] = [pdbfile.split ("_")[1]] d_smile[struct_type][smile_find]["ligand"] = [pdbfile.split ("_")[0]] d_smile[struct_type][smile_find]["ref"] = [ref_folder] else : if not smile_find in d_smile[struct_type].keys () : d_smile[struct_type][smile_find] = {} d_smile[struct_type][smile_find]["count"] = 1 d_smile[struct_type][smile_find]["PDB"] = [pdbfile.split ("_")[1]] d_smile[struct_type][smile_find]["ligand"] = [pdbfile.split ("_")[0]] d_smile[struct_type][smile_find]["ref"] = [ref_folder] else : d_smile[struct_type][smile_find]["count"] = d_smile[struct_type][smile_find]["count"] + 1 d_smile[struct_type][smile_find]["PDB"].append (pdbfile.split ("_")[1]) d_smile[struct_type][smile_find]["ligand"].append (pdbfile.split ("_")[0]) d_smile[struct_type][smile_find]["ref"].append (ref_folder) else : if not struct_type in d_control["out sheap"].keys () : d_control["out sheap"][struct_type] = 1 else : d_control["out sheap"][struct_type] = d_control["out sheap"][struct_type] + 1 tool.closeDicoFile (d_filout_superimposed) # sheap control tool.closeDicoFile (d_filout_sheap) for p_file_sheap in d_filout_sheap["list"] : runOtherSoft.RhistogramMultiple (p_file_sheap) # write list of smile for substruct in d_smile.keys () : p_list_smile = pathManage.result(name_lig) + "list_" + substruct + "_" + str (thresold_shaep) + "_smile.txt" filout_smile = open (p_list_smile, "w") for smile_code in d_smile[substruct].keys () : l_lig = d_smile[substruct][smile_code]["ligand"] l_PDB = d_smile[substruct][smile_code]["PDB"] l_ref = d_smile[substruct][smile_code]["ref"] filout_smile.write (str (smile_code) + "\t" + str (d_smile[substruct][smile_code]["count"]) + "\t" + " ".join (l_PDB) + "\t" + " ".join (l_ref) + "\t" + " ".join(l_lig) + "\n") filout_smile.close () p_log.close () # control filout_control.write ("NB ref: " + str(d_control["pr ref"]) + "\n") filout_control.write ("Ligand query: " + str(d_control["lig query"]) + "\n") for k in d_control["subref"].keys () : filout_control.write ("LSR " + str (k) + ": " + str(d_control["subref"][k]) + "\n") for k in d_control["subref empty"].keys () : filout_control.write ("NB LSR empty " + str (k) + ": " + str(d_control["subref empty"][k]) + "\n") for k in d_control["out sheap"].keys () : filout_control.write ("LSR out by sheap " + str (k) + ": " + str(d_control["out sheap"][k]) + "\n") filout_control.write ("**********************\n\n") for k in d_control["subref"].keys () : filout_control.write ("LSR keep" + str (k) + ": " + str(d_control["subref"][k] - d_control["out sheap"][k]) + "\n") filout_control.close () return 1
def datasetPreparation(ligand_ID, clean=1): p_dir_dataset = pathManage.dataset(ligand_ID) l_folder = listdir(p_dir_dataset) indent = 0 for ref_folder in l_folder: # file include in dataset folder if len(ref_folder) != 4: continue l_pdbfile = listdir(p_dir_dataset + ref_folder + "/") indent = indent + 1 print ref_folder, indent # clean repertory -> only PDB ref and PDB l_pdbfile = listdir(p_dir_dataset + ref_folder + "/") if clean == 1: for pdbfile in l_pdbfile: p_file_pdb = p_dir_dataset + ref_folder + "/" + pdbfile if not search(".pdb", pdbfile) or search( "subref", pdbfile) or len(pdbfile.split("_")[0]) == 3: remove(p_file_pdb) l_pdbfile = listdir(p_dir_dataset + ref_folder + "/") for pdbfile in l_pdbfile: p_file_pdb = p_dir_dataset + ref_folder + "/" + pdbfile # extract ligand in PDB l_ligand = parsePDB.retrieveListLigand(p_file_pdb) # print l_ligand if l_ligand == []: continue else: l_atom_pdb_parsed = parsePDB.loadCoordSectionPDB(p_file_pdb) for name_ligand in l_ligand: l_lig_parsed = parsePDB.retrieveLigand( l_atom_pdb_parsed, name_ligand) if l_lig_parsed == []: continue p_filout_ligand = p_dir_dataset + ref_folder + "/" + name_ligand + "_" + path.split( p_file_pdb)[1] writePDBfile.coordinateSection(p_filout_ligand, l_lig_parsed[0], "HETATM", header=0, connect_matrix=1) # ligand_ID write for shaep # print p_dir_dataset + ref_folder + "/" p_lig_ref = pathManage.findligandRef(p_dir_dataset + ref_folder + "/", ligand_ID) if p_lig_ref == 0: continue # print p_lig_ref lig_ref_parsed = parsePDB.loadCoordSectionPDB(p_lig_ref) d_l_atom_substruct = substructTools.retrieveSubstruct( lig_ref_parsed, ligand_ID) # case with AMP without phosphate if d_l_atom_substruct == {}: continue # write ligand_ID for subs in d_l_atom_substruct.keys(): p_filout_substruct = p_dir_dataset + ref_folder + "/subref_" + subs + "_" + ref_folder + ".pdb" writePDBfile.coordinateSection(p_filout_substruct, d_l_atom_substruct[subs], "HETATM", header=0, connect_matrix=1) return 1
def countingSubstituent (name_final, debug = 1): pr_final_folder = pathManage.result("final_" + name_final) d_count = {} d_lig = {} d_by_ref = {} d_count_pr = {} l_file_final = listdir(pr_final_folder) if debug : print "1", pr_final_folder for pr_type_subref in l_file_final : # case where pr type is a file not a folder try : l_pr_sub = listdir(pr_final_folder + pr_type_subref + "/") except : continue if debug: print "2",pr_final_folder + pr_type_subref + "/" # case cycle append one directory if "cycle" in l_pr_sub : l_pr_sub.remove ("cycle") l_second_sub = listdir (pr_final_folder + pr_type_subref + "/cycle/") for second_sub in l_second_sub : l_pr_sub.append ("cycle/" + second_sub) for pr_sub in l_pr_sub : # case where pr_type_substituent is a folder try : l_pr_PDBref = listdir(pr_final_folder + pr_type_subref + "/" + pr_sub + "/") except : continue if debug : print "3", pr_final_folder + pr_type_subref, pr_sub for pr_PDBref in l_pr_PDBref : PDB_ref = pr_PDBref.split ("_")[-1] family_ref = pr_PDBref.split ("-")[0] group_ref = pr_PDBref.split ("_")[0].split ("-")[-1] pr_LGD = pr_final_folder + pr_type_subref + "/" + pr_sub + "/" + pr_PDBref + "/LGD/" pr_LSR = pr_final_folder + pr_type_subref + "/" + pr_sub + "/" + pr_PDBref + "/LSR/" pr_BS = pr_final_folder + pr_type_subref + "/" + pr_sub + "/" + pr_PDBref + "/BS/" if debug : print "4",pr_LGD print "4", pr_BS print "4", pr_LSR ################ # folder LSR # ################ l_file_LSR = listdir (pr_LSR) for file_LSR in l_file_LSR : # -> count by type sub reference if search ("LSR_", file_LSR) and file_LSR.split ("_")[1] != "REF" : ligand_sub = file_LSR.split ("_")[1] if debug : print "5", file_LSR if not ligand_sub in d_count.keys () : d_count[ligand_sub] = {} if not pr_sub in d_count[ligand_sub].keys () : d_count[ligand_sub][pr_sub] = 0 d_count[ligand_sub][pr_sub] = d_count[ligand_sub][pr_sub] + 1 ################ # complet LSR # ################ elif search ("LSR", file_LSR): # case LSR reference # ###################### if search ("REF_", file_LSR) : lig_ref = file_LSR.split ("_")[2][:3] if not lig_ref in d_by_ref.keys () : d_by_ref[lig_ref] = {} type_ref = pr_type_subref.split ("_")[0] if not type_ref in d_by_ref[lig_ref].keys () : d_by_ref[lig_ref][type_ref] = 0 d_by_ref[lig_ref][type_ref] = d_by_ref[lig_ref][type_ref] + 1 ################# # folder LGD # ################# l_file_LGD = listdir(pr_LGD) for file_LGD in l_file_LGD : # print file_ref if search ("LGD", file_LGD): ligand = file_LGD.split ("_")[1] if ligand == "REF" : continue if not ligand in d_lig.keys () : d_lig[ligand] = {} d_lig[ligand]["count"] = 0 d_lig[ligand]["group"] = [] d_lig[ligand]["family"] = [] d_lig[ligand]["count"] = d_lig[ligand]["count"] + 1 d_lig[ligand]["family"].append (str(family_ref)) d_lig[ligand]["group"].append (str(group_ref)) ############### # folder BS # ############### l_file_BS = listdir(pr_BS) for file_BS in l_file_BS : if search ("BS_REF", file_BS): lig_ref = file_BS.split ("_")[2] pr_ref = file_BS.split ("_")[3].split (".")[0] print lig_ref, pr_ref, "*****" if not lig_ref in d_count_pr.keys () : d_count_pr[lig_ref] = {} d_count_pr[lig_ref]["pr ref"] = [] d_count_pr[lig_ref]["pr queries"] = [] d_count_pr[lig_ref]["lig queries"] = [] if not pr_ref in d_count_pr[lig_ref]["pr ref"] : d_count_pr[lig_ref]["pr ref"].append (pr_ref) try: family = analysis.findFamily (pr_ref, pathManage.dataset (lig_ref) + "family_PDB.txt") if not family in d_count_pr[lig_ref].keys () : d_count_pr[lig_ref][family] = 0 d_count_pr[lig_ref][family] = d_count_pr[lig_ref][family] + 1 except: pass # BS -> query for file_BS in l_file_BS : # for not reference BS if not search ("BS_REF", file_BS) : lig_querie = file_BS.split ("_")[1] prot_querie = file_BS.split ("_")[2][0:4] print prot_querie, lig_querie, "*******" # find ligand reference # lig ref define in previous step d_count_pr[lig_ref]["pr queries"].append (prot_querie) d_count_pr[lig_ref]["lig queries"].append (lig_querie) # write and plot # ################## pr_result = pathManage.generatePath(pr_final_folder + "counting/") for ligand_sub in d_count.keys () : p_filout = pr_result + ligand_sub filout = open (p_filout, "w") filout.write ("\t".join(d_count[ligand_sub].keys ()) + "\n") l_value = [str(x) for x in d_count[ligand_sub].values ()] filout.write ("\t".join(l_value) + "\n") filout.close () runOtherSoft.piePlot(p_filout) filout_lig = open (pr_result + "count_ligand", "w") filout_lig.write ("Ligand ID\tNumber of occurences in the dataset\tNumber of different clusters\tList of clusters\tList of protein families\n") for lig in d_lig.keys () : if d_lig[lig] > 1 : filout_lig.write (str (lig) + "\t" + str (d_lig[lig]["count"]) + "\t" + str(len (list (set(d_lig[lig]["group"])))) + "\t" + " ".join (d_lig[lig]["group"]) + "\t" + " ".join (d_lig[lig]["family"]) + "\n") filout_lig.close () filout_LSR_lig = open (pr_result + "CountByLigandRef", "w") for lig_ref in d_by_ref.keys () : filout_LSR_lig.write ("====" + str (lig_ref) + "====\n") for sub_ref in d_by_ref[lig_ref].keys () : filout_LSR_lig.write (str (sub_ref) + ": " + str (d_by_ref[lig_ref][sub_ref]) + "\n") filout_LSR_lig.close () filout_pr_count = open (pr_result + "count_pr", "w") for lig in d_count_pr.keys () : filout_pr_count.write ("====" + str (lig) + "====\n") filout_pr_count.write ("nb ref pr: " + str (len (d_count_pr[lig]["pr ref"])) + "\n") filout_pr_count.write ("nb querie pr: " + str (len (d_count_pr[lig]["pr queries"])) + "\n") filout_pr_count.write ("nb ligand queries: " + str (len (d_count_pr[lig]["lig queries"])) + "\n") for family in d_count_pr[lig].keys () : if family != "pr ref" and family != "pr queries" and family != "lig queries" : filout_pr_count.write ("Ref " + str (family) + ": " + str (d_count_pr[lig][family]) + "\n") filout_pr_count.close () runOtherSoft.barplot(pr_result + "count_ligand")
def globalArrangement (pr_orgin, p_smile, p_family, name_ligand, l_ligand_out): # print "--------" # print pr_orgin # print p_smile # print p_family # print name_ligand # print "--------" subst = p_smile.split ("_")[-3] filin = open (p_smile, "r") l_line_smile = filin.readlines () filin.close() for line_smile in l_line_smile : # search substructure # print line_smile l_PDB_query = line_smile.split ("\t")[-3].split (" ") # print l_PDB_query l_PDB_ref = line_smile.split ("\t")[-2].split (" ") l_ligand = line_smile.strip().split ("\t")[-1].split (" ") # search replacement smile = line_smile.split ("\t")[0] # search if LSR is small -> thresold < 3 small_LSR = smileAnalysis.smallLSR (smile) if subst == "ribose" : if small_LSR == 1 : first_folder = "ribose_small" else : first_folder = "ribose" else : if small_LSR == 1 : first_folder = "Pi_small" else : first_folder = "Pi" print smile, l_PDB_query, l_PDB_ref, l_ligand, subst, small_LSR replacement, metal = smileAnalysis.searchReplacement (smile, l_PDB_query[0], l_PDB_ref[0], name_ligand) # case with cycle -> search replacement 2 if replacement == "cycle" : replacement2, metal = smileAnalysis.searchReplacement (smile, l_PDB_query[0], l_PDB_ref[0], name_ligand, in_cycle = 1) replacement = replacement + "/" + replacement2 # new folder # case metal if replacement == "metal" : print metal, l_PDB_query, l_PDB_ref, name_ligand len_find = len (l_PDB_ref) i = 0 while i < len_find : # exclusion of ligand out if l_ligand[i] in l_ligand_out : i = i + 1 continue group, family = analysis.findFamilyAndGroup(l_PDB_ref[i]) # folder reference pr_dataset = pathManage.dataset(name_ligand + "/" + l_PDB_ref[i]) PDB_ref = pathManage.findPDBRef(pr_dataset) p_ligand_ref = pathManage.findligandRef(pr_dataset , name_ligand) l_frag_ref = pathManage.findSubstructRef(pr_dataset, name_ligand) for f_ref in l_frag_ref : if search (subst, f_ref) : p_frag_ref = f_ref break # folder_query pr_result = pathManage.result(name_ligand + "/" + l_PDB_ref[i]) l_protein_tranloc = pathManage.findPDBQueryTransloc(pr_result) for p_t in l_protein_tranloc : if search (l_ligand[i], p_t) and search (l_PDB_query[i], p_t) : p_protein_query = p_t break if replacement != "metal" : p_lig_query = pathManage.findligandQuery(pr_dataset , l_ligand[i], l_PDB_query[i]) else : p_lig_query = pathManage.findligandQuery(pr_dataset ,metal, l_PDB_query[i]) # need apply transloc matrix matrix_transloc = pathManage.findMatrix(p_ligand_ref, p_lig_query, name_ligand) lig_query_parsed = parsePDB.loadCoordSectionPDB(p_lig_query) try : superposeStructure.applyMatrixLigand(lig_query_parsed, matrix_transloc) except : i = i + 1 continue p_lig_substituate = pathManage.findSubstructFind(pr_result, l_ligand[i], l_PDB_query[i], subst) l_p_BS = pathManage.findFileBS(pr_result, l_PDB_query[i]) for BS in l_p_BS : if search (l_ligand[i], BS) : p_BS = BS break # print pr_final # print "***************" # print PDB_ref # print p_ligand_ref # print p_frag_ref # print "----" # print p_protein_query # print p_lig_query # print p_lig_substituate # print p_BS # print "**************" # ajouter group + family 2 lettre pr_final = pr_orgin + first_folder + "/" + replacement + "/" + str (family) + "-" + str (group) + "_" + l_PDB_ref[i] + "/" pr_ligand = pr_orgin + first_folder + "/" + replacement + "/" + str (family) + "-" + str (group) + "_" + l_PDB_ref[i] + "/LGD/" pr_BS = pr_orgin + first_folder + "/" + replacement + "/" + str (family) + "-" + str (group) + "_" + l_PDB_ref[i] + "/BS/" pr_sust = pr_orgin + first_folder + "/" + replacement + "/" + str (family) + "-" + str (group) + "_" + l_PDB_ref[i] + "/LSR/" if not path.isdir(pr_final): makedirs (pr_final) if not path.isdir(pr_ligand): makedirs (pr_ligand) if not path.isdir(pr_BS): makedirs (pr_BS) if not path.isdir(pr_sust): makedirs (pr_sust) # list file p_list_smile_queries = pr_sust + "list.smile" if not path.exists(p_list_smile_queries) : file_smile_queries = open (p_list_smile_queries, "w") else : file_smile_queries = open (p_list_smile_queries, "a") file_smile_queries.write (str(smile) + "\n") file_smile_queries.close () # lig de la query writePDBfile.coordinateSection(pr_ligand + "LGD_" + p_lig_query.split ("/")[-1], lig_query_parsed, recorder = "HETATM", header = "LCG_" + p_lig_query.split ("/")[-1], connect_matrix = 1) runOtherSoft.babelConvertPDBtoSMILE(pr_ligand + "LGD_" + p_lig_query.split ("/")[-1], clean_smi = 1) # lig de reference + smile copy2(p_ligand_ref, pr_ligand + "LGD_REF_" + p_ligand_ref.split ("/")[-1]) runOtherSoft.babelConvertPDBtoSMILE(pr_ligand + "LGD_REF_" + p_ligand_ref.split ("/")[-1]) # LSR de ref copy2(p_frag_ref, pr_sust + "LSR_REF_" + name_ligand + "_" + l_PDB_ref[i] + ".pdb") # protein query #copy2(p_protein_query, pr_final) # LSR query -> p_lig_ref only for the name copy2(p_lig_substituate, pr_sust + "LSR_" + subst + "_" + p_lig_query.split ("/")[-1]) # BS query copy2(p_BS, pr_BS) # BS from reference l_atom_BS = parsePDB.computeBS (PDB_ref, p_ligand_ref, thresold = 4.50, option_onlyATOM = 0) writePDBfile.coordinateSection(pr_BS + "BS_REF_" + name_ligand + "_" + PDB_ref.split ("/")[-1], l_atom_BS, recorder = "ATOM", header = "BS_REF_" + name_ligand + "_" + PDB_ref, connect_matrix = 0) i = i + 1 return 1
def analysisBS(name_lig, ID_seq='0.0', debug=1): pr_result = pathManage.result(name_lig) pr_out = pathManage.result(name_lig + "/sameBS") # log files p_log_file = pr_out + "log.txt" filout_log = open(p_log_file, "w") # dictionnar with files d_file_BS = {} d_file_BS["global"] = open(pr_out + name_lig + "_", "w") d_file_BS["global"].write( "name_bs\tRMSD_prot\tRMSD_BS_ca\tRMSD_BS_all\tD_max\tl_at_BS\tidentic\n" ) d_file_BS["summary"] = open(pr_out + "summary.txt", "w") pr_dataset = pathManage.dataset(name_lig) l_folder_ref = listdir(pr_result) nb_BS = 0 nb_BS_filtered = 0 nb_same_BS = 0 for PDB_ref in l_folder_ref: if debug: print PDB_ref if len(PDB_ref) != 4: continue p_pdb_ref = pathManage.findPDBRef(pr_dataset + PDB_ref + "/") l_p_query = pathManage.findPDBQueryTransloc( pathManage.result(name_lig) + PDB_ref + "/") if debug: print l_p_query for p_query in l_p_query: # read TM Align if debug: print p_query.split("/")[-1][7:-4] p_TMalign = pathManage.alignmentOutput(name_lig) + p_pdb_ref.split( "/")[-1][0:-4] + "__" + p_query.split("/")[-1][7:-4] + "/RMSD" try: score_align = parseTMalign.parseOutputTMalign(p_TMalign) except: filout_log.write("ERROR TM align " + p_TMalign + "\n") continue nb_BS = nb_BS + 1 if score_align["IDseq"] >= ID_seq: nb_BS_filtered = nb_BS_filtered + 1 l_p_substruct_ref = pathManage.findSubstructRef( pr_dataset + PDB_ref + "/", name_lig) # sub BS for p_substruct_ref in l_p_substruct_ref: struct_substitued = p_substruct_ref.split("_")[-2] # write header if not struct_substitued in d_file_BS.keys(): d_file_BS[struct_substitued] = open( pr_out + name_lig + "_" + struct_substitued + "_", "w") d_file_BS[struct_substitued].write( "name_bs\tRMSD_prot\tRMSD_BS_ca\tRMSD_BS_all\tD_max\tl_at_BS\tidentic\n" ) RMSD_bs = analysis.computeRMSDBS(p_pdb_ref, p_query, p_substruct_ref, pr_out) if RMSD_bs != []: d_file_BS[struct_substitued].write( p_substruct_ref.split("/")[-1][0:-4] + "_*_" + p_query.split("/")[-1][0:-4] + "\t" + str(score_align["RMSD"]) + "\t" + str(RMSD_bs[1]) + "\t" + str(RMSD_bs[0]) + "\t" + str(RMSD_bs[2]) + "\t" + str(RMSD_bs[-2]) + "\t" + str(RMSD_bs[-1]) + "\n") p_ligand_ref = pathManage.findligandRef( pr_dataset + PDB_ref + "/", name_lig) RMSD_bs_lig = analysis.computeRMSDBS(p_pdb_ref, p_query, p_ligand_ref, pr_out) if RMSD_bs_lig != []: d_file_BS["global"].write( p_ligand_ref.split("/")[-1][0:-4] + "_*_" + p_query.split("/")[-1][0:-4] + "\t" + str(score_align["RMSD"]) + "\t" + str(RMSD_bs_lig[1]) + "\t" + str(RMSD_bs_lig[0]) + "\t" + str(RMSD_bs_lig[2]) + "\t" + str(RMSD_bs_lig[-2]) + "\t" + str(RMSD_bs_lig[-1]) + "\n") if RMSD_bs_lig[-1] == 1: nb_same_BS = nb_same_BS + 1 # write summary d_file_BS["summary"].write("BS global: " + str(nb_BS) + "\n") d_file_BS["summary"].write("BS - IDseq " + str(ID_seq) + "%: " + str(nb_BS_filtered) + "\n") d_file_BS["summary"].write("BS - same atom number: " + str(nb_same_BS) + "\n") filout_log.close() # close files and run histograms for k_dico in d_file_BS.keys(): p_file = d_file_BS[k_dico].name d_file_BS[k_dico].close() if name_lig == "ATP": runOtherSoft.RhistogramRMSD(p_file, max_RMSD=5.0) elif name_lig == "ADP": runOtherSoft.RhistogramRMSD(p_file, max_RMSD=4.0) elif name_lig == "AMP": runOtherSoft.RhistogramRMSD(p_file, max_RMSD=4.0) else: runOtherSoft.RhistogramRMSD(p_file, max_RMSD=3.5) return 1