Docking

Docking is the job of placing a small molecule (the ligand) inside a protein binding site and working out how it sits there. The placed molecule is called a pose, which is one possible position and orientation of the ligand in the pocket. A docking run tries many poses and keeps the best ones.

This tool does non covalent docking, which means the ligand sits in the pocket held by ordinary attractions and does not form a chemical bond to the protein. It samples the ligand in many random orientations around a point you choose, then scores each pose with a classical physics model that adds up the usual short range attraction and repulsion between atoms (called Lennard Jones), the electrical attraction between charges (Coulomb), and hydrogen bonds.

Use it to get a quick read on whether a molecule fits a pocket and roughly how favourable the fit looks, before spending time on a slower and more accurate free energy calculation.

When to use it

Use it for a fast first pass when you want to know whether a ligand, fragment, or cofactor can sit in a known binding site, and to rank a set of candidate molecules by how well they fit. It is much cheaper and faster than a free energy simulation. When you need an accurate binding strength for the best hits, follow up with Absolute Binding Free Energy or Relative Binding Free Energy. If your molecule forms a real chemical bond to the protein, use Covalent Docking instead.

Inputs

Input	Required	What it is
`structure_file`	yes	Protein structure file in PDB or CIF format.
`drug_smiles`	yes	SMILES string of the ligand or cofactor to dock.
`chain_id`	yes	Which protein chain to dock into, for example `A`.
`binding_site_residues`	no	JSON list of `[resname, resid]` pairs that mark the centre of the pocket, for example `[["SER",64],["HIS",57]]`.
`binding_site_center`	no	JSON list `[x,y,z]` giving an explicit pocket centre, for example `[12.5, 8.3, -4.1]`. If set, this is used instead of `binding_site_residues`.
`placement_radius`	no, default `8.0`	Radius in Angstroms of the sphere around the pocket centre where the ligand is randomly placed. Allowed range `3.0` to `20.0`.
`n_conformers`	no, default `3`	Number of 3D shapes of the ligand to generate and try. Allowed range `1` to `20`.
`n_orientations`	no, default `8`	Number of random orientations to try per shape. Allowed range `1` to `50`.
`keep_cofactors`	no	JSON list of cofactor residue names or `[name, resid]` pairs to keep in the pocket, for example `["ZN", "HEM"]`.
`fmax`	no, default `0.5`	Force convergence threshold in eV per Angstrom for the energy minimiser. Smaller values minimise more tightly.
`max_steps`	no, default `700`	Largest number of minimisation steps per pose. Allowed range `100` to `2000`.
`use_electrostatics`	no, default `true`	Whether to include charge to charge (Coulomb) attractions in the score.
`protonate`	no, default `true`	Adds or removes hydrogens on the ligand to match the chosen pH. Turn off if your input is already prepared.
`ph`	no, default `7.4`	pH used to decide the ligand protonation state. Allowed range `0.0` to `14.0`.

More conformers and more orientations sample the pocket more thoroughly, which gives better poses but costs more runtime.

How to run it

Submit your own protein and ligand from Azulene Studio, the Python SDK, or the CLI. New here? The Get started page walks through installing, logging in, and running a ready made example first.

In Azulene Studio

Open Docking from the tools list, then on the Inputs and Parameters step upload your protein structure file, enter the ligand SMILES, set the chain ID, point to the pocket with binding_site_residues or binding_site_center, adjust the sampling settings if you want, then Review and Submit.

From the Python SDK

from opal import jobs

result = jobs.submit(
    job_type="docking",
    input_data={
        "structure_file": "/path/to/your/protein.pdb",
        "drug_smiles": "c1ccc(cc1)C(=N)N",
        "chain_id": "A",
        "binding_site_residues": "[[\"BEN\",1]]",
    },
)

From the CLI

Pass the inputs as a JSON string.

opal jobs submit --job-type docking \
  --input-data '{"structure_file": "/path/to/your/protein.pdb", "drug_smiles": "c1ccc(cc1)C(=N)N", "chain_id": "A", "binding_site_residues": "[[\"BEN\",1]]"}'

Reading the result

The headline number is the composite score in kcal/mol, the classical physics score of the best pose. A more negative composite score means a better fitting pose. In Azulene Studio you also see a ligand to site distance in Angstroms (final_distance), the distance from the ligand to its binding site target, which is a quick sanity check that the ligand landed where you aimed it.

Below the headline numbers is a ranked table of the top poses. Each row has a rank (numbered from 0), a pose label, and that pose’s composite score in kcal/mol (top_k_composite_kcal_mol). The poses are also drawn as a bar chart of composite score per pose. You can sort the table, colour it by score, and export it to CSV. The downloaded result contains the docked structures as pose_0.pdb, pose_1.pdb, and so on, matching the rank numbers in the table.

Notes

Point the search at the pocket. Use binding_site_center when you know the exact coordinates of the pocket centre, or binding_site_residues when you would rather name a few residues that line the pocket. Keep any structural cofactors, such as a zinc ion or a heme group, with keep_cofactors so the pocket keeps its real shape. Docking gives a fast relative ranking, not an accurate binding free energy. For accurate numbers on your best hits, run a free energy tool afterwards.