Drawing a Ligand-Protein Complex SurfaceΒΆ

The previous chapter demonstrates how to draw and customize 2D molecule surfaces. Grapheme TK also provides a method that depicts a ligand-protein complex in which the arcs of the 2D surface of the molecule are annotated based on the distance between the accessible surfaces of the ligand and the surrounding protein (OEMakeAccessibleSurface). Based on this calculation, the atoms of the ligand are divided into four categories which are then inherited by the corresponding arcs when the 2D molecule surface of the ligand is drawn. These four types are the following:

  1. Solvent (OEDefaultSolventArcFxn)

    A surface arc is depicted using the solvent style if the corresponding atom is accessible to a solvent. (See Figure: Example of the ‘solvent’ arc style)

    ../_images/OEDefaultSolventArcFxn.png

    Example of the ‘solvent’ arc style

  2. Cavity (OEDefaultCavityArcFxn)

    A surface arc is depicted using the cavity style if in the region of the corresponding atom, a cavity is detected between the ligand and the receptor molecule surfaces. The cavity is large enough to allow expanding the ligand in this region without bumping into the receptor. (See Figure: Example of the cavity arc style)

    ../_images/OEDefaultCavityArcFxn.png

    Example of the ‘cavity’ arc style

  3. Void (OEDefaultVoidArcFxn)

    A surface arc is depicted using the void style, if in the region of the corresponding atom a small interstice is detected between the ligand and the receptor molecule surfaces. (See Figure: OEDefaultBuriedArcFxn)

    ../_images/OEDefaultVoidArcFxn.png

    Example of the ‘void’ arc style

  4. Buried (OEDefaultBuriedArcFxn)

    A surface arc is depicted using the buried style, if in the region of the corresponding atom the ligand is tightly fit to the receptor. (See Figure: Example of the buried arc style)

    ../_images/OEDefaultBuriedArcFxn.png

    Example of the ‘buried’ arc style

Note

Even though, Spicoli TK is used to generate the accessible surfaces of the ligand and the receptor, no Spicoli TK license is required to call the OEAddComplexSurfaceArcs function.

The following Listing 1 example show how to display the surface of the ligand-protein complex. After importing the ligand and the receptor structures, the OEAddComplexSurfaceArcs function is called to generate the accessible molecule surfaces (using Spicoli TK) and assign the surface drawing styles (solvent, buried, void, or cavity) for the atoms of the ligand. These styles are the used to draw the arcs of the molecule surface when the OEDraw2DSurface function is invoked. The OEGetMoleculeSurfaceScale function is used to reduce the scaling of the molecule in order to be able to fit both the molecule diagram and the molecule surface into the image.

Listing 1: Example of complex surface drawing

#!/usr/bin/env python
import sys
from openeye.oechem import *
from openeye.oedepict import *
from openeye.oegrapheme import *


def ImportMolecule(filename):

    ifs = oemolistream()
    if not ifs.open(filename):
        OEThrow.Fatal("Unable to open %s for reading" % filename)

    mol = OEGraphMol()
    if not OEReadMolecule(ifs, mol):
        OEThrow.Fatal("Unable to read molecule in %s" % filename)

    OEAssignBondiVdWRadii(mol)
    OESuppressHydrogens(mol)

    return mol

if len(sys.argv) != 3:
    OEThrow.Usage("%s <receptor> <ligand>" % sys.argv[0])

receptor = ImportMolecule(sys.argv[1])
ligand = ImportMolecule(sys.argv[2])

OEAddComplexSurfaceArcs(ligand, receptor)

OEPrepareDepictionFrom3D(ligand)

width, height = 450, 350
opts = OE2DMolDisplayOptions(width, height, OEScale_AutoScale)
opts.SetScale(OEGetMoleculeSurfaceScale(ligand, opts))

disp = OE2DMolDisplay(ligand, opts)
OEDraw2DSurface(disp)

OERenderMolecule("DrawComplexSurface.png", disp)
OERenderMolecule("DrawComplexSurface.pdf", disp)

The following snapshot (Figure: Dihydrofolate reductase) displays the ligand of the 2w3a PDB complex in VIDA with the accessible surface of the protein. The image shown in the Figure: The Grapheme representation of the 2w3a complex is created by Listing 1 code for the same ligand-protein complex.

../_images/DrawComplexSurface-VIDA.png

Dihydrofolate reductase complexed with trimethoprim in VIDA (PDB 2w3a)

../_images/DrawComplexSurface.png

The Grapheme representation of the 2w3a complex

User-defined solvent and buried surface drawing styles can be implemented by deriving from the OESurfaceArcFxnBase base class. Similarly, user-defined cavity and void surface drawing styles can be implemented by deriving from the OEComplexSurfaceArcFxnBase base class. This later abstract class also stores the relative distance calculated between the ligand and the receptor. The following code snippet shows how to use this depth to emphasize the volume of the cavity by adjusting the size of the spikes when drawing the surface arcs using the OEDrawSunSurfaceArc function.

def DrawSurfaceArc(image, depth, arc, pen):
        edgeAngle = 5.0
        patternAngle = 5.0
        minPatternWidthRatio = 0.05
        maxPatternWidthRatio = 0.10 * depth
        patternDirection = OEPatternDirection_Outside
        OEDrawSunSurfaceArc(image, arc.GetCenter(), arc.GetBgnAngle(), arc.GetEndAngle(),
                            arc.GetRadius(), pen, edgeAngle,
                            patternDirection, patternAngle,
                            minPatternWidthRatio, maxPatternWidthRatio)


class SolventArcFxn(OESurfaceArcFxnBase):
    def __call__(self, image, arc):
        pen = OEPen(OELightGrey, OELightGrey)
        pen.SetLineWidth(0.5)
        OEDrawDefaultSurfaceArc(image, arc.GetCenter(), arc.GetBgnAngle(),
                                arc.GetEndAngle(), arc.GetRadius(), pen)
        return True


class BuriedArcFxn(OESurfaceArcFxnBase):
    def __call__(self, image, arc):
        pen = OEPen(OEGrey, OEGrey)
        pen.SetLineWidth(2.0)
        OEDrawDefaultSurfaceArc(image, arc.GetCenter(), arc.GetBgnAngle(),
                                arc.GetEndAngle(), arc.GetRadius(), pen)
        return True


class CavityArcFxn(OEComplexSurfaceArcFxnBase):
    def __call__(self, image, arc):
        pen = OEPen(OEBlack, OEBlack)
        pen.SetLineWidth(2.0)
        DrawSurfaceArc(image, self.GetDepth(), arc, pen)
        return True


class VoidArcFxn(OEComplexSurfaceArcFxnBase):
    def __call__(self, image, arc):
        pen = OEPen(OEDarkGrey, OEDarkGrey)
        pen.SetLineWidth(2.0)
        DrawSurfaceArc(image, self.GetDepth(), arc, pen)
        return True

These arc drawing predicates then can be used to draw the surface of the ligand-protein complex when calling the OEAddComplexSurfaceArcs function. The image created is shown in Figure: Example of user-defined surface drawing.

sfxn = SolventArcFxn()
bfxn = BuriedArcFxn()
cfxn = CavityArcFxn()
vfxn = VoidArcFxn()
OEAddComplexSurfaceArcs(ligand, receptor, sfxn, bfxn, cfxn, vfxn)
../_images/DrawComplexSurfaceUserDefined.png

Example of user-defined surface drawing

See also