DSDPFlex is a GPU-accelerated flexible-receptor docking program derived from DSDP (Deep Site and Docking Pose). Similar to AutoDock Vina, it supports selective side-chain flexibility during docking. A flexible docking process can be done in ~1 s with DSDPFlex. Learn more in our preprint.

DSDPFlex runs on a Linux machine (tested on Ubuntu 22.04 and 20.04).

A GPU with CUDA is required. NVCC is required for compilation, please install Cuda Toolkit and make sure it is in the system path. (e.g. check using nvcc --version)

NOTE: Cuda version would need to be compatible with the GPU architecture and gcc/g++ version. An example version we used is cuda_11.6 with gcc_9.4.0. If an older GPU (former to the GTX/RTX Turing) was used on your computer, you might need to modify the -arch=sm_70 in Makefile to a compatible one.

Clone this repository.

git clone https://github.com/PKUGaoGroup/DSDPFlex.git
cd DSDPFlex

Install DSDPFlex. Suppose you are at the root of this repository.

cd DSDPFlex_v0.2
make clean && make
cp DSDPflex ../bin
cd ..

A binary named DSDPflex will be compiled. You may add it to the system path by adding this line to ~/.bashrc

export PATH=/path/to/DSDPFlex/bin:$PATH

so that DSDPFlex can be called directly from the command line.

(If the flexible receptor parts are not needed, DSDP would work better.) For a ligand-receptor pair, run:

./DSDPflex --ligand ligand.pdbqt \
--protein receptor_rigid.pdbqt \
--flex receptor_flex.pdbqt \
--box_min x y z \
--box_max x y z \
--exhaustiveness 384 --search_depth 40 --top_n 1 \
--out ligand_out.pdbqt \
--out_flex flex_out.pdbqt \
--log dsdp_out.log

Input: DSDPFlex supports .pdbqt formatted input files, which can be prepared with AutoDockTools.

• --ligand ligand file name (required)
• --protein protein rigid part (required)
• --flex protein flexible part file (required for flexible docking)

Output:

• --out the output file of ligand poses (default=DSDP_out.pdbqt)
• --out_flex the output file of flexible side chain poses (default=DSDP_out_flex.pdbqt)
• --log the log file name (default=DSDP_out.log)
• --top_n the top-N ranking results will be exported (defualt=10)

Search space: The search space information needs to be provided by the user. The search box specifies the (known) binding site. The ligand box is used for restricting ligand translation, which can be a smaller box.

• --box_min x y z minima of the search box
• --box_max x y z maxima of the search box
• --ligbox_min x y z minima of the ligand box
• --ligbox_max x y z maxima of the ligand box

Search settings: The user could manually adjust the following settings. The default settings would generally work well.

• --exhaustiveness the number of sampling threads, default=384
• --search_depth the number of sampling iterations of each thread, default=40

Use --help to see more details.

For docking multiple ligands to a single receptor (e.g. in a virtual screening scenario), you can use the batch mode.

./DSDPflex --ligand_batch batch_list ...

The batch_list should be a text file, like

ligand_0.pdbqt out_0.pdbqt out_flex_0.pdbqt
ligand_1.pdbqt out_1.pdbqt out_flex_1.pdbqt
...

It will replace the --ligand, --out, and --out_flex options. Each file name should be a valid file path. The protein files (--protein & --flex) still need to be specified.

We provide a Python interface for calling DSDPFlex and related tools. It is recommended to run rescoring with this DSDPFlex_pyTools. More functions can be implemented in the future.

We recommend setting up the Python environment with conda.

conda create -n DSDPFlex_py
conda activate DSDPFlex_py

Then you can install the DSDPFlex_pyTools package by the following command:

cd ./DSDPFlex_pyTools
python ./setup.py install

Then the command DSDPflex-py will be available in the current python environment.

Before using DSDPflex-py, make sure that DSDPflex is in your system path (see Installation). To use GNINA, please download GNINA and add it to the system path.

To use DSDPflex-py:

DSDPflex-py --ligand ... --protein ... --rescore gnina

(the other options are the same as DSDPflex.) DSDPflex-py will call gnina for rescoring after docking by DSDPflex. By default, top-20 poses are rescored, the output files will be named *_rescored.pdbqt

Other rescoring methods might be implemented in the future.

The 211 systems within APOBind dataset, which was used for evaluation in the paper, are provided in ./test/apobind_prepared. To run this test:

cd ./test
sh ./run_apobind.sh

DSDPFlex will perform docking on each system.

There are advanced options in DSDPflex that allow users to manually adjust or further develop the program.

• --no_norm let the program not normalize the intra-protein score (i.e. using the original Vina score, see more in the paper)
• --norm_param <float> modify the normalization parameter $p$ the weight of intra-protein score ($\gamma$) will be $$\gamma = p\times \min(f_\text{ligand} / f_\text{flex}, 1)$$ default $p = 1/2$
• --rand_init_flex randomly initialize flexible side chain conformations. By default, DSDPflex keeps the initial side chain conformations.
• --rank_ligand_only consider only ligand-related scores when ranking (&output) the poses.

TBD

Licensed under GNU AFFERO GENERAL PUBLIC LICENSE (Version 3), you may not use this file except in compliance with the License. Any commercial use is not permitted.