def dock_molecules(receptor_filename, molecules, filename):
"""
Dock the specified molecules, writing out to specified file
Parameters
----------
receptor_filename : str
Receptor .oeb.gz filename
molecules : list of openeye.oechem.OEMol
The read molecules to dock
filename : str
The filename to stream docked molecules to
"""
# Read the receptor
print('Loading receptor...')
from openeye import oechem, oedocking
receptor = oechem.OEGraphMol()
if not oedocking.OEReadReceptorFile(receptor, 'receptor.oeb.gz'):
oechem.OEThrow.Fatal("Unable to read receptor")
if oedocking.OEReceptorHasBoundLigand(receptor):
print("Receptor has a bound ligand")
else:
print("Receptor does not have bound ligand")
print('Initializing receptor...')
dockMethod = oedocking.OEDockMethod_Hybrid2
dockResolution = oedocking.OESearchResolution_High
dock = oedocking.OEDock(dockMethod, dockResolution)
success = dock.Initialize(receptor)
# Set up Omega
from openeye import oeomega
omegaOpts = oeomega.OEOmegaOptions(oeomega.OEOmegaSampling_Dense)
#omegaOpts = oeomega.OEOmegaOptions()
omega = oeomega.OEOmega(omegaOpts)
omega.SetStrictStereo(False)
# Dock molecules
with oechem.oemolostream(filename) as ofs:
from tqdm import tqdm
for mol in tqdm(molecules):
dockedMol = oechem.OEGraphMol()
# Expand conformers
omega.Build(mol)
# Dock molecule
retCode = dock.DockMultiConformerMolecule(dockedMol, mol)
if (retCode != oedocking.OEDockingReturnCode_Success):
oechem.OEThrow.Fatal("Docking Failed with error code " + oedocking.OEDockingReturnCodeGetName(retCode))
# Store docking data
sdtag = oedocking.OEDockMethodGetName(dockMethod)
oedocking.OESetSDScore(dockedMol, dock, sdtag)
dock.AnnotatePose(dockedMol)
# Write molecule
oechem.OEWriteMolecule(ofs, dockedMol)
def get_receptor(receptor_file=None, use_hybrid=True, high_resolution=True):
"""
:param receptor_file: file to .oeb or oeb.gz with prepared protein receptor
:param use_hybrid: whether or not to override using hybrid docking method
:param high_resolution: set resolution for search
:return: docking objector from OE, the receptor oemol
"""
from . import dock_conf
from openeye import oedocking
receptor = dock_conf.PrepareReceptorFromBinary(receptor_file)
if oedocking.OEReceptorHasBoundLigand(receptor) and use_hybrid:
dock_method = oedocking.OEDockMethod_Hybrid
else:
dock_method = oedocking.OEDockMethod_Chemgauss4
if high_resolution:
reso = oedocking.OESearchResolution_High
else:
reso = oedocking.OESearchResolution_Default
dock = oedocking.OEDock(dock_method, reso)
dock.Initialize(receptor)
return dock, receptor
def dock_molecules_to_receptor(receptor_filename):
"""
Dock the specified molecules, writing out to specified file
Parameters
----------
receptor_filename : str
Receptor .oeb.gz filename
fragment : str
The fragment name to dock to
"""
import os
# Read the receptor
from openeye import oechem, oedocking
receptor = oechem.OEGraphMol()
if not oedocking.OEReadReceptorFile(receptor, receptor_filename):
oechem.OEThrow.Fatal("Unable to read receptor")
if not oedocking.OEReceptorHasBoundLigand(receptor):
raise Exception("Receptor does not have bound ligand")
#print('Initializing receptor...')
dockMethod = oedocking.OEDockMethod_Hybrid2
dockResolution = oedocking.OESearchResolution_Default
dock = oedocking.OEDock(dockMethod, dockResolution)
success = dock.Initialize(receptor)
# Set up Omega
#print('Expanding conformers...')
from openeye import oeomega
#omegaOpts = oeomega.OEOmegaOptions(oeomega.OEOmegaSampling_Dense)
omegaOpts = oeomega.OEOmegaOptions()
omega = oeomega.OEOmega(omegaOpts)
omega.SetStrictStereo(False)
# Dock molecules
docked_molecules = list()
for mol in molecules:
dockedMol = oechem.OEGraphMol()
# Expand conformers
omega.Build(mol)
# Dock molecule
#print(f'Docking {mol.NumConfs()} conformers...')
retCode = dock.DockMultiConformerMolecule(dockedMol, mol)
if (retCode != oedocking.OEDockingReturnCode_Success):
print("Docking Failed with error code " + oedocking.OEDockingReturnCodeGetName(retCode))
continue
# Store docking data
sdtag = oedocking.OEDockMethodGetName(dockMethod)
oedocking.OESetSDScore(dockedMol, dock, sdtag)
dock.AnnotatePose(dockedMol)
docked_molecules.append( oechem.OEMol(dockedMol) )
return docked_molecules
def dock_molecule(receptor, molecule_smiles, n_conformations=10, n_poses=1):
"""Run the multi-conformer docker.
Parameters
----------
receptor : openeye.oedocking.OEReceptor
The openeye receptor.
molecule_smiles : str
The SMILES string of the molecule.
n_conformations : int, optional
The number of omega conformations to pass to the multi-conformer
docker (default is 10).
n_poses : int, optional
Number of binding poses to return.
Returns
-------
docked_oemol : openeye.oechem.OEMol
The docked multi-conformer OpenEye molecule.
"""
dock = oedocking.OEDock()
dock.Initialize(receptor)
molecule_oemol = moltools.openeye.smiles_to_oemol(molecule_smiles)
molecule_oemol = moltools.openeye.get_charges(molecule_oemol,
keep_confs=n_conformations)
docked_oemol = oechem.OEMol()
dock.DockMultiConformerMolecule(docked_oemol, molecule_oemol, n_poses)
return docked_oemol
def DockConf(pdb_file, mol, MAX_POSES = 5):
receptor = oechem.OEGraphMol()
oedocking.OEReadReceptorFile(receptor, pdb_file)
dock = oedocking.OEDock()
dock.Initialize(receptor)
lig = oechem.OEMol()
err = dock.DockMultiConformerMolecule(lig,mol,MAX_POSES)
return dock, lig, receptor
def DockConf(receptor, mol, MAX_POSES=5):
dock = oedocking.OEDock()
dock.Initialize(receptor)
lig = oechem.OEMol()
err = dock.DockMultiConformerMolecule(lig, mol, MAX_POSES)
# TODO: should do some sort of error checking here. outputs will both be empty molecules
# if it doesn't run properly.
return dock, lig
def __init__(self, receptor: utils.FilePath):
self.receptor_file = receptor
omegaOpts = oeomega.OEOmegaOptions()
omegaOpts.SetStrictStereo(False)
self.omega = oeomega.OEOmega(omegaOpts)
oechem.OEThrow.SetLevel(10000)
oereceptor = oechem.OEGraphMol()
oedocking.OEReadReceptorFile(oereceptor, self.receptor_file)
self.dock = oedocking.OEDock()
self.dock.Initialize(oereceptor)
def init_oedock_from_receptor(receptor, oe_options=None):
oe_options = oe_options or OEOptions()
dockMethod = oedocking.OEDockMethod_Hybrid if oe_options.use_hybrid else oedocking.OEDockMethod_Chemgauss4
dockResolution = oedocking.OESearchResolution_High if oe_options.high_resolution else oedocking.OESearchResolution_Default
dock = oedocking.OEDock(dockMethod, dockResolution)
assert (dock.Initialize(receptor))
if (not oedocking.OEReceptorHasCachedScore(receptor)) and oe_options.cache_receptor:
dock.CacheScoringSetup(receptor, clearOldData=oe_options.cache_receptor_clear)
return dock
def DockConf(pdb_file, mol, MAX_POSES=1, dock=None):
if dock is None:
receptor = oechem.OEGraphMol()
oedocking.OEReadReceptorFile(receptor, pdb_file)
dock = oedocking.OEDock(oedocking.OEScoreType_Chemgauss4,
oedocking.OESearchResolution_High)
dock.Initialize(receptor)
else:
receptor = None
lig = DockConf_(dock, mol, MAX_POSES=MAX_POSES)
return lig, receptor
def main(argv=[__name__]):
if len(argv) != 3:
oechem.OEThrow.Usage("%s <receptor> <conformers>" % argv[0])
receptor = oechem.OEGraphMol()
oedocking.OEReadReceptorFile(receptor, argv[1])
dock = oedocking.OEDock()
dock.Initialize(receptor)
conformers = oechem.OEMol()
imstr = oechem.oemolistream(argv[2])
for conformers in imstr.GetOEMols():
poses = oechem.OEMol()
dock.DockMultiConformerMolecule(poses, conformers)
TagPoses(dock, poses, dock.GetName())
def begin(self):
receptor = oechem.OEGraphMol()
self.args.receptor = utils.download_dataset_to_file(self.args.receptor)
if not oedocking.OEReadReceptorFile(receptor, str(self.args.receptor)):
raise Exception("Unable to read receptor from {0}".format(self.args.receptor))
# Initialize Docking
dock_method = oedocking.OEDockMethod_Hybrid
if not oedocking.OEReceptorHasBoundLigand(receptor):
oechem.OEThrow.Warning("No bound ligand, switching OEDockMethod to ChemGauss4.")
dock_method = oedocking.OEDockMethod_Chemgauss4
dock_resolution = oedocking.OESearchResolution_Default
self.sdtag = oedocking.OEDockMethodGetName(dock_method)
self.dock = oedocking.OEDock(dock_method, dock_resolution)
if not self.dock.Initialize(receptor):
raise Exception("Unable to initialize Docking with {0}".format(self.args.receptor))
def __init__(self, prefix: str, receptor_file: os.PathLike):
"""
:param prefix: Prefix to identify scoring function instance (e.g., Risperidone)
:param receptor_file: Path to receptor file (.oeb).
"""
logger.warning("This code has not been tested (at all!)")
self.prefix = prefix
self.receptor_file = receptor_file
omegaOpts = oeomega.OEOmegaOptions()
omegaOpts.SetStrictStereo(False)
self.omega = oeomega.OEOmega(omegaOpts)
oechem.OEThrow.SetLevel(10000)
oereceptor = oechem.OEGraphMol()
oedocking.OEReadReceptorFile(oereceptor, self.receptor_file)
self.oedock = oedocking.OEDock()
self.oedock.Initialize(oereceptor)
def __init__(self, prefix: str, receptor_file: str):
"""
Scoring function class to perform OpenEye docking (FRED)
:param prefix: Name (to help keep track metrics, if using a scoring function class more than once)
:param receptor_file: Path to oe receptor file.
"""
logger.warning("This code has not been tested (at all!)")
self.prefix = prefix
self.receptor_file = receptor_file
omegaOpts = oeomega.OEOmegaOptions()
omegaOpts.SetStrictStereo(False)
self.omega = oeomega.OEOmega(omegaOpts)
oechem.OEThrow.SetLevel(10000)
oereceptor = oechem.OEGraphMol()
oedocking.OEReadReceptorFile(oereceptor, self.receptor_file)
self.oedock = oedocking.OEDock()
self.oedock.Initialize(oereceptor)
def main(argv=[__name__]):
itf = oechem.OEInterface(InterfaceData)
# @ <SNIPPET-DOCK-MOLECULES-CONFIGURE>
oedocking.OEDockMethodConfigure(itf, "-method")
oedocking.OESearchResolutionConfigure(itf, "-resolution")
# @ </SNIPPET-DOCK-MOLECULES-CONFIGURE>
if not oechem.OEParseCommandLine(itf, argv):
return 1
imstr = oechem.oemolistream(itf.GetString("-in"))
omstr = oechem.oemolostream(itf.GetString("-out"))
receptor = oechem.OEGraphMol()
if not oedocking.OEReadReceptorFile(receptor, itf.GetString("-receptor")):
oechem.OEThrow.Fatal("Unable to read receptor")
# @ <SNIPPET-DOCK-MOLECULES-GET-VALUE>
dockMethod = oedocking.OEDockMethodGetValue(itf, "-method")
dockResolution = oedocking.OESearchResolutionGetValue(itf, "-resolution")
# @ </SNIPPET-DOCK-MOLECULES-GET-VALUE>
# @ <SNIPPET-DOCK-MOLECULES-SETUP>
dock = oedocking.OEDock(dockMethod, dockResolution)
# @ </SNIPPET-DOCK-MOLECULES-SETUP>
# @ <SNIPPET-DOCK-MOLECULES-INITIALIZE>
dock.Initialize(receptor)
# @ </SNIPPET-DOCK-MOLECULES-INITIALIZE>
for mcmol in imstr.GetOEMols():
print("docking", mcmol.GetTitle())
dockedMol = oechem.OEGraphMol()
# @ <SNIPPET-DOCK-MOLECULES-DOCK>
retCode = dock.DockMultiConformerMolecule(dockedMol, mcmol)
if (retCode != oedocking.OEDockingReturnCode_Success):
oechem.OEThrow.Fatal("Docking Failed with error code " + oedocking.OEDockingReturnCodeGetName(retCode))
# @ </SNIPPET-DOCK-MOLECULES-DOCK>
sdtag = oedocking.OEDockMethodGetName(dockMethod)
# @ <SNIPPET-DOCK-MOLECULES-ASSIGN-SCORE>
oedocking.OESetSDScore(dockedMol, dock, sdtag)
# @ </SNIPPET-DOCK-MOLECULES-ASSIGN-SCORE>
# @ <SNIPPET-DOCK-MOLECULES-ANNOTATE>
dock.AnnotatePose(dockedMol)
# @ </SNIPPET-DOCK-MOLECULES-ANNOTATE>
oechem.OEWriteMolecule(omstr, dockedMol)
return 0
def dock_molecule(receptor, molecule_smiles, n_conformations=10, n_poses=2):
"""Run the multi-conformer docker.
Parameters
----------
receptor : openeye.oedocking.OEReceptor
The openeye receptor.
molecule_smiles : str
The SMILES string of the molecule.
n_conformations : int, optional
The number of omega conformations to pass to the multi-conformer
docker (default is 10).
n_poses : int, optional
Number of binding poses to return.
Returns
-------
docked_oemol : openeye.oechem.OEMol
The docked multi-conformer OpenEye molecule.
"""
from openeye import oechem, oedocking
import openmoltools as moltools
if oedocking.OEReceptorHasBoundLigand(receptor):
dock = oedocking.OEHybrid(oedocking.OEDockMethod_Hybrid2,
oedocking.OESearchResolution_High)
else:
dock = oedocking.OEDock()
dock.Initialize(receptor)
molecule_oemol = moltools.openeye.smiles_to_oemol(molecule_smiles)
molecule_oemol = moltools.openeye.get_charges(molecule_oemol,
keep_confs=n_conformations)
docked_oemol = oechem.OEMol()
dock.DockMultiConformerMolecule(docked_oemol, molecule_oemol, n_poses)
return docked_oemol
def main(argv=[__name__]):
itf = oechem.OEInterface()
oedocking.OEDockMethodConfigure(itf, "-method")
oedocking.OESearchResolutionConfigure(itf, "-resolution")
receptors = []
path = "receptor_oebs/*.oeb" #input: receptor oebs
files = glob.glob(path)
for i in files:
receptor = oechem.OEGraphMol()
if not oedocking.OEReadReceptorFile(receptor, i):
oechem.OEThrow.Fatal("Unable to read receptor from %s" % i)
receptors.append(receptor)
dockMethod = 5 #Set scoring function (5=Chemscore)
dockResolution = 2 #set search resolution (2=Standard)
dock = oedocking.OEDock(
dockMethod,
dockResolution) #Selecting exhaustive search and scoring functions
for receptor_idx, receptor in enumerate(receptors):
Centroid_number = files[receptor_idx][-5:-4]
omstr = oechem.oemolostream("Docking_Results/Receptor_%s.oeb" %
(Centroid_number))
dock.Initialize(receptor) #initialize with receptor object
imstr = oechem.oemolistream("lig.oeb.gz")
for mcmol in imstr.GetOEMols():
print("docking", mcmol.GetTitle())
dockedMol = oechem.OEMol()
dock.DockMultiConformerMolecule(dockedMol, mcmol) #Docking
sdtag = oedocking.OEDockMethodGetName(dockMethod)
oedocking.OESetSDScore(dockedMol, dock, sdtag)
dock.AnnotatePose(dockedMol)
oechem.OEWriteMolecule(omstr, dockedMol)
g = open("Docking_Results/score.txt", "a+") #write scores to file
g.write(
str(files[receptor_idx]) + " " + str(mcmol.GetTitle()) + " " +
str(oechem.OEMCMolBase.GetEnergy(dockedMol)) + "\r\n")
g.close()
return 0
def main(argv=[__name__]):
if len(argv) != 3:
oechem.OEThrow.Usage("%s <receptor> <ligand>" % argv[0])
receptor = oechem.OEGraphMol()
oedocking.OEReadReceptorFile(receptor, argv[1])
dock = oedocking.OEDock(oedocking.OEDockMethod_PLP)
dock.Initialize(receptor)
mcmol = oechem.OEMol()
imstr = oechem.oemolistream(argv[2])
oechem.OEReadMolecule(imstr, mcmol)
# @ <SNIPPET-DOCK-SCORING-3>
numPoses = 10
poses = oechem.OEMol()
dock.DockMultiConformerMolecule(poses, mcmol, numPoses)
# @ </SNIPPET-DOCK-SCORING-3>
for pose in poses.GetConfs():
PrintScore(dock, pose)
for atom in pose.GetAtoms():
PrintAtomScore(dock, pose, atom)
def run_docking(receptor,
molecules,
dock_method,
num_poses=1,
docking_poses_save_path=None):
"""
Dock molecules into a prepared receptor.
Parameters
----------
receptor: oechem.OEGraphMol
An oechem.OEGraphMol object holding the prepared receptor.
molecules: list of oechem.OEGraphMol
A list of oechem.OEGraphMol objects holding prepared molecules for docking.
dock_method: int
Constant defining the docking method.
num_poses: int
Number of docking poses to generate per molecule.
docking_poses_save_path: str
File path for saving docking poses. If docking_poses_save_path is not provided, docking poses will not be saved.
Returns
-------
docked_molecules: list of oechem.OEGraphMol
A list of oechem.OEGraphMol objects holding the docked molecules.
"""
# Standard libraries
import pathlib
# External libraries
from openeye import oechem, oedocking, oequacpac, oeomega
# initialize receptor
dock_resolution = oedocking.OESearchResolution_High
dock = oedocking.OEDock(dock_method, dock_resolution)
dock.Initialize(receptor)
def score(molecule, dock=dock):
"""Return the docking score."""
value = oechem.OEGetSDData(molecule, dock.GetName())
return float(value)
docked_molecules = list()
# dock molecules
for molecule in molecules:
# enumerate tautomers
tautomer_options = oequacpac.OETautomerOptions()
tautomer_options.SetMaxTautomersGenerated(4096)
tautomer_options.SetMaxTautomersToReturn(16)
tautomer_options.SetCarbonHybridization(True)
tautomer_options.SetMaxZoneSize(50)
tautomer_options.SetApplyWarts(True)
pKa_norm = True
tautomers = [
oechem.OEMol(tautomer)
for tautomer in oequacpac.OEGetReasonableTautomers(
molecule, tautomer_options, pKa_norm)
]
# set up omega
omega_options = oeomega.OEOmegaOptions()
omega_options.SetMaxSearchTime(60.0) # time out
omega = oeomega.OEOmega(omega_options)
omega.SetStrictStereo(False) # enumerate stereochemistry if uncertain
docked_tautomers = list()
# dock tautomers
for mol in tautomers:
docked_mol = oechem.OEMol()
# expand conformers
omega.Build(mol)
# dock molecule
return_code = dock.DockMultiConformerMolecule(
docked_mol, mol, num_poses)
if return_code != oedocking.OEDockingReturnCode_Success:
print(
f'Docking failed for molecule with title {mol.GetTitle()} with error code '
f'{oedocking.OEDockingReturnCodeGetName(return_code)}.')
continue
# store docking data
oedocking.OESetSDScore(docked_mol, dock, dock.GetName())
# expand conformations
for conformation in docked_mol.GetConfs():
docked_tautomers.append(oechem.OEGraphMol(conformation))
# sort all conformations of all tautomers by score
docked_tautomers.sort(key=score)
# keep number of conformations as specified by num_poses
docked_molecules += docked_tautomers[:num_poses]
if len(docked_molecules) == 0:
return None
# save docking poses
if docking_poses_save_path is not None:
write_mols(docked_molecules,
str(pathlib.Path(docking_poses_save_path).absolute()))
return docked_molecules
def _execute(self, directory, available_resources):
import mdtraj
from openeye import oechem, oedocking
from simtk import unit as simtk_unit
if (len(self.ligand_substance.components) != 1
or self.ligand_substance.components[0].role !=
Component.Role.Ligand):
raise ValueError(
"The ligand substance must contain a single ligand component.")
logger.info("Initializing the receptor molecule.")
receptor_molecule = self._create_receptor()
logger.info("Initializing the ligand molecule.")
ligand_molecule = self._create_ligand()
logger.info("Initializing the docking object.")
# Dock the ligand to the receptor.
dock = oedocking.OEDock()
dock.Initialize(receptor_molecule)
docked_ligand = oechem.OEGraphMol()
logger.info("Performing the docking.")
status = dock.DockMultiConformerMolecule(docked_ligand,
ligand_molecule)
if status != oedocking.OEDockingReturnCode_Success:
raise RuntimeError("The ligand could not be successfully docked", )
docking_method = oedocking.OEDockMethodGetName(
oedocking.OEDockMethod_Default)
oedocking.OESetSDScore(docked_ligand, dock, docking_method)
dock.AnnotatePose(docked_ligand)
self.docked_ligand_coordinate_path = path.join(directory, "ligand.pdb")
output_stream = oechem.oemolostream(self.docked_ligand_coordinate_path)
oechem.OEWriteMolecule(output_stream, docked_ligand)
output_stream.close()
receptor_pdb_path = path.join(directory, "receptor.pdb")
output_stream = oechem.oemolostream(receptor_pdb_path)
oechem.OEWriteMolecule(output_stream, receptor_molecule)
output_stream.close()
ligand_trajectory = mdtraj.load(self.docked_ligand_coordinate_path)
ligand_residue = ligand_trajectory.topology.residue(0)
ligand_residue.name = self.ligand_residue_name
# Save the ligand file with the correct residue name.
ligand_trajectory.save(self.docked_ligand_coordinate_path)
receptor_trajectory = mdtraj.load(receptor_pdb_path)
receptor_residue = receptor_trajectory.topology.residue(0)
receptor_residue.name = self.receptor_residue_name
# Create a merged ligand-receptor topology.
complex_topology = ligand_trajectory.topology.copy()
atom_mapping = {}
new_residue = complex_topology.add_residue(receptor_residue.name,
complex_topology.chain(0))
for receptor_atom in receptor_residue.atoms:
new_atom = complex_topology.add_atom(
receptor_atom.name,
receptor_atom.element,
new_residue,
serial=receptor_atom.serial,
)
atom_mapping[receptor_atom] = new_atom
for bond in receptor_trajectory.topology.bonds:
complex_topology.add_bond(
atom_mapping[bond[0]],
atom_mapping[bond[1]],
type=bond.type,
order=bond.order,
)
complex_positions = []
complex_positions.extend(
ligand_trajectory.openmm_positions(0).value_in_unit(
simtk_unit.angstrom))
complex_positions.extend(
receptor_trajectory.openmm_positions(0).value_in_unit(
simtk_unit.angstrom))
complex_positions *= simtk_unit.angstrom
self.docked_complex_coordinate_path = path.join(
directory, "complex.pdb")
with open(self.docked_complex_coordinate_path, "w+") as file:
app.PDBFile.writeFile(complex_topology.to_openmm(),
complex_positions, file)
def hybrid_docking(receptor_path,
molecules_path,
docked_molecules_path,
n_poses=10):
"""Automated hybrid docking of small molecules to a receptor.
Parameters
----------
receptor_path : str
Path to PDB file containing receptor and reference ligand, or pre-prepared receptor for docking
molecules_path : str
Path to file containing one or more molecules (in OpenEye readable format) to be docked.
(For example, list of SMILES)
docked_molecules_path : str
Path to output file to be created to contain docked molecules
Uses OpenEye recognized file extension, such as .mol2 or .sdf
n_poses : int, optional, default=1
Number of docked poses to generate
receptor_filename : str, optional, default=None
If not None, the pre-prepared receptor is loaded
TODO: How can this API be improved?
"""
from .docking import create_receptor, load_receptor, pose_molecule
from openeye import oedocking, oechem
#import openmoltools as moltools # TODO: Bring these methods into this module
# Try to load pre-prepared receptor from specified file
receptor = oechem.OEGraphMol()
print('Attempting to load receptor from {}...'.format(receptor_path))
if not oedocking.OEReadReceptorFile(receptor, receptor_path):
# Load complex of receptor and reference ligand
complex_istream = oechem.oemolistream(receptor_path)
complex = oechem.OEGraphMol()
oechem.OEReadMolecule(complex_istream, complex)
# Attempt to split into components and build receptor based on reference ligand
print('Attempting to split complex into components...')
ligand = oechem.OEGraphMol()
protein = oechem.OEGraphMol()
water = oechem.OEGraphMol()
other = oechem.OEGraphMol()
if oechem.OESplitMolComplex(ligand, protein, water, other, complex):
# Create receptor using bound ligand reference
print('Creating receptor using reference ligand...')
oedocking.OEMakeReceptor(receptor, protein, ligand)
# TODO: We can store prepared receptor file if desired
oedocking.OEWriteReceptorFile(
receptor,
'/home/guoj1/projects/INSPIRE/kinomodel/kinomodel/data/docking/prepared_receptor.oeb'
)
else:
raise Exception(
'Could not split specified PDB file {} into receptor and reference ligand'
.format(receptor_path))
# Open file for writing docked molecules
docked_molecules_ostream = oechem.oemolostream(docked_molecules_path)
# Configure omega
# From canonical recipe: https://docs.eyesopen.com/toolkits/cookbook/python/modeling/am1-bcc.html
from openeye import oeomega
omega = oeomega.OEOmega()
omega.SetIncludeInput(False)
omega.SetCanonOrder(False)
omega.SetSampleHydrogens(True)
eWindow = 15.0
omega.SetEnergyWindow(eWindow)
omega.SetMaxConfs(800)
omega.SetRMSThreshold(1.0)
# Dock all molecules requested
dock_method = oedocking.OEDockMethod_Hybrid2
dock_resolution = oedocking.OESearchResolution_Standard
dock = oedocking.OEDock(dock_method, dock_resolution)
dock.Initialize(receptor)
molecules_istream = oechem.oemolistream(molecules_path)
molecule = oechem.OEGraphMol()
for molecule in molecules_istream.GetOEMols():
print("docking", molecule.GetTitle())
#docked_molecules = pose_molecule(receptor, molecule, n_poses=n_poses)
#molecule = moltools.openeye.get_charges(molecule, keep_confs=10)
# Generate conformers
if not omega(molecule):
continue
# Apply charges
from openeye import oequacpac
oequacpac.OEAssignCharges(molecule, oequacpac.OEAM1BCCELF10Charges())
# Dock
docked_molecule = oechem.OEGraphMol()
dock.DockMultiConformerMolecule(docked_molecule, molecule)
sdtag = oedocking.OEDockMethodGetName(dock_method)
oedocking.OESetSDScore(docked_molecule, dock, sdtag)
dock.AnnotatePose(docked_molecule)
oechem.OEWriteMolecule(docked_molecules_ostream, docked_molecule)
def getscores(self,
actions,
gsmis,
prot,
lig,
num_returns=10,
return_docked_pose=False,
refmol=None):
with self.logger("getscores") as logger:
if num_returns <= 0:
num_returns = len(actions) - 1
logger.log("Action space is ", len(actions))
idxs = list(
np.random.choice(len(actions),
min(num_returns,
len(actions) - 1),
replace=False).flatten())
actions = [actions[idx] for idx in idxs]
gsmis = [gsmis[idx] for idx in idxs]
protein = oechem.OEMol(prot)
receptor = oechem.OEGraphMol()
if not (self.sort == 'iscores' and self.optimize):
logger.log(
"Creating receptor from recent pdb, this might take awhile"
)
oedocking.OEMakeReceptor(receptor, protein, lig)
dockobj = oedocking.OEDock(self.dockmethod)
dockobj.Initialize(receptor)
assert (dockobj.IsInitialized())
logger.log("done")
else:
dockobj = None
logger.log(
"Skipping receptor building as optimize is set and sort method is iscore."
)
pscores = []
dscores = []
ds_old_scores = []
ds_start_scores = []
data = []
with multiprocessing.Pool() as p:
imapiter = p.imap(
self.env.action.aligner.__class__.call_static,
zip(actions, gsmis,
[copy.deepcopy(refmol)] * len(actions)))
for idx, res in enumerate(imapiter):
try:
if res is None:
logger.error(
"Alignment failed and returned none for ",
gsmis[idx])
continue
ps, ds, ds_start, ds_old = None, None, None, []
new_mol, new_mol2, gs, action = res
if dockobj is not None:
dockedpose = oechem.OEMol()
newmol2 = oechem.OEMol(new_mol)
dockobj.DockMultiConformerMolecule(
dockedpose, newmol2, 1)
ds = dockedpose.GetEnergy()
ps = dockobj.ScoreLigand(new_mol)
dscores.append(ds)
pscores.append(ps)
if return_docked_pose:
new_mol_ = oechem.OEMol(dockedpose)
if self.start_dobj is not None:
dockedpose2 = oechem.OEMol()
newmol2 = oechem.OEMol(new_mol)
self.start_dobj.DockMultiConformerMolecule(
dockedpose2, newmol2, 1)
ds_start = dockedpose2.GetEnergy()
ds_start_scores.append(ds_start)
if self.track_hscores:
for olddobj in self.past_dockobjs:
dockedpose2 = oechem.OEMol()
newmol2 = oechem.OEMol(new_mol)
olddobj.DockMultiConformerMolecule(
dockedpose2, newmol2, 1)
ds_old.append(dockedpose2.GetEnergy())
ds_old_scores.append(ds_old)
if dockobj is not None and return_docked_pose:
new_mol = new_mol_
oechem.OEAssignAromaticFlags(new_mol)
oechem.OEAddExplicitHydrogens(new_mol)
oechem.OE3DToInternalStereo(new_mol)
new_mol2 = oechem.OEMol(new_mol)
gs = oechem.OECreateSmiString(
new_mol, oechem.OESMILESFlag_DEFAULT
| oechem.OESMILESFlag_Hydrogens
| oechem.OESMILESFlag_Isotopes
| oechem.OESMILESFlag_BondStereo
| oechem.OESMILESFlag_AtomStereo)
logger.log(
f"(idx / {len(idxs)}: Pose Score {ps}, Dock Score {ds}, Init Score {ds_start}"
)
data.append((new_mol, new_mol2, gs, action))
except Exception as p:
logger.error(p)
traceback.print_tb(p.__traceback__)
continue
self.past_dockobjs.append(dockobj)
self.past_receptors.append(receptor)
logger.log("Sorting on", self.sort)
if self.sort == 'dscores':
order = np.argsort(dscores)
logger.log([dscores[i] for i in order])
elif self.sort == 'pscores':
order = np.argsort(pscores)
logger.log([pscores[i] for i in order])
elif self.sort == 'iscores':
order = np.argsort(ds_start_scores)
logger.log([ds_start_scores[i] for i in order])
elif self.sort == 'hscores':
hscores = [
np.quantile(np.clip(scoreset, None, 0), 0.)
for scoreset in ds_old_scores
]
order = np.argsort(hscores)
logger.log([hscores[i] for i in order])
else:
assert (False)
self.env.data['dscores'].append(dscores)
self.env.data['pscores'].append(pscores)
self.env.data['iscores'].append(ds_start_scores)
self.env.data['hscores'].append(ds_old_scores)
data = [data[i] for i in order]
return data
def _run_docking(
receptor: oechem.OEGraphMol,
molecules: List[oechem.OEGraphMol],
dock_method: int,
num_poses: int = 1,
) -> Union[List[oechem.OEGraphMol], None]:
"""
Dock molecules into a prepared receptor.
Parameters
----------
receptor: oechem.OEGraphMol
An OpenEye molecule holding the prepared receptor.
molecules: list of oechem.OEGraphMol
A list of OpenEye molecules holding prepared molecules for docking.
dock_method: int
Constant defining the docking method.
num_poses: int
Number of docking poses to generate per molecule.
Returns
-------
docked_molecules: list of oechem.OEGraphMol or None
A list of OpenEye molecules holding the docked molecules.
"""
from openeye import oedocking
from ..modeling.OEModeling import generate_reasonable_conformations
# initialize receptor
dock_resolution = oedocking.OESearchResolution_High
dock = oedocking.OEDock(dock_method, dock_resolution)
dock.Initialize(receptor)
def score(molecule: oechem.OEGraphMol, dock: oedocking.OEDock = dock):
"""Return the docking score."""
value = oechem.OEGetSDData(molecule, dock.GetName())
return float(value)
docked_molecules = list()
# dock molecules
for molecule in molecules:
# tautomers, enantiomers, conformations
conformations_ensemble = generate_reasonable_conformations(molecule, dense=True)
docked_conformations = list()
# dock tautomers
for conformations in conformations_ensemble:
docked_mol = oechem.OEMol()
# dock molecule
return_code = dock.DockMultiConformerMolecule(docked_mol, conformations, num_poses)
if return_code != oedocking.OEDockingReturnCode_Success:
# TODO: Maybe something for logging
print(
f"Docking failed for molecule with title {conformations.GetTitle()} with error code "
f"{oedocking.OEDockingReturnCodeGetName(return_code)}."
)
continue
# store docking data
oedocking.OESetSDScore(docked_mol, dock, dock.GetName())
# expand conformations
for conformation in docked_mol.GetConfs():
docked_conformations.append(oechem.OEGraphMol(conformation))
# sort all conformations of all tautomers and enantiomers by score
docked_conformations.sort(key=score)
# keep number of conformations as specified by num_poses
docked_molecules += docked_conformations[:num_poses]
if len(docked_molecules) == 0:
# TODO: returning None when something goes wrong
return None
return docked_molecules
def __init__(self,
env,
sort='dscores',
return_docked_pose=False,
num_returns=-1,
orig_pdb=None,
useHybrid=False,
trackHScores=True,
optimize=False):
self.logger = make_message_writer(env.verbose, self.__class__.__name__)
with self.logger("__init__") as logger:
self.sort = sort
if self.sort not in ['iscores', 'dscores', 'hscores', 'pscores']:
logger.failure(
f"{self.sort} is not a valid sorting method. Exiting",
exit_all=True)
self.return_docked_pose = return_docked_pose
self.num_returns = num_returns
self.env = env
self.orig_pdb = orig_pdb
self.start_dobj = None
self.start_receptor = None
self.track_hscores = trackHScores
if not self.track_hscores and self.sort == 'hscores':
logger.error(
"Track hscores is set to false but the sorting method desired is hscores. Assuming this was error, continuing by setting track_hscores to True"
)
self.track_hscores = True
self.past_receptors = []
self.past_dockobjs = []
self.past_coordinates = []
self.optimize = optimize
self.dockmethod = oedocking.OEDockMethod_Hybrid if useHybrid else oedocking.OEDockMethod_Chemgauss4
if (not (self.sort != 'iscores'
and self.optimize)) and self.orig_pdb is not None:
pdb = oechem.OEMol()
prot = oechem.OEMol()
lig = oechem.OEMol()
wat = oechem.OEGraphMol()
other = oechem.OEGraphMol()
ifs = oechem.oemolistream(self.orig_pdb)
oechem.OEReadMolecule(ifs, pdb)
ifs.close()
if not oechem.OESplitMolComplex(lig, prot, wat, other, pdb):
logger.failure("Could not split complex", exit_all=True)
self.start_receptor = oechem.OEGraphMol()
logger.log("Building initial receptor file...")
oedocking.OEMakeReceptor(self.start_receptor, prot, lig)
self.start_dobj = oedocking.OEDock(self.dockmethod)
self.start_dobj.Initialize(self.start_receptor)
assert (self.start_dobj.IsInitialized())
logger.log("done")
elif self.sort != 'iscores' and self.optimize:
logger.log(
"Skipping building inital receptor because optmize is set and sorting method is not iscore"
)
else:
logger.log(
"Skipping building inital receptor because orig_pdb was not provided."
)
def dock_molecule_to_receptor(molecule, receptor_filename, covalent=False):
"""
Dock the specified molecules, writing out to specified file
Parameters
----------
molecule : oechem.OEMol
The molecule to dock
receptor_filename : str
Receptor to dock to
covalent : bool, optional, default=False
If True, try to place covalent warheads in proximity to CYS145
Returns
-------
docked_molecule : openeye.oechem.OEMol
Returns the best tautomer/protomer in docked geometry, annotated with docking score
None is returned if no viable docked pose found
"""
import os
# Extract the fragment name for the receptor
fragment = extract_fragment_from_filename(receptor_filename)
# Read the receptor
from openeye import oechem, oedocking
receptor = oechem.OEGraphMol()
if not oedocking.OEReadReceptorFile(receptor, receptor_filename):
oechem.OEThrow.Fatal("Unable to read receptor")
#print(f'Receptor has {receptor.NumAtoms()} atoms')
if not oedocking.OEReceptorHasBoundLigand(receptor):
raise Exception("Receptor does not have bound ligand")
#print('Initializing receptor...')
dockMethod = oedocking.OEDockMethod_Hybrid2
dockResolution = oedocking.OESearchResolution_High
dock = oedocking.OEDock(dockMethod, dockResolution)
success = dock.Initialize(receptor)
# Add covalent restraint if specified
warheads_found = find_warheads(molecule)
if covalent and len(warheads_found) > 0:
warheads_found = set(warheads_found.keys())
# Initialize covalent constraints
customConstraints = oedocking.OEReceptorGetCustomConstraints(receptor)
# Find CYS145 SG atom
hv = oechem.OEHierView(receptor)
hres = hv.GetResidue("A", "CYS", 145)
proteinHeavyAtom = None
for atom in hres.GetAtoms():
if atom.GetName().strip() == 'SG':
proteinHeavyAtom = atom
break
if proteinHeavyAtom is None:
raise Exception('Could not find CYS145 SG')
# Add the constraint
feature = customConstraints.AddFeature()
feature.SetFeatureName("CYS145 proximity")
for warhead_type in warheads_found:
smarts = covalent_warhead_smarts[warhead_type]
print(f'Adding constraint for SMARTS pattern {smarts}')
feature.AddSmarts(smarts)
sphereRadius = 4.0 # Angstroms
sphereCenter = oechem.OEFloatArray(3)
receptor.GetCoords(proteinHeavyAtom, sphereCenter)
sphere = feature.AddSphere()
sphere.SetRad(sphereRadius)
sphere.SetCenter(sphereCenter[0], sphereCenter[1], sphereCenter[2])
oedocking.OEReceptorSetCustomConstraints(receptor, customConstraints)
# Enumerate tautomers
from openeye import oequacpac
tautomer_options = oequacpac.OETautomerOptions()
tautomer_options.SetMaxTautomersGenerated(4096)
tautomer_options.SetMaxTautomersToReturn(16)
tautomer_options.SetCarbonHybridization(True)
tautomer_options.SetMaxZoneSize(50)
tautomer_options.SetApplyWarts(True)
pKa_norm = True
tautomers = [ oechem.OEMol(tautomer) for tautomer in oequacpac.OEGetReasonableTautomers(molecule, tautomer_options, pKa_norm) ]
# Set up Omega
#print('Expanding conformers...')
from openeye import oeomega
#omegaOpts = oeomega.OEOmegaOptions(oeomega.OEOmegaSampling_Dense)
omegaOpts = oeomega.OEOmegaOptions()
#omegaOpts.SetMaxConfs(5000)
omegaOpts.SetMaxSearchTime(60.0) # time out
omega = oeomega.OEOmega(omegaOpts)
omega.SetStrictStereo(False) # enumerate sterochemistry if uncertain
# Dock tautomers
docked_molecules = list()
from tqdm import tqdm
for mol in tautomers:
dockedMol = oechem.OEGraphMol()
# Expand conformers
omega.Build(mol)
# Dock molecule
retCode = dock.DockMultiConformerMolecule(dockedMol, mol)
if (retCode != oedocking.OEDockingReturnCode_Success):
#print("Docking Failed with error code " + oedocking.OEDockingReturnCodeGetName(retCode))
continue
# Store docking data
sdtag = oedocking.OEDockMethodGetName(dockMethod)
oedocking.OESetSDScore(dockedMol, dock, sdtag)
oechem.OESetSDData(dockedMol, "docked_fragment", fragment)
dock.AnnotatePose(dockedMol)
docked_molecules.append( dockedMol.CreateCopy() )
if len(docked_molecules) == 0:
return None
# Select the best-ranked molecule and pose
# Note that this ignores protonation state and tautomer penalties
docked_molecules.sort(key=score)
best_molecule = docked_molecules[0]
return best_molecule
