def ensembling(self, optd):
if optd['import_ensembles']:
ensembler.import_ensembles(optd)
elif optd['ideal_helices']:
ample_util.ideal_helices(optd)
logger.info("*** Using ideal helices to solve structure ***")
else:
# Import the models here instead of cluster_util.
if optd['cluster_method'] is 'import':
# HACK - this is certainly not how we want to do it. One flag for all (-models) in future
optd['models'] = optd['cluster_dir']
optd['models'] = ample_util.extract_and_validate_models(optd)
# Check we have some models to work with
if not (optd['single_model_mode'] or optd['models']):
ample_util.save_amoptd(optd)
msg = "ERROR! Cannot find any pdb files in: {0}".format(
optd['models_dir'])
exit_util.exit_error(msg)
optd['ensemble_ok'] = os.path.join(optd['work_dir'], 'ensemble.ok')
if optd['submit_cluster']:
# Pickle dictionary so it can be opened by the job to get the parameters
ample_util.save_amoptd(optd)
script = ensembler.cluster_script(optd)
ensembler_timeout = ensembler.get_ensembler_timeout(optd)
workers_util.run_scripts(
job_scripts=[script],
monitor=monitor,
nproc=optd['nproc'],
job_time=ensembler_timeout,
job_name='ensemble',
submit_cluster=optd['submit_cluster'],
submit_qtype=optd['submit_qtype'],
submit_queue=optd['submit_queue'],
submit_pe_lsf=optd['submit_pe_lsf'],
submit_pe_sge=optd['submit_pe_sge'],
submit_array=optd['submit_array'],
submit_max_array=optd['submit_max_array'])
# queue finished so unpickle results
optd.update(ample_util.read_amoptd(optd['results_path']))
else:
try:
ensembler.create_ensembles(optd)
except Exception as e:
msg = "Error creating ensembles: {0}".format(e)
exit_util.exit_error(msg, sys.exc_info()[2])
# Check we have something to work with
if not os.path.isfile(
optd['ensemble_ok']) or 'ensembles' not in optd.keys(
) or not len(optd['ensembles']):
msg = "Problem generating ensembles!"
exit_util.exit_error(msg)
if not (optd['homologs'] or optd['single_model_mode']):
ensemble_summary = ensembler.ensemble_summary(
optd['ensembles_data'])
logger.info(ensemble_summary)
# Save the results
ample_util.save_amoptd(optd)
# Bail here if we didn't create anything
if not len(optd['ensembles']):
msg = "### AMPLE FAILED TO GENERATE ANY ENSEMBLES! ###\nExiting..."
exit_util.exit_error(msg)
# Update results view
if self.ample_output:
self.ample_output.display_results(optd)
return
if not restart and not ('models' in optd and optd['models'] and os.path.exists(optd['models'])):
msg = 'AMPLE ensembler requires a -models argument with a file/directory of pdbs'
exit_util.exit_error(msg, sys.exc_info()[2])
# Set up the working directory if one doesn't already exist
if not ('work_dir' in optd and optd['work_dir']):
optd['work_dir'] = os.path.join(os.path.abspath(os.path.curdir), ENSEMBLE_DIRNAME)
if not os.path.isdir(optd['work_dir']):
try:
os.mkdir(optd['work_dir'])
except OSError as e:
msg = 'Error making ensemble workdir {0} : {1}'.format(optd['work_dir'], e)
exit_util.exit_error(msg, sys.exc_info()[2])
assert os.path.isdir(optd['work_dir'])
# Start logging to a file
logging_util.setup_file_logging(os.path.join(optd['work_dir'], "ensemble.log"))
try:
if not restart:
results = process_models.extract_and_validate_models(optd)
process_models.handle_model_import(optd, results)
process_ensemble_options(optd)
optd['ensemble_ok'] = os.path.join(optd['work_dir'], 'ensemble.ok')
optd['results_path'] = os.path.join(optd['work_dir'], AMPLE_PKL)
ensembler.create_ensembles(optd)
ample_util.save_amoptd(optd)
except Exception as e:
msg = "Error running ensembling: {0}".format(e.message)
exit_util.exit_error(msg, sys.exc_info()[2])
def ensembling(self, optd):
if optd['import_ensembles']:
ensembler.import_ensembles(optd)
elif optd['ideal_helices']:
ample_util.ideal_helices(optd)
logger.info(
"*** Attempting to solve the structure using ideal helices ***"
)
logger.warning(
'If ideal helices do not solve the structure, you may want to use -helical_ensembles in '
'place of -ideal_helices. AMPLE will then use a new set of helical ensembles which has been '
'very successful on solving challenging cases!')
elif optd['helical_ensembles']:
ample_util.ideal_helices(optd)
logger.info(
"*** Attempting to solve the structure using %s set of helical ensembles ***"
% optd['helical_ensembles_set'])
else:
# Check we have some models to work with
if not (optd['single_model_mode'] or optd['processed_models']):
ample_util.save_amoptd(optd)
msg = "ERROR! Cannot find any pdb files in: {0}".format(
optd['models_dir'])
exit_util.exit_error(msg)
optd['ensemble_ok'] = os.path.join(optd['work_dir'], 'ensemble.ok')
if optd['submit_qtype'] != 'local':
# Pickle dictionary so it can be opened by the job to get the parameters
ample_util.save_amoptd(optd)
script = ensembler.cluster_script(optd)
ensembler_timeout = ensembler.get_ensembler_timeout(optd)
with TaskFactory(
optd['submit_qtype'],
script,
cwd=optd['work_dir'],
environment=optd['submit_pe'],
run_time=ensembler_timeout,
name='benchmark',
nprocesses=optd['nproc'],
max_array_size=optd['submit_max_array'],
queue=optd['submit_queue'],
shell="/bin/bash",
) as task:
task.run()
task.wait(interval=5, monitor_f=monitor)
# queue finished so unpickle results
optd.update(ample_util.read_amoptd(optd['results_path']))
else:
try:
ensembler.create_ensembles(optd)
except Exception as e:
msg = "Error creating ensembles: {0}".format(e)
exit_util.exit_error(msg, sys.exc_info()[2])
# Check we have something to work with
if not os.path.isfile(
optd['ensemble_ok']) or 'ensembles' not in optd.keys(
) or not len(optd['ensembles']):
msg = "Problem generating ensembles!"
exit_util.exit_error(msg)
if not (optd['homologs'] or optd['single_model_mode']):
ensemble_summary = ensembler.ensemble_summary(
optd['ensembles_data'])
logger.info(ensemble_summary)
# Save the results
ample_util.save_amoptd(optd)
# Bail here if we didn't create anything
if not len(optd['ensembles']):
msg = "### AMPLE FAILED TO GENERATE ANY ENSEMBLES! ###\nExiting..."
exit_util.exit_error(msg)
# Update results view
if self.ample_output:
self.ample_output.display_results(optd)
return
if not os.path.isdir(optd['work_dir']):
try:
os.mkdir(optd['work_dir'])
except OSError as e:
msg = 'Error making ensemble workdir {0} : {1}'.format(
optd['work_dir'], e)
exit_util.exit_error(msg, sys.exc_info()[2])
assert os.path.isdir(optd['work_dir'])
# Start logging to a file
logging_util.setup_file_logging(os.path.join(optd['work_dir'], "ensemble.log"))
try:
if not restart:
optd['models'] = ample_util.extract_models(optd)
if optd['subcluster_program'] == 'gesamt':
optd['gesamt_exe'] = ample_util.find_exe('gesamt')
elif optd['subcluster_program'] == 'maxcluster':
optd['maxcluster_exe'] = ample_util.find_exe('maxcluster')
else:
raise RuntimeError("Unknown subcluster_program: {0}".format(
optd['subcluster_program']))
optd['theseus_exe'] = ample_util.find_exe('theseus')
optd['ensemble_ok'] = os.path.join(optd['work_dir'], 'ensemble.ok')
optd['results_path'] = os.path.join(optd['work_dir'], AMPLE_PKL)
ensembler.create_ensembles(optd)
ample_util.save_amoptd(optd)
except Exception as e:
msg = "Error running ensembling: {0}".format(e.message)
exit_util.exit_error(msg, sys.exc_info()[2])
def ensembling(self, optd):
if optd['import_ensembles']:
ensembler.import_ensembles(optd)
elif optd['ideal_helices']:
ample_util.ideal_helices(optd)
logger.info("*** Using ideal helices to solve structure ***")
else:
# Check we have some models to work with
if not (optd['single_model_mode'] or optd['processed_models']):
ample_util.save_amoptd(optd)
msg = "ERROR! Cannot find any pdb files in: {0}".format(optd['models_dir'])
exit_util.exit_error(msg)
optd['ensemble_ok'] = os.path.join(optd['work_dir'], 'ensemble.ok')
if optd['submit_cluster']:
# Pickle dictionary so it can be opened by the job to get the parameters
ample_util.save_amoptd(optd)
script = ensembler.cluster_script(optd)
ensembler_timeout = ensembler.get_ensembler_timeout(optd)
workers_util.run_scripts(
job_scripts=[script],
monitor=monitor,
nproc=optd['nproc'],
job_time=ensembler_timeout,
job_name='ensemble',
submit_cluster=optd['submit_cluster'],
submit_qtype=optd['submit_qtype'],
submit_queue=optd['submit_queue'],
submit_pe_lsf=optd['submit_pe_lsf'],
submit_pe_sge=optd['submit_pe_sge'],
submit_array=optd['submit_array'],
submit_max_array=optd['submit_max_array'])
# queue finished so unpickle results
optd.update(ample_util.read_amoptd(optd['results_path']))
else:
try:
ensembler.create_ensembles(optd)
except Exception as e:
msg = "Error creating ensembles: {0}".format(e)
exit_util.exit_error(msg, sys.exc_info()[2])
# Check we have something to work with
if not os.path.isfile(optd['ensemble_ok']) or 'ensembles' not in optd.keys() or not len(optd['ensembles']):
msg = "Problem generating ensembles!"
exit_util.exit_error(msg)
if not (optd['homologs'] or optd['single_model_mode']):
ensemble_summary = ensembler.ensemble_summary(optd['ensembles_data'])
logger.info(ensemble_summary)
# Save the results
ample_util.save_amoptd(optd)
# Bail here if we didn't create anything
if not len(optd['ensembles']):
msg = "### AMPLE FAILED TO GENERATE ANY ENSEMBLES! ###\nExiting..."
exit_util.exit_error(msg)
# Update results view
if self.ample_output:
self.ample_output.display_results(optd)
return