Docking

Docking is the process of determining the structure of a ligand bound in the active site of a target protein. In the Docking Toolkit this is done with the OEDock class that takes a multiconformer representation of a ligand and returns the top scoring pose (or poses if desired) within the active site. Docking is done using an exhaustive search algorithm, followed by optimization of the best poses from the exhaustive search (see Docking Algorithm section).

Listing 2 is an example program that uses the OEDock class to dock, score and annotate multiconformer molecules.

Required Parameters

-receptor

Filename of a receptor.

-in

Input file of multiconformer molecules to dock.

-out

Output file for docked molecules.

Optional Parameters

-method

Scoring method to use.

-resolution

Docking resolution to use.

Listing 2: Example program for docking molecules

#!/usr/bin/env python
#
# Copyright (c) 2010,2014 OpenEye Scientific Software, Inc.
#
from __future__ import print_function
import sys

from openeye.oechem import *
from openeye.oedocking import *

def main(argv = [__name__]):
    itf = OEInterface(InterfaceData)
    OEDockMethodConfigure(itf, "-method")
    OESearchResolutionConfigure(itf, "-resolution")
    if not OEParseCommandLine(itf, argv):
        return 1

    imstr = oemolistream(itf.GetString("-in"))
    omstr = oemolostream(itf.GetString("-out"))

    receptor = OEGraphMol()
    if not OEReadReceptorFile(receptor, itf.GetString("-receptor")):
        OEThrow.Fatal("Unable to read receptor")

    dockMethod = OEDockMethodGetValue(itf, "-method")
    dockResolution = OESearchResolutionGetValue(itf, "-resolution")
    dock = OEDock(dockMethod, dockResolution)
    dock.Initialize(receptor)

    for mcmol in imstr.GetOEMols():
        print ("docking", mcmol.GetTitle())
        dockedMol = OEGraphMol()
        dock.DockMultiConformerMolecule(dockedMol, mcmol)
        sdtag = OEDockMethodGetName(dockMethod)
        OESetSDScore(dockedMol, dock, sdtag)
        dock.AnnotatePose(dockedMol)
        OEWriteMolecule(omstr, dockedMol)

    return 0

InterfaceData = """
!PARAMETER -receptor
  !ALIAS -rec
  !TYPE string
  !REQUIRED true
  !LEGAL_VALUE *.oeb
  !LEGAL_VALUE *.oeb.gz 
  !BRIEF A receptor file the molecules pass to the -in flag will be docked to
!END

!PARAMETER -in
  !TYPE string
  !REQUIRED true
  !BRIEF Multiconformer file of molecules to be docked.
!END

!PARAMETER -out
  !TYPE string
  !REQUIRED true
  !BRIEF Docked molecules will be written to this file
!END
"""

if __name__ == "__main__":
    sys.exit(main(sys.argv))

Scoring Functions and Search Resolution

The resolution of the exhaustive search and scoring functions used are chosen when the OEDock object is constructed, as shown in this snippet of code from Listing 2.

dock = OEDock(dockMethod, dockResolution)

dockMethod is an unsigned int constant from the OEDockMethod namespace, that specifies the combination of scoring functions (or method) OEDock uses for the exhaustive search and optimization. The available scoring methods are:

dockResolution is an unsigned int constant from the OESearchResolution namespace, that specifies the docking resolution to use. The docking resolution is the rotational and translational stepsize used during the exhaustive search and optimization (the rotational stepsize is the furthest distance any heavy atom of the ligand will move in a single rotational step). The following resolutions are supported

Resolution Exhaustive Translational Exhaustive Rotational
OESearchResolution_High 1.0 1.0
OESearchResolution_Standard 1.0 1.5
OESearchResolution_Low 1.5 2.0
Resolution Optimization Translational Optimization Rotational
OESearchResolution_High 0.5 0.5
OESearchResolution_Standard 0.5 0.75
OESearchResolution_Low 0.75 1.0

All resolutions are in Angstroms.

Note

The OEDock constructor has default settings for both dockMethod and dockResolution. The default value are OEDockMethod_Chemgauss4 and OESearchResolution_Standard respectively.

See also

Section Docking Algorithm for more information docking algorithm.

Hybrid Method

The hybrid (OEDockMethod_Hybrid2) docking method is distinguished from other docking methods because it uses information present in the structure of a bound ligand to enhance docking performance.

The bound ligand information is used during the exhaustive search stage of the docking process (see Docking Algorithm section) by using the Chemical Gaussian Overlay scoring function, which scores poses based on how well a docked pose overlays the shape of the bound ligand and mimics the same hydrogen bonding and interactions the bound ligand makes. After the exhaustive search, optimization is performed with Chemgauss4 which is a standard structure based scoring function.

The final score a ligand receives using the hybrid docking method is based only on its interactions with the protein. Ligand information is used only to guide the selection of poses during the exhaustive search.

Note

In order to use the hybrid docking method the receptor object must have a bound ligand (see Bound Ligand section).

Initialization

An OEDock object must be initialized with a receptor object, prior to docking, scoring or annotating any molecules. This is done by passing a receptor to the OEDock.Initialize method, as shown in the following code snippet from Listing 2.

dock.Initialize(receptor)

Note

Unlike OEScore, OEDock cannot be initialized with a protein and a box, however a receptor can be constructed from a protein and box using the OEMakeReceptor function.

Docking Molecules

Once the OEDock object has been initialized molecules are docked using the OEDock.DockMultiConformerMolecule method, as shown in this code snippet from Listing 2.

dock.DockMultiConformerMolecule(dockedMol, mcmol)

mcmol is a multiconformer representation of the molecule being docked, and pose is an OEMolBase the resulting top scoring docked pose is returned in. The score of the docked molecule can be obtained by calling the OEMolBase.GetEnergy method of pose.

OEDock can also return alternate as well as top scoring poses of the docked molecule.

numPoses = 10
poses = OEMol()
dock.DockMultiConformerMolecule(poses, mcmol, numPoses)

In this example the 10 best scoring poses are returned as conformers of poses. The score of each pose can be obtained by calling the OEMolBase.GetEnergy method of each pose.

Scoring Molecules

The final score of a molecule (using the optimization scoring function) docked with the OEDock.DockMultiConformerMolecule method can be obtained by calling the OEMolBase.GetEnergy.

OEDock can also recalculate a score of a pose (using the optimization scoring function), and calculate the contribution for each individual component of the score as in the following example.

def PrintScore(dock, pose):
    print("Total pose score = %f" % dock.ScoreLigand(pose))
    print("Score components contributions to score:")
    for comp in dock.GetComponentNames():
        print("%12s: %6.2f" % (comp, dock.ScoreLigandComponent(pose, comp)))

Scores can also be calculated on a per-atom basis, and broken down into contributions from individual components of the scoring function.

def PrintAtomScore(dock, pose, atom):
    print("")
    print("  Atom: %d score: %f" % (atom.GetIdx(), dock.ScoreAtom(atom, pose)))
    print("Score components contributions to atoms score: ")
    for comp in dock.GetComponentNames():
        print("%12s: %.2f" % (comp, dock.ScoreAtomComponent(atom, pose, comp)))

Listing 2 uses the convenience function OESetSDScore to assign the scores to SD data on the molecules. This function simply assigns the result of ‘OEScore::ScoreLigand’ to the SD data with tag sdtag.

OESetSDScore(dockedMol, dock, sdtag)

Annotating

OEDock can add VIDA score annotations to docked poses, as shown in this code snippet from Listing 2.

dock.AnnotatePose(dockedMol)

These annotations break down the score of each pose to contributions from each component of the scoring function and each atom of the scoring function. When viewed in VIDA these values are displayed visually in the 3D window.

Docking Algorithm

OEDock docks multiconformer molecules using an exhaustive search that systematically searches rotations and translations of each conformer of the ligand within the active site. Following the exhaustive search the top scoring poses are optimized and assigned a final score. These two steps are described in more detail below

Exhaustive Search

  1. Enumerates, to given resolution, every possible rotation and translation of each conformer of the ligand being docked within a box enclosing the active site. The resolution of the exhaustive search is determined by the overall resolution setting of OEDock (see Scoring Functions and Search Resolution section).
  2. Discard out poses that either clash with the protein or extend to far from the binding site using the receptor’s negative image outer contour (see Negative Image section).
  3. If the negative image inner contour is enabled discard any poses that do not have at least one heavy atom that falls within the inner contour. (see Negative Image section).
  4. Discard any poses that do no match any user specified constraints. (see Constraints section).
  5. Score all remaining poses. The scoring function used here depends on what scoring method is being used (see Scoring Functions and Search Resolution section).
  6. Sort poses by score and pass the top scoring poses to optimization. The number of posses passed to optimization depends on the search resolution (see OESearchResolution constant namespace).

Optimization

  1. Each pose moved to 729 nearby positions, scored and the top scoring position become the new optimized pose. The positions are generated by having the initial pose take one positive and one negative step for each translational and rotational degree of freedom. The resolution of these steps is half that of the exhaustive search, and is determined by the overall resolution setting of OEDock (see Scoring Functions and Search Resolution section).
  2. The best scoring pose of the 729 tests poses is selected as the final docked structure (and score) for the ligand.