Relative Binding Free Energy

Relative Binding Free Energy (RBFE) calculates the difference in binding free energy between two ligands binding the same protein, reported as ΔΔG_bind.

The sign convention is ΔΔG_bind = ΔG_bind(ligand B) minus ΔG_bind(ligand A). A negative ΔΔG_bind means ligand B binds more tightly than ligand A. A positive value means ligand A binds more tightly.

RBFE is most accurate for two closely related ligands, a congeneric pair that share a common core. It works by gradually morphing ligand A into ligand B, once in plain water and once inside the protein pocket, and taking the difference between those two changes. Because the two ligands are so similar, much of the calculation cancels out, which makes the result both cheaper to compute and more precise.

If your two ligands are not closely related, or you need an absolute number for a single ligand on its own, use Absolute Binding Free Energy instead.

When to use it

Use it when you are optimizing within a congeneric series, ranking close analogs, or deciding which of two candidate modifications to a molecule binds better. RBFE is usually cheaper and more precise than Absolute Binding Free Energy for close pairs, because the shared core cancels out and only the small chemical difference between the two ligands has to be simulated.

Inputs

Input	Required	What it is
`pdb_file`	yes	PDB file of the protein. Upload one, or fetch from RCSB by ID. It may already contain a ligand.
`smiles_a`	yes	SMILES string of ligand A, the first ligand.
`smiles_b`	yes	SMILES string of ligand B, the second ligand.
`ligand_file_a`	no	A structure file for ligand A in SDF, PDB, or CIF format, if you have one.
`ligand_file_b`	no	A structure file for ligand B in SDF, PDB, or CIF format, if you have one.
`ligand_in_pdb_file_a`	no, default `false`	Set to `true` if ligand A is already inside the protein PDB.
`ligand_in_pdb_file_b`	no, default `false`	Set to `true` if ligand B is already inside the protein PDB.
`ligand_residue_name_a`	no, default `LIG`	Residue name of ligand A in the PDB.
`ligand_residue_name_b`	no, default `LIG`	Residue name of ligand B in the PDB.
`assign_protonation_states`	no, default `true`	Protonates both ligands automatically at the given pH. Turn off if your inputs are already protonated.
`ph`	no, default `7.0`	pH used to decide protonation.
`equil_length`	no, default `0.08` ns	Equilibration length per replica.
`prod_length`	no, default `0.4` ns	Production length per replica.
`protocol_repeats`	no, default `3`, minimum `1`	Number of independent repeats used for the uncertainty estimate. More repeats give a smaller uncertainty.
`platform`	no, default `CUDA`	Compute platform, one of `CUDA`, `OpenCL`, `CPU`, or `Reference`.
`keep_dirs`	no, default `true`	Preserves the full simulation outputs so you can download them.

Longer simulation lengths and more repeats give more reliable numbers, but cost more runtime and credits.

How to run it

Submit your own protein and two ligands 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 Relative Binding Free Energy from the tools list, then on the Inputs and Parameters step upload your protein PDB (or fetch it from RCSB by ID), provide ligand A and ligand B as SMILES (or upload ligand files), adjust the pH and simulation lengths if you want, then Review and Submit.

From the Python SDK

from opal import jobs

result = jobs.submit(
    job_type="relative_binding",
    input_data={
        "pdb_file": "/path/to/your/protein.pdb",
        "smiles_a": "<SMILES of ligand A>",
        "smiles_b": "<SMILES of ligand B>",
        "ph": 7.0,
    },
)

From the CLI

Pass the inputs as a JSON string.

opal jobs submit --job-type relative_binding \
  --input-data '{"pdb_file": "/path/to/your/protein.pdb", "smiles_a": "<SMILES of ligand A>", "smiles_b": "<SMILES of ligand B>", "ph": 7.0}'

Reading the result

The main output is ddg_binding, the relative binding free energy ΔΔG_bind, reported with an uncertainty and a ddg_binding_unit (kcal/mol or kJ/mol).

A more negative ddg_binding means ligand B is the stronger binder of the pair. A positive value means ligand A binds more tightly. More protocol_repeats lower the uncertainty. If keep_dirs is on, the full simulation outputs can be downloaded.

Notes

Keep the simulation lengths short for a quick first run. For reliable numbers, use a longer prod_length and at least 3 repeats. RBFE runs on a GPU, and runtime grows with the simulation lengths and the number of repeats. RBFE needs the two ligands to share a common scaffold so the morph from one to the other is well defined. If your two ligands are too dissimilar, use Absolute Binding Free Energy instead.