def test_convex_hull_exhaustive_search(self):
self.params.exhaustive.output.csv_name = os.path.join(
self.params.output.out_dir, "test.csv")
exhaustive(self.params)
bound_occ, u_iso, fofc = get_minimum_fofc(
self.params.exhaustive.output.csv_name)
self.assertAlmostEqual(0.6, bound_occ)
self.assertAlmostEqual(0.35, u_iso)
def test_exhaustive_search(self):
""" Test with minimal number of parameters changed from default."""
self.params.exhaustive.output.csv_name = os.path.join(
self.params.output.out_dir, "test.csv")
self.params.exhaustive.options.step = 0.2
exhaustive(self.params)
bound_occ, u_iso, fofc = get_minimum_fofc(
self.params.exhaustive.output.csv_name)
self.assertAlmostEqual(0.6, bound_occ)
self.assertAlmostEqual(0.4, u_iso)
def run_es_many_xtals(xtals, in_dir, out_dir, params):
rejects = []
if not os.path.exists(out_dir):
os.mkdir(out_dir)
for xtal_name in xtals:
params.input.xtal_name = xtal_name
params.input.in_path = os.path.join(in_dir, xtal_name)
params.input.pdb = os.path.join(params.input.in_path, "refine.pdb")
print(params.input.pdb)
params.output.out_dir = os.path.join(out_dir, xtal_name)
if not os.path.exists(params.output.out_dir):
os.mkdir(params.output.out_dir)
params.output.log_dir = os.path.join(params.output.out_dir, "logs")
if not os.path.exists(params.output.log_dir):
os.mkdir(params.output.log_dir)
# TODO Standardise the output name?
params.exhaustive.output.csv_name = params.input.xtal_name \
+ "_exhaustive_search_occ_u_iso.csv"
if os.path.exists(
os.path.join(params.output.out_dir,
params.exhaustive.output.csv_name)):
continue
params.input.mtz = os.path.join(params.input.in_path, "refine.mtz")
try:
check_input_files(params)
except:
rejects.append(xtal_name)
continue
try:
exhaustive(params)
except UnboundLocalError:
rejects.append(xtal_name)
continue
print(rejects)
print("input pdb doesn't exist: {}".format(params.input.pdb))
continue
if not os.path.exists(params.input.mtz):
print("input mtz doesn't exsit: {}".format(params.input.mtz))
continue
params.exhaustive.output.csv_name = os.path.join(
params.output.out_dir, "exhaustive_search.csv")
csv_paths.append(params.exhaustive.output.csv_name)
if os.path.exists(params.exhaustive.output.csv_name):
continue
exhaustive(params=params)
scatter_plot(params.exhaustive.output.csv_name)
with open(os.path.join(compound_dir, "es_minima.csv"), "wb") as minima_csv:
minima_writer = csv.writer(minima_csv, delimiter=",")
for path in csv_paths:
occ, u_iso, fofc = get_minimum_fofc(path)
b_fac = u_iso_to_b_fac(u_iso)
xtal_name = os.path.split(os.path.split(path)[0])[1]
minima_writer.writerow([xtal_name, occ, b_fac, fofc])
#### Covalent ratios ###################
def occ_loop_merge_confs_simulate(params):
""" Simulate Experimental data using phenix f_model.
Run exhaustive_search on simulated data.
Loop over all occupancies between params.validate.options.start_simul_occ
and params.validate.options.end_simul_occ,
in sizes of params.validate.options.step_simulation.
For each of these occupancies:
> Run giant.merge_conformations to generate suitable
(with occupancies set to (1- lig_occ) for ground and to (lig_occ)
for bound state) pdb f (multi-state-model.pdb) to be passed to the
simulation routine.
> If a B factor is to be set (using params.validate.options.set_b)
then set B factor of ground and bound states to
a fixed value using set_b_fac_all_occupancy_groups()
> Simulate Fobs data using phenix.f_model, base ouput on reflections
on params.input.mtz
> Run exhaustive search routine on simulated data. Via qsub submission
> Run phenix.maps (cctbx equivalent) to get viewable map
from simluated mtz.
Parameters
-----------
params: libtbx.phil.scope_extract
python object from phil file,
edited with any additional parameters
Returns
--------
None
"""
# TODO Remove requirement to be in output dir if possible #64
logging.info("Changing to the local directory")
os.chdir(params.output.out_dir)
logging.info("Checking validity of input files")
check_validate_input_files(params=params)
logging.info("Looping over simulated occupancies "
"between {} and {} in steps of {}".format(
params.validate.options.start_simul_occ,
params.validate.options.end_simul_occ,
params.validate.options.step_simulation,
))
for lig_occupancy in np.arange(
params.validate.options.start_simul_occ,
params.validate.options.end_simul_occ +
params.validate.options.step_simulation / 5,
params.validate.options.step_simulation,
):
merged_pdb = os.path.join(
params.output.out_dir,
"{}_refine_occ_{}.pdb".format(params.input.xtal_name,
str(lig_occupancy).replace(".",
"_")),
)
if params.validate.options.overwrite or not os.path.exists(
os.path.join(merged_pdb)):
logging.info("Using giant.merge_conformations to generate a pdb "
"f with bound state occupancy {}".format(
str(1 - lig_occupancy)))
# Params for merging confs
merge_params = merge_phil.extract()
merge_params.input.major = params.validate.input.ground_state_pdb_path
merge_params.input.minor = params.validate.input.bound_state_pdb_path
merge_params.options.major_occupancy = 1 - lig_occupancy
merge_params.options.minor_occupancy = lig_occupancy
merge_params.options.reset_all_occupancies = False
merge_params.output.pdb = merged_pdb
merge_params.output.log = os.path.join(
params.output.log_dir,
"occ_{}_b_{}_merge_conformations.log".format(
str(lig_occupancy).format(lig_occupancy),
str(params.validate.options.set_b).replace(".", "_"),
),
)
merge_conformations(merge_params)
else:
logging.info("Skipping generating merged pdb"
"\n{}\n as it already exists,"
"and overwriting is not flagged".format(merged_pdb))
if params.validate.options.set_b is not None:
merged_file_name, _ = os.path.splitext(merged_pdb)
if params.validate.options.overwrite or not os.path.exists(
merged_pdb + "_set_b_{}.pdb".format(
str(params.validate.options.set_b).replace(".", "_"))):
if params.validate.options.set_all_b is not None:
logging.info(
"Generating pdb f:\n{}\n with"
"all B factors set to {}".format(
merged_file_name +
params.validate.output.set_all_b_name_extension))
set_b_fac_all_atoms(
input_pdb=merged_pdb,
output_pdb=merged_file_name +
params.validate.output.set_all_b_name_extension,
b_fac=params.validate.options.set_b,
)
else:
logging.info(
"Generating pdb f:\n{}\n with B factors"
"of atoms in occupancy groups related to "
"ground and bound states set to {}".format(
merged_file_name +
params.validate.output.set_b_name_extension,
lig_occupancy,
))
set_b_fac_all_occupancy_groups(
input_pdb=merged_pdb,
output_pdb=merged_file_name +
params.validate.output.set_b_name_extension,
b_fac=params.validate.options.set_b,
params=params,
)
if params.validate.options.set_all_b is not None:
merged_pdb = (merged_file_name +
params.validate.output.set_all_b_name_extension)
else:
merged_pdb = (merged_file_name +
params.validate.output.set_b_name_extension)
# TODO merged pdb and simulated mtz names as phil parameters: 54
simulated_mtz = os.path.join(params.output.out_dir,
merged_pdb + ".mtz")
if params.validate.options.overwrite or not os.path.exists(
simulated_mtz):
logging.info("Generating simulated mtz \n{}\n "
"For occupancy {} using cctbx equivalent of "
"phenix.fmodel from pdb: \n{}\n "
"With miller indices matched to "
"input mtz:\n{}\n".format(simulated_mtz,
lig_occupancy, merged_pdb,
params.input.mtz))
# TODO Work out data column label for sensible input:
# Talk to tobias- Frank suggests a pre-selection filter: 32
# TODO Allocate location of fmodel log/ generate log #56
fmodel_args = [
merged_pdb,
params.validate.input.base_mtz,
'data_column_label="F,SIGF"',
"type=real",
"output.file_name={}".format(simulated_mtz),
]
logging.debug("FMODEL: {}".format(fmodel_args))
print("FMODEL: {}".format(fmodel_args))
# The below cctbx code is that called by phenix.fmodel
#
# os.system("phenix.fmodel
# data_column_label=\"F,SIGF\" {} {} type=real".format(merged_pdb,
# params.validate.input.base_mtz))
fmodel_log = open(
os.path.join(
params.output.out_dir,
params.output.log_dir,
"{}_occ_{}_b_{}_fmodel.log".format(
params.input.xtal_name,
str(lig_occupancy).replace(".", "_"),
str(params.validate.options.set_b).replace(".", "_"),
),
),
"w+",
)
fmodel(args=fmodel_args, log=fmodel_log)
fmodel_log.close()
else:
logging.info("Skipping the generation of simulated data:"
"\n{}\n using fmodel as it already exists,"
" for occupancy {}, and "
" params.validate.options.overwrite is "
"{}".format(simulated_mtz, lig_occupancy,
params.validate.options.overwrite))
try:
assert os.path.exists(
merged_pdb +
".mtz"), "Simulated mtz does not exist:\n{}\n".format(
merged_pdb + ".mtz")
except AssertionError:
logging.exception(
"Simulated mtz does not exist:\n{}\n".format(merged_pdb +
".mtz"))
raise
# TODO How to supply sh_file as phil parameter? #54
sh_file = "{}_occ_{}_b_{}.sh".format(
params.input.xtal_name,
str(lig_occupancy).replace(".", "_"),
str(params.validate.options.set_b).replace(".", "_"),
)
params.input.pdb = os.path.join(params.output.out_dir, merged_pdb)
params.input.mtz = simulated_mtz
params.exhaustive.options.mtz_prefix = "simul_{}_".format(
str(lig_occupancy).replace(".", "_"))
params.exhaustive.output.csv_name = (
params.exhaustive.output.csv_prefix + "_occ_{}_b_{}.csv".format(
str(lig_occupancy).replace(".", "_"),
str(params.validate.options.set_b).replace(".", "_"),
))
if params.validate.options.overwrite or not os.path.exists(
os.path.join(params.output.out_dir,
params.exhaustive.output.csv_name)):
# TODO Test with qsub: 57
# TODO Sort parameter passing with qsub: 57
if params.validate.options.use_qsub:
cmd = ("$CCP4/bin/ccp4-python /dls/science/groups/i04-1/"
"elliot-dev/Work/exhaustive_search/exhaustive/"
"exhaustive.py "
"input.pdb={} "
"input.mtz={} "
"output.out_dir={} "
"input.xtal_name={} "
"exhaustive.output.csv_name={} "
"exhaustive.options.step={} "
"exhaustive.options.buffer={} "
"exhaustive.options.grid_spacing={} "
"exhaustive.options.generate_mtz={}").format(
merged_pdb,
merged_pdb + ".mtz",
params.output.out_dir,
params.input.xtal_name,
params.exhaustive.output.csv_name,
params.exhaustive.options.step,
params.validate.options.buffer,
params.exhaustive.options.grid_spacing,
params.exhaustive.options.generate_mtz,
)
logging.info("Writing {} to run exhaustive"
"search via qsub".format(sh_file))
with open(os.path.join(params.output.out_dir, sh_file),
"w") as f:
f.write("#!/bin/bash\n")
f.write('export XChemExplorer_DIR="/dls/science/'
"groups/i04-1/software/XChemExplorer_new/"
'XChemExplorer"\n')
f.write("source /dls/science/groups/i04-1/software/"
"XChemExplorer_new/XChemExplorer/"
"setup-scripts/pandda.setup-sh\n")
f.write(cmd)
logging.info("Job submission to qsub")
qsub_output_log = os.path.join(
params.output.out_dir,
params.output.log_dir,
params.validate.options.qsub_out_prefix +
"_{}.txt".format(str(lig_occupancy).replace(".", "_")),
)
qsub_error_log = os.path.join(
params.output.out_dir,
params.output.log_dir,
params.validate.options.qsub_error_prefix +
"_{}.txt".format(str(lig_occupancy).replace(".", "_")),
)
os.system("qsub -o {} -e {} {}".format(
qsub_output_log,
qsub_error_log,
os.path.join(params.output.out_dir, sh_file),
))
else:
logging.info("Running exhaustive search locally")
exhaustive(params=params)
else:
logging.info("Skipping exhaustive search")
if params.validate.options.generate_ccp4:
if (params.validate.options.overwrite
or not os.path.exists(merged_pdb + ".mtz")
or not os.path.exists(merged_pdb)):
logging.info(
"Converting simualted mtz: "
"\n{}\n to difference map .ccp4 f".format(merged_pdb +
".mtz"))
map_args = [
'maps.map.map_type="mfo-Dfc"',
merged_pdb,
merged_pdb + ".mtz",
]
# equivalent to phenix.maps
generate_map(args=map_args)