#!/usr/bin/env ccp4-python # # Copyright (C) 2005 Ronan Keegan # # This code is distributed under the terms and conditions of the # CCP4 Program Suite Licence Agreement as a CCP4 Application. # A copy of the CCP4 licence can be obtained by writing to the # CCP4 Secretary, Daresbury Laboratory, Warrington WA4 4AD, UK. # import os, sys, string, time import shutil import urllib import pickle # import MRBUMP_target_info import Matches import Model import Model_Queue import Model_struct import PQS import PISA import Ensemble import MRBUMP_MR import MRBUMP_HH import Cleanup import MRBUMP_loggraphs import WriteXML import WriteLogfile import Dummy_Run import subprocess import MRBUMP_writebest import MRBUMP_HHpred try: import pyrvapi except: # sys.stdout.write("Import warning: No pyrvapi\n") sys.stdout.write("") class Master: """ Master script for running MRBUMP """ def __init__(self): self.name = '' try: self.debug = eval(os.environ['MRBUMP_DEBUG']) except: self.debug = False def setDEBUG(self, flag): self.debug = flag def fast_search_MR(self, init, target_info, mstat): queue = None # If we want to run a dummy job only (requires example data pickled in folder pickle_data. # Also requires example log files from Phaser/Molrep/Refmac in the same directory if init.keywords.DUMMY: sys.stdout.write("##################################\n") sys.stdout.write("### Running Dummy Job ###\n") sys.stdout.write("##################################\n") sys.stdout.write("\n") dj = Dummy_Run.DummyJob() dj.run(init) return # Set up the directories for the job mstat.setSearchDir(init.search_dir) mstat.setResultsDir(init.results_dir) mstat.setScratchDir(init.scratch_dir) # Start the target data processing # target_info=MRBUMP_target_info.TargetInfo() # Set the log file for matthews coef job # target_info.setMattCoefLogfile(os.path.join(init.search_dir, "logs", "matt_coef.log")) # Set the target information # mstat.InitError = target_info.setTargetInfo(init, init.search_dir) # target_info.printTargetInfo(init) # Update the no. of mols in the a.s.u. if the user has specified a value # if init.keywords.NMASU != None: # print "The estimated number of molecules in the asu is: %d" % target_info.no_of_mols # print "The user has specified a value of %d" % init.keywords.NMASU # print "The value will be set to the user defined value" # mstat.setEstNoofMols(target_info.no_of_mols) # target_info.no_of_mols = init.keywords.NMASU # Set the DB's for local-based searches assert int(init.keywords.RLEVEL) in [100, 95, 90, 70, 50] mstat.setFastaDB(os.path.join(init.mrbump, 'data', 'pdb%d.txt' % int(init.keywords.RLEVEL))) # Set the output results html page if init.keywords.HTMLOUT == True: mstat.setResultsHTML(init.results_html) # Make a note of the start time for the job mstat.setStartTime(time.time()) # Set the model preparation and MR parameters mstat.setMRNUM(init.keywords.MRNUM) mstat.setENSMODNUM(init.keywords.ENSMODNUM) # initialize the results page # w=Write_Search_results.Write_html() if init.keywords.HTMLOUT == True: mstat.search_results.write_header(init, mstat.results_html) mstat.search_results.write_footer(init, mstat, mstat.results_html) # write the target details if init.keywords.HTMLOUT == True: mstat.search_results.write_target_details(init, mstat, target_info, mstat.results_html) # If there was an error in the initialisation exit the program if mstat.job_end == True: sys.exit() # Assign the ignore list, i.e. the PDB codes that are to be ignored mstat.ignore_list = init.keywords.ignore_list # Assign the include list, i.e. the CHAIN codes that are to be included mstat.include_list = init.keywords.include_list # If there is no pyrvapi module make sure JSRVIEW is not used if sys.modules.has_key("pyrvapi") == False: init.keywords.JSRVIEW = False ############################################################################################## ############################################################################################## # Jsrview ############################################################################################## if init.keywords.JSRVIEW: jsrview = os.path.join(os.environ["CCP4"], "libexec", "jsrview") dir_test = os.path.join(os.environ["CCP4"], "crap") pyrvapi.rvapi_init_document("aaa", dir_test, "MRBUMP", 1, os.path.join(os.environ["CCP4"], "share", "jsrview"), None, None) subprocess.Popen([jsrview, os.path.join(dir_test, "index.html")]) pyrvapi.rvapi_add_header("MrBUMP job ??") pyrvapi.rvapi_add_tab("tab1", "Input", True) pyrvapi.rvapi_add_tab("tab2", "Log file", False) log = os.path.join(dir_test, "output.log") pyrvapi.rvapi_append_content(log, True, "tab2") pyrvapi.rvapi_flush() pyrvapi.rvapi_add_section("sec1", "MrBUMP Input", "tab1", 0, 0, 1, 1, True) # pyrvapi.rvapi_add_section1("tab1/sec2", "Output files", 1, 0, 1, 1, True) pyrvapi.rvapi_flush() pyrvapi.rvapi_add_table1("sec1/table1", "Target details", 1, 0, 1, 1, True), # Make column headers(optional) # pyrvapi.rvapi_put_horz_theader("table1", "Column 1", "Tooltip 1", 0), # pyrvapi.rvapi_put_horz_theader("table1", "Column 2", "", 1), # pyrvapi.rvapi_put_horz_theader("table1", "Column 3", "Tooltip 2", 2), # pyrvapi.rvapi_put_horz_theader("table1", "Column 4", "", 3), # Make row headers(optional) pyrvapi.rvapi_put_vert_theader("table1", "HKLIN:", "Tooltip 1", 0) pyrvapi.rvapi_put_vert_theader("table1", "SEQIN:", "", 1) pyrvapi.rvapi_put_vert_theader("table1", "Sequence:", "", 2) pyrvapi.rvapi_put_vert_theader("table1", "Number of residues:", "", 3) pyrvapi.rvapi_put_vert_theader("table1", "Molecular weight (daltons):", "", 4) pyrvapi.rvapi_put_vert_theader("table1", "No. of molecules in asu:", "", 5) pyrvapi.rvapi_put_vert_theader("table1", "Data resolution (Angstroms):", "", 6) pyrvapi.rvapi_put_table_string("table1", os.path.split(target_info.hklin)[-1], 0, 0) pyrvapi.rvapi_put_table_string("table1", os.path.split(target_info.seqfile)[-1], 1, 0) pyrvapi.rvapi_put_table_string("table1", target_info.sequence, 2, 0) pyrvapi.rvapi_put_table_string("table1", str(target_info.no_of_res), 3, 0) pyrvapi.rvapi_put_table_string("table1", str(target_info.mol_weight), 4, 0) pyrvapi.rvapi_put_table_string("table1", str(target_info.no_of_mols), 5, 0) pyrvapi.rvapi_put_table_string("table1", str(target_info.resolution), 6, 0) pyrvapi.rvapi_flush() else: pyrvapi = None ############################################################################################## ############################################################################################## # Set up the FASTA search seq_search = Matches.SEQ_match() mstat.ALN_report=os.path.join(init.search_dir, "logs", "alignment_report.log") # If DOFASTA is true do the fasta search otherwise just add the specified chain IDs if init.keywords.DOFASTA == True: # Search information sys.stdout.write("\n") sys.stdout.write("###################################\n") sys.stdout.write("### Fasta search ###\n") sys.stdout.write("###################################\n") sys.stdout.write("\n") # Get the FASTA file using the target sequence seq_search.get_Fasta_file(init, mstat, target_info, os.path.join(mstat.results_dir, 'data', 'matches'), \ init.environment.SETUP_DIR) # Add the resulting chains to the chain list seq_search.get_Fasta_matches(init, mstat, target_info, "FASTA") # If DOPHMMER is true do the phmmer search if init.keywords.DOPHMMER == True: # Search information aln_title ="\n" aln_title+="###################################\n" aln_title+="### PHMMER search ###\n" aln_title+="###################################\n" aln_title+="\n" sys.stdout.write(aln_title) mstat.makeI2report("%s" % aln_title, mstat.ALN_report) # Do the search and add the resulting chains to the chain list seq_search.get_Fasta_matches(init, mstat, target_info, "PHMMER") # Set the alignment for each chain that was found in the PHMMER search for chain in mstat.PHresultsDict.keys(): if chain[0:4] not in init.keywords.ignore_list: # mstat.chain_list[chain].PHalignment=mstat.PHresultsDict[chain].alignments[">" + chain] # mstat.chain_list[chain].PHtargetSequence=mstat.PHresultsDict[chain].alignments[">Target_alignment"] mstat.chain_list[chain].PHmatch = True if init.XMLOUTIN: import makeXML makeXML.writeXMLOUT(init.search_dict, mstat.results_dict, init.version, init.xmlout) # Set the target domain for this chain based on Phmmer results for x in target_info.targetDomainDict.keys(): for chain in mstat.chain_list.keys(): if chain in target_info.targetDomainDict[x].matches: mstat.chain_list[chain].myPHTargetDomain=target_info.targetDomainDict[x].ID # If DOHHPRED is true do the hhblits search otherwise just add the specified chain IDs if init.keywords.DOHHPRED == True: # Search information sys.stdout.write("\n") sys.stdout.write("###################################\n") sys.stdout.write("### HHpred search ###\n") sys.stdout.write("###################################\n") sys.stdout.write("\n") # Set the various log files and output files mstat.HHblits_logfile = os.path.join(init.search_dir, "logs", "hhblits.log") mstat.HHblits_oa3mfile = os.path.join(init.search_dir, "sequences", "hhblits_oa3m.txt") mstat.HHsearch_logfile = os.path.join(init.search_dir, "logs", "hhsearch.log") mstat.HHsearch_fastafile = os.path.join(init.search_dir, "sequences", "hhsearch_fasta.txt") # Run HHPRED hh = MRBUMP_HH.HHpred() hh.runHHblits(seqin=target_info.seqfile, \ uniprotDB=init.keywords.HHUNIDB, \ oa3mFile=mstat.HHblits_oa3mfile, \ logfile=mstat.HHblits_logfile, \ debug=eval(os.environ["MRBUMP_DEBUG"])) hh.runHHsearch(seqout=mstat.HHsearch_fastafile, \ ina3mFile=mstat.HHblits_oa3mfile, \ pdbDB=init.keywords.HHDBPDB, \ targetSequence=target_info.sequence, \ logfile=mstat.HHsearch_logfile, \ debug=eval(os.environ["MRBUMP_DEBUG"])) mstat.HHresultsList = hh.resultsList mstat.HHresultsDict = hh.resultsDict # If this is a webserver run echo the list of results if init.keywords.WEBSERVER: sys.stdout.write("List of homologues found using HHPred:\n") sys.stdout.write("\n") sys.stdout.write(",".join(mstat.HHresultsList)) sys.stdout.write("\n\n") # Set the name of the output alignment file # mstat.hhpredALNFile=os.path.join(init.search_dir, "sequences", "hhpred_alignment.a3m") # Instantiate # HHBLITS=MRBUMP_HHpred.HHblits() # Run it # HHBLITS.runHHblits(target_info.seqfile, init.keywords.HHDBPDB, mstat.hhpredALNFile, 2) # mstat.hhpredList=HHBLITS.hitList # Add the resulting chains to the chain list seq_search.get_Fasta_matches(init, mstat, target_info , "HHPRED") # Set the alignment for each chain that was found in the HHpred search for chain in mstat.HHresultsDict.keys(): if chain[0:4] not in init.keywords.ignore_list: # mstat.chain_list[chain].HHalignment=HHBLITS.chainDict[chain].alignment # mstat.chain_list[chain].HHtargetSequence=HHBLITS.chainDict[chain].targetSequence mstat.chain_list[chain].HHalignment = mstat.HHresultsDict[chain].alignments[">" + chain] mstat.chain_list[chain].HHtargetSequence = mstat.HHresultsDict[chain].alignments[">Target_alignment"] mstat.chain_list[chain].HHmatch = True # Add the specified chains to the list seq_search.add_included_chains(init, mstat, target_info) # Add the specified chains from local files seq_search.add_local_chains(init, mstat, target_info) # Process the results from the FASTA search if mstat.no_of_SEQhits > 0: ps = Matches.Process_Score() sys.stdout.write("\n") sys.stdout.write("---------------------------------------------------------\n") sys.stdout.write("Fasta: Getting Template Sequences and Multiple Alignment:\n") sys.stdout.write("---------------------------------------------------------\n") sys.stdout.write("\n") # ps.PDB_process(mstat, 'SEQ') # Extract the sequences for the chains from the pdb datafile #ps.getPDB_sequences(init, mstat, "SEQ") # Set the names of the input and output files to be used in the multiple alignment mstat.setAllRawFile(os.path.join(init.search_dir, "sequences", "All_raw_seqs_SEQ.fasta")) mstat.setAllAlignFile(os.path.join(init.search_dir, "sequences", "All_align_seqs_SEQ.fasta")) #for x in mstat.chain_list.keys(): # print mstat.chain_list[x].source # Do the multiple alignment #if not init.keywords.DOHHPRED and not init.keywords.DOPHMMER: # list = ps.alignment(mstat.chain_list.keys(), target_info, init, mstat) # Get the top hit and sort the list of aligned sequences ps.get_top_hit(mstat.chain_list.keys(), init, mstat) sys.stdout.write("Top match from FASTA search: %s\n" % mstat.top_match_chainid) # First check if it is one of the local PDB files # if mstat.top_match_chainid[0:3]=="loc": # mstat.FASTA_top_match_PDBfile=init.keywords.local_list[mstat.top_match_chainid].filename # else: # mstat.FASTA_top_match_PDBfile=os.path.join(init.search_dir, "scratch", mstat.top_match_pdbid + ".pdb") # pdb_get=Matches.PDB_get() # pdb_get.download_single_PDB(mstat.top_match_pdbid, mstat.FASTA_top_match_PDBfile, init.keywords.PDBDIR) # Exit if no hits were found # if mstat.no_of_SEQhits == 0: # if init.keywords.HTMLOUT == True: # mstat.search_results.write_SEQ_search_details(mstat, mstat.results_html) # sys.exit() # write the SEQ search details to the html page if init.keywords.HTMLOUT == True: mstat.search_results.write_SEQ_search_details(init, mstat, mstat.results_html) # shutil.copy('/tmp/ssm_result.xml', mrsearchdir + '/results/ssm_result.xml') if init.keywords.SSM == True: sys.stdout.write("\n") sys.stdout.write("###################################\n") sys.stdout.write("### SSM search ###\n") sys.stdout.write("###################################\n") sys.stdout.write("\n") ssm_search = Matches.SSM_match() ssm_search.setSSMScript(os.path.join(init.mrbump_incl, 'perl', 'ssm.pl')) ssm_search.get_SSM_file(init, mstat, init.keywords.JOBID, os.path.join(mstat.results_dir, 'data', 'ssm_result.xml')) # Check to see if the SSM search failed if init.keywords.SSM: ssm_search.get_SSM_matches(init, mstat) sys.stdout.write("\n") sys.stdout.write("-------------------------------------------------------\n") sys.stdout.write("SSM: Getting Template Sequences and Multiple Alignment:\n") sys.stdout.write("-------------------------------------------------------\n") sys.stdout.write("\n") # ps.PDB_process(mstat, 'SSM') # Extract the sequences for the chains from the pdb datafile ps.getPDB_sequences(init, mstat, "SSM") # Set the names of the input and output files to be used in the multiple alignment mstat.setAllRawFile(os.path.join(init.search_dir, "sequences", "All_raw_seqs_SSM.fasta")) mstat.setAllAlignFile(os.path.join(init.search_dir, "sequences", "All_align_seqs_SSM.fasta")) # Do the multiple alignment list = ps.alignment(mstat.chain_list.keys(), target_info, init, mstat) # Get the top hit and sort the list of aligned sequences ps.get_top_hit(mstat.chain_list.keys(), init, mstat) # write the SSM search details to the html page if init.keywords.HTMLOUT == True: mstat.search_results.write_SSM_search_details(init, mstat, mstat.results_html) # Write out the target processing logfile ssmlog = WriteLogfile.Logfile() ssmlog.writeSSMLog(init, mstat) mstat.SSM_logfile = ssmlog.logfile # Prune the list ps.prune_list(init, mstat) ps.print_list(init, mstat) # Ouput the loggraph data for the alignment results if init.keywords.WEBSERVER == False: lg_plot = MRBUMP_loggraphs.Mrbump_logs() lg_plot.plot_alignment_graphs(init, mstat) ps.PDB_process(init, mstat) # Search the SCOP database to see if any domains exist in the template structures if init.keywords.SCOP == True: sys.stdout.write("\n") sys.stdout.write("#####################################################\n") sys.stdout.write("### Searching for Domains (SCOP) ###\n") sys.stdout.write("#####################################################\n") sys.stdout.write("\n") scop_search = Matches.SCOP_match() scop_search.get_SCOP_matches(init, mstat, init.environment.SETUP_DIR) if mstat.no_of_SCOPhits > 0: sys.stdout.write("\n") sys.stdout.write("---------------------------\n") sys.stdout.write("SCOP: Processing PDB files:\n") sys.stdout.write("---------------------------\n") sys.stdout.write("\n") # ps.PDB_process(mstat, 'SCOP') # Extract the sequences for the chains from the pdb datafile # ps.getPDB_sequences(init, mstat, "SSM") # Set the names of the input and output files to be used in the multiple alignment mstat.setAllRawFile(os.path.join(init.search_dir, "sequences", "All_raw_seqs_SCOP.fasta")) mstat.setAllAlignFile(os.path.join(init.search_dir, "sequences", "All_align_seqs_SCOP.fasta")) # Add the SCOP results into the MR list before re-alignment and sorting mstat.sorted_MR_list = mstat.sorted_MR_list + mstat.Domains_list # Do the multiple alignment list = ps.alignment(mstat.sorted_MR_list, target_info, init, mstat) mstat.sorted_MR_list = list # Get the top hit and sort the list of aligned sequences ps.get_top_hit(mstat.sorted_MR_list, init, mstat) # write the SSM search details to the html page if init.keywords.HTMLOUT == True: mstat.search_results.write_domains_search_details(init, mstat, mstat.results_html) # Re-sort the list to take into account the SCOP results scores ps.re_sort_MR_list(mstat) ps.print_pruned_list(mstat) # write the overall search details to the html page if init.keywords.HTMLOUT == True: mstat.search_results.write_ALL_search_details(init, mstat, target_info, mstat.results_html) ############################################################################################## ############################################################################################## # Jsrview ############################################################################################## if init.keywords.JSRVIEW: pyrvapi.rvapi_add_tab("tab3", "Model Search", False) pyrvapi.rvapi_flush() ############################################################################################## ############################################################################################## # Do the modelling of the PDB model structures sys.stdout.write("\n") sys.stdout.write("###########################################\n") sys.stdout.write("### Search Model Preparation ###\n") sys.stdout.write("###########################################\n") sys.stdout.write("\n") # Output the details of what will be modelled sys.stdout.write("The following types of model will be generated:\n") sys.stdout.write("\n") for i in init.model_types: sys.stdout.write("%s -- " % i) if i == 'UNMOD': sys.stdout.write("Unmodified models.\n") if i == 'PDBCLP': sys.stdout.write("PDBclip model, waters, hydrogens removed + most probable side-chain conformations.\n") if i == 'PLYALA': sys.stdout.write("Polyalanine model, all side chains removed.\n") if i == 'MOLREP': sys.stdout.write("Molrep generated model, side chains pruned according to sequence alignment.\n") if i == 'CHNSAW': sys.stdout.write("Chainsaw generated model, side chains pruned according to sequence alignment.\n") if i == 'SCLPTR': sys.stdout.write("Sculptor generated model, side chains pruned according to sequence alignment.\n") sys.stdout.write("\n") model = Model.Modelling() #model.convert_to_pir(mstat, target_info) # Prepare polyalanine models using if init.keywords.MDLUNMOD: model.unmodModel(target_info, init, mstat) # Prepare polyalanine models using if init.keywords.MDLPLYALA: model.polyala(target_info, init, mstat) # Prepare models using Molrep if init.keywords.MDLMOLREP: model.molrepModel(target_info, init, mstat) # Multiple alignment input to Chainsaw if init.keywords.MDLCHAINSAW: model.chainsawModel(target_info, init, mstat) # Multiple alignment input to Sculptor if init.keywords.MDLSCULPTOR: model.sculptorModel(target_info, init, mstat) # Monitor the queue for the completion of all the jobs if init.keywords.CLUSTER == True: queue = Model_Queue.Queue_info() queue.qstat_check(init, mstat, target_info, 'MODEL_PREP') # Print out the summary of results so far # best=MRBUMP_writebest.BestLog() # best.write_results_log(init, mstat) # mstat.sorted_soln_list=best.sorted_soln_list # sys.stdout.write(best.report) mstat.resetJobid_Array() mstat.resetJobid_Dict() mstat.resetJobName_Dict() # Write the overall search details to the html page mstat.search_results.write_model_prep_details(init, mstat, target_info, mstat.results_html) # Output the loggraph data for the model preparation results if init.keywords.MDLMOLREP or init.keywords.MDLCHAINSAW: lg_plot = MRBUMP_loggraphs.Mrbump_logs() lg_plot.plot_model_prep_graphs(init, mstat) ################################################################## # Note on PISA positioning # Needs to be after PDB coord download, and before ONLYMODELS exit. # Have it after model editing so that we form multimers of models rather than templates. # Having it after SCOP means we could have multimers of domains. # If the number of molecules in our target is greater than 1 consult PISA for multimers if target_info.no_of_mols >= 2 and init.keywords.PISA == True: sys.stdout.write("\n") sys.stdout.write("#####################################################\n") sys.stdout.write("### Searching for Multimers (PISA) ###\n") sys.stdout.write("#####################################################\n") sys.stdout.write("\n") pisa = PISA.PISA() pisa.get_pisa_files(target_info, init, mstat) # Create a models directory and copy all of the models to it # Create the models directory and any domains folders mstat.setModelsDir(os.path.join(init.search_dir, 'models')) os.mkdir(mstat.models_dir) # and an ensembles directory for ensemble models os.mkdir(os.path.join(mstat.models_dir, "ensembles")) # make the domains folders for dom in range(target_info.noDomains): os.mkdir(os.path.join(mstat.models_dir, "domain_%s" % str(dom+1))) os.mkdir(os.path.join(mstat.models_dir, "domain_%s" % str(dom+1), "ensembles")) if init.keywords.RTUNMOD: os.mkdir(os.path.join(mstat.models_dir, "domain_%s" % str(dom+1), "unmodified")) # Ensemble preparation moved here from MR_start # If we are using an Ensemble model then set it up. We now do this # whatever MR program chosen - Molrep should ignore an ensemble_model model. if init.keywords.USEENSEM: sys.stdout.write("###############################################################################\n") sys.stdout.write("### Model Preparation log: Setting up ensemble model from top search models ###\n") sys.stdout.write("###############################################################################\n") sys.stdout.write("\n") # Make sure we are not asking for more models than are in the MR list if mstat.num_MR_models < init.keywords.ENSMODNUM: init.keywords.ENSMODNUM = mstat.num_MR_models sys.stdout.write("Resetting the number in the ensemble to " + `init.keywords.ENSMODNUM` + " as there are not enough models for the specified value\n") sys.stdout.write("\n") ens = Ensemble.Ensemble() #ens.setup_ensemble(mstat, init, target_info) for dom in target_info.targetDomainDict.keys(): # Remove domains not included in the mr step from the domains lists tempMatches=target_info.targetDomainDict[dom].matches[:] tempRanges =target_info.targetDomainDict[dom].ranges[:] for chain in target_info.targetDomainDict[dom].matches: if chain not in mstat.sorted_MR_list: index=tempMatches.index(chain) tempMatches.pop(index) tempRanges.pop(index) target_info.targetDomainDict[dom].matches=tempMatches[:] target_info.targetDomainDict[dom].ranges=tempRanges[:] if len(target_info.targetDomainDict[dom].matches) >= 1: ens.setup_ensemble(mstat, init, target_info, domain=dom, outputEnsemblesDir=os.path.join(mstat.models_dir, "domain_%s" % target_info.targetDomainDict[dom].ID, "ensembles")) # write the ensemble details to the html page if init.keywords.HTMLOUT == True: mstat.search_results.write_ensemble_details(init, mstat, target_info, mstat.results_html) else: sys.stdout.write("Model Preparation log: Use Ensemble set to 'False' - no ensemble will be created.\n") sys.stdout.write("\n") # If user only wants to generate the models then we will exit at this point. if init.ONLYMODELS == True: # Output the list of models that has been created mr_setup = Model_struct.MR_setup() mr_setup.setTypes(init, mstat, target_info, init.search_dir) # Print the references and exit if init.keywords.HTMLOUT == True: mstat.mr_results.print_references(init, mstat) mstat.mr_results.print_references_stdout(init) # Pickle the objects for running as input for a dummy run later if init.keywords.PICKLE: sys.stdout.write("#############################################################\n") sys.stdout.write("### Pickling the objects for running a dummy job ###\n") sys.stdout.write("#############################################################\n") sys.stdout.write("\n") dj = Dummy_Run.DummyJob() dj.pickle(init, mstat, target_info) finish_time = time.ctime() finish_file = open(os.path.join(mstat.results_dir, 'finished.txt'), 'w') finish_file.write('Job finished: ' + finish_time) finish_file.write('') finish_file.write('Information only, please do not reply to this email.') finish_file.close() # Produce the summary of the models generated (data file for parsing) if init.keywords.DOPHMMER: mr_setup.makeModelsReport(init, mstat) sys.exit(0) # If we want to force an exit when models are prep'd in an MR run if init.keywords.EXITMODELS: sys.exit(0) ############################################################################################## ############################################################################################## # Jsrview ############################################################################################## if init.keywords.JSRVIEW: pyrvapi.rvapi_add_tab("tab4", "Model Preparation", False) pyrvapi.rvapi_flush() ############################################################################################## ############################################################################################## # Setup the models for MR mr_setup = Model_struct.MR_setup() mr_setup.setTypes(init, mstat, target_info, init.search_dir) # FIXME if init.keywords.ONLYENSEM: tempModelList = mstat.sorted_model_list[:] for i in tempModelList: if "ensemb" not in i.lower(): mstat.sorted_model_list.remove(i) # Write the header for the MR secion if init.keywords.HTMLOUT == True: mstat.mr_results.write_MR_header(init, mstat) return queue def runMR(self, init, target_info, mstat, queue=None): """ Function for running molecular replacement. """ ############################################################################################## ############################################################################################## # Jsrview ############################################################################################## if init.keywords.JSRVIEW: pyrvapi.rvapi_add_tab("tab5", "MR & Refinement", True) pyrvapi.rvapi_flush() # pyrvapi.rvapi_add_tab ( "tree_tab","Tree Widget",True ), ############################################################################################## ############################################################################################## # Announce the Molecular Replacement stage sys.stdout.write("##############################################################\n") sys.stdout.write("### Molecular Replacement and Refinement ###\n") sys.stdout.write("##############################################################\n") sys.stdout.write("\n") # If the number of molecules in our target is greater than 1 consult PQS for multimers if target_info.no_of_mols >= 2 and init.keywords.PQS == True: sys.stdout.write("\n") sys.stdout.write("------------------------------\n") sys.stdout.write("Searching for Multimers (PQS):\n") sys.stdout.write("------------------------------\n") sys.stdout.write("\n") pqs = PQS.PQS() pqs.set_pqs_list(init.environment.SETUP_DIR) pqs.get_pqs_files(init, target_info, mstat, init.keywords.MAPROGRAM) # write the PQS search details to the html page if init.keywords.HTMLOUT == True: mstat.search_results.write_PQS_search_details(init, mstat, target_info, mstat.results_html) # Do the molecular replacement using the model list MR = MRBUMP_MR.MR_submit() # Loop over the list of MR programs set at the start # for MRPROGRAM in init.keywords.MR_PROGRAM_LIST: sys.stdout.write("*********************************************************************************\n") sys.stdout.write("*********************************************************************************\n") sys.stdout.write("*********************************************************************************\n") # Echo the name of the MR program being used to the stdout # sys.stdout.write("MR log: Using " + MRPROGRAM + " for molecular replacement:\n") # sys.stdout.write("\n") # mstat.setMRPROGRAM(MRPROGRAM.upper()) # if sys.modules.has_key("pyrvapi") == False: # pyrvapi = None if init.keywords.JSRVIEW: MR.MR_start(target_info, init, mstat, init.keywords.QSIZE, pyrvapi) else: MR.MR_start(target_info, init, mstat, init.keywords.QSIZE, None) # Poll the queue to see if the jobs have finished if init.keywords.CLUSTER == True: sys.stdout.write("\n") sys.stdout.write("---------------------------\n") sys.stdout.write("Results (post-refinement):\n") sys.stdout.write("---------------------------\n") sys.stdout.write("\n") if queue == None: queue = Model_Queue.Queue_info() queue.qstat_check(init, mstat, target_info, 'MOL_REPLACE', MR) mstat.resetJobid_Array() mstat.resetJobid_Dict() # mstat.resetJobName_Dict() # Print out the summary of results so far best = MRBUMP_writebest.BestLog() best.write_results_log(init, mstat) mstat.sorted_soln_list = best.sorted_soln_list sys.stdout.write(best.report) # If running in TRYALL mode capture a summary of the results if init.keywords.TRYALL: mstat.mr_results.setTRYALL_summary(init, mstat) #if mstat.solution_found == False: # sys.stdout.write("\n") # sys.stdout.write("No solution was found using the following MR programs:\n") # count = 1 # for MRPROGRAM in init.keywords.MR_PROGRAM_LIST: # sys.stdout.write(`count` + ". " + MRPROGRAM + "\n") # count = count + 1 # sys.stdout.write("\n") # If running in TRYALL mode output a summary of the results for each MR program # for MRPROGRAM in init.keywords.MR_PROGRAM_LIST: # if init.keywords.TRYALL: # sys.stdout.write(mstat.TRYALL_summary[MRPROGRAM]) # write the final solution details to the html page mstat.setJob_End(True) if init.keywords.HTMLOUT == True: mstat.mr_results.write_final_soln(init, mstat, target_info) # Display the references in the results html file and the output logfile. if init.keywords.HTMLOUT == True: mstat.mr_results.print_references(init, mstat) mstat.mr_results.print_references_stdout(init) if mstat.solution_found == True and init.keywords.TRYALL == False: if mstat.soln_MRprogram == "MOLREP": shutil.copy(mstat.model_list[mstat.soln_model].refmac_molrep_MTZOUTfile , init.hklout) shutil.copy(mstat.model_list[mstat.soln_model].refmac_molrep_PDBfile , init.xyzout) if mstat.soln_MRprogram == "PHASER": shutil.copy(mstat.model_list[mstat.soln_model].refmac_phaser_MTZOUTfile , init.hklout) shutil.copy(mstat.model_list[mstat.soln_model].refmac_phaser_PDBfile , init.xyzout) # Output the job details to an XML file if init.keywords.XMLOUT: xml = WriteXML.writeXML() xml.write_details(init, mstat, target_info, init.keywords.SUMMARYFILE) # Output a pickle file of the results table with open(os.path.join(init.resultspkl), "w") as f: pickle.dump(mstat.results_dict, f) # Pickle the objects for running as input for a dummy run later if init.keywords.PICKLE: sys.stdout.write("#############################################################\n") sys.stdout.write("### Pickling the objects for running a dummy job ###\n") sys.stdout.write("#############################################################\n") sys.stdout.write("\n") dj = Dummy_Run.DummyJob() dj.pickle(init, mstat, target_info) finish_time = time.ctime() finish_file = open(os.path.join(mstat.results_dir, 'finished.txt'), 'w') finish_file.write('Job finished: ' + finish_time) finish_file.write('') finish_file.write('Information only, please do not reply to this email.') finish_file.close() # If running in LITE mode remove the input and PDB_files directories contents if init.keywords.LITE: purge = Cleanup.Clean() purge.purgeDirectory(os.path.join(init.search_dir, "logs")) purge.purgeDirectory(os.path.join(init.search_dir, "PDB_files")) purge.purgeDirectory(os.path.join(init.search_dir, "scratch")) purge.purgeDirectory(os.path.join(init.search_dir, "results", "data")) # Some space saving if init.keywords.DEBUG == False: if os.path.isfile(target_info.refinement_hklin): os.remove(target_info.refinement_hklin) # Remove the data directory to save memory space if init.keywords.CLEAN: sys.stdout.write("Cleanup: Removing surplus search data and scratch directory\n") cleanup = Cleanup.Clean() cleanup.clean_data_dir(mstat, init.keywords.OVERWRITE) cleanup.rm_dir(os.path.join(init.search_dir, 'scratch')) if init.XMLOUTIN: import makeXML makeXML.writeXMLOUT(init.search_dict, mstat.results_dict, init.version, init.xmlout) # If this is a webserver run tar-up the entire directory for downloading if init.keywords.WEBSERVER: import tarfile currDIR = os.getcwd() tar = tarfile.open(os.path.join(init.search_dir, "mrbump_results.tar.gz"), "w:gz") os.chdir(os.path.split(init.search_dir)[0]) for name in [os.path.split(init.search_dir)[-1]]: tar.add(name) tar.close() os.chdir(currDIR) sys.exit(0)