def generate_alternate_3d_nonaromatic_ring_confs(
contnrs,
max_variants_per_compound,
thoroughness,
num_procs,
second_embed,
job_manager,
parallelizer_obj,
):
"""Docking programs like Vina rotate chemical moieties around their
rotatable bonds, so it's not necessary to generate a larger rotomer
library for each molecule. The one exception to this rule is
non-aromatic rings, which can assume multiple conformations (boat vs.
chair, etc.). This function generates a few low-energy ring structures
for each molecule with a non-aromatic ring(s).
:param contnrs: A list of containers (MolContainer.MolContainer).
:type contnrs: list
:param max_variants_per_compound: To control the combinatorial explosion,
only this number of variants (molecules) will be advanced to the next
step.
:type max_variants_per_compound: int
:param thoroughness: How many molecules to generate per variant (molecule)
retained, for evaluation. For example, perhaps you want to advance five
molecules (max_variants_per_compound = 5). You could just generate five
and advance them all. Or you could generate ten and advance the best
five (so thoroughness = 2). Using thoroughness > 1 increases the
computational expense, but it also increases the chances of finding good
molecules.
:type thoroughness: int
:param num_procs: The number of processors to use.
:type num_procs: int
:param second_embed: Whether to try to generate 3D coordinates using an
older algorithm if the better (default) algorithm fails. This can add
run time, but sometimes converts certain molecules that would
otherwise fail.
:type second_embed: bool
:param job_manager: The multiprocess mode.
:type job_manager: string
:param parallelizer_obj: The Parallelizer object.
:type parallelizer_obj: Parallelizer.Parallelizer
:return: Returns None if no ring conformers are generated
:rtype: None
"""
# Let the user know you've started this step.
Utils.log(
"Generating several conformers of molecules with non-aromatic "
+ "rings (boat vs. chair, etc.)..."
)
# Create parameters (inputs) to feed to the parallelizer.
params = []
ones_with_nonaro_rngs = set([]) # This is just to keep track of which
# ones have non-aromatic rings.
for contnr_idx, contnr in enumerate(contnrs):
if contnr.num_nonaro_rngs > 0:
ones_with_nonaro_rngs.add(contnr_idx)
for mol in contnr.mols:
params.append(
tuple([mol, max_variants_per_compound, thoroughness, second_embed])
)
params = tuple(params)
# If there are no compounds with non-aromatic rings, no need to continue.
if len(ones_with_nonaro_rngs) == 0:
return # There are no such ligands to process.
# Run it through the parallelizer
tmp = []
if parallelizer_obj != None:
tmp = parallelizer_obj.run(
params, parallel_get_ring_confs, num_procs, job_manager
)
else:
for i in params:
tmp.append(parallel_get_ring_confs(i[0], i[1], i[2], i[3]))
# Flatten the results.
results = Parallelizer.flatten_list(tmp)
# Group by mol. You can't use existing functions because they would
# require you to recalculate already calculated energies.
grouped = {} # Index will be container index. Value is list of
# (energy, mol) pairs.
for mol in results:
# Save the energy as a prop while you're here.
energy = mol.conformers[0].energy
mol.mol_props["Energy"] = energy
# Add the mol with it's energy to the appropriate entry in grouped.
# Make that entry if needed.
contnr_idx = mol.contnr_idx
if not contnr_idx in grouped:
grouped[contnr_idx] = []
grouped[contnr_idx].append((energy, mol))
# Now, for each container, keep only the best ones.
for contnr_idx in grouped:
lst_enrgy_mol_pairs = grouped[contnr_idx]
if len(lst_enrgy_mol_pairs) != 0:
contnrs[contnr_idx].mols = [] # Note that only affects ones that
# had non-aromatic rings.
lst_enrgy_mol_pairs.sort() # Sorting by energy (first item in
# pair).
# Keep only the top ones.
lst_enrgy_mol_pairs = lst_enrgy_mol_pairs[:max_variants_per_compound]
# Add the top ones to the container mol list.
for energy, mol in lst_enrgy_mol_pairs:
contnrs[contnr_idx].add_mol(mol)
else:
# There are no entries in the list. It apparently wasn't able to
# generate any alternate conformers. Let the user know.
for i in range(len(contnrs[contnr_idx].mols)):
contnrs[contnr_idx].mols[i].genealogy.append(
"(WARNING: Could not generate alternate conformations "
+ "of nonaromatic ring)"
)
def enumerate_chiral_molecules(contnrs, max_variants_per_compound,
thoroughness, num_procs, job_manager,
parallelizer_obj):
"""Enumerates all possible enantiomers of a molecule. If the chirality of
an atom is given, that chiral center is not varied. Only the chirality
of unspecified chiral centers is varied.
:param contnrs: A list of containers (MolContainer.MolContainer).
:type contnrs: list
:param max_variants_per_compound: To control the combinatorial explosion,
only this number of variants (molecules) will be advanced to the next
step.
:type max_variants_per_compound: int
:param thoroughness: How many molecules to generate per variant (molecule)
retained, for evaluation. For example, perhaps you want to advance five
molecules (max_variants_per_compound = 5). You could just generate five
and advance them all. Or you could generate ten and advance the best
five (so thoroughness = 2). Using thoroughness > 1 increases the
computational expense, but it also increases the chances of finding good
molecules.
:type thoroughness: int
:param num_procs: The number of processors to use.
:type num_procs: int
:param job_manager: The multiprocess mode.
:type job_manager: string
:param parallelizer_obj: The Parallelizer object.
:type parallelizer_obj: Parallelizer.Parallelizer
"""
# No point in continuing none requested.
if max_variants_per_compound == 0:
return
Utils.log("Enumerating all possible enantiomers for all molecules...")
# Group the molecules so you can feed them to parallelizer.
params = []
for contnr in contnrs:
for mol in contnr.mols:
params.append(tuple([mol, thoroughness,
max_variants_per_compound]))
params = tuple(params)
# Run it through the parallelizer.
tmp = []
if parallelizer_obj != None:
tmp = parallelizer_obj.run(params, parallel_get_chiral, num_procs,
job_manager)
else:
for i in params:
tmp.append(parallel_get_chiral(i[0], i[1], i[2]))
# Remove Nones (failed molecules)
clean = Parallelizer.strip_none(tmp)
# Flatten the data into a single list.
flat = Parallelizer.flatten_list(clean)
# Get the indexes of the ones that failed to generate.
contnr_idxs_of_failed = Utils.fnd_contnrs_not_represntd(contnrs, flat)
# Go through the missing ones and throw a message.
for miss_indx in contnr_idxs_of_failed:
Utils.log("\tCould not generate valid enantiomers for " +
contnrs[miss_indx].orig_smi + " (" +
contnrs[miss_indx].name + "), so using existing " +
"(unprocessed) structures.")
for mol in contnrs[miss_indx].mols:
mol.genealogy.append("(WARNING: Unable to generate enantiomers)")
clean.append(mol)
# Keep only the top few compound variants in each container, to prevent a
# combinatorial explosion.
ChemUtils.bst_for_each_contnr_no_opt(contnrs, flat,
max_variants_per_compound,
thoroughness)