Getting Started

In this section, you have the documentation with installation and validation instructions for first-time users.
You can read the documentation in HTML format in this same page, or you can download it in pdf format following this link.


1 Overview

rDock is a fast and versatile Open Source docking program that can be used against proteins and nucleic acids. Itis designed for High Throughput Virtual Screening (HTVS) campaigns and Binding Mode prediction studies.

The rDock program was developed from 1998 to 2006 (formerly known as RiboDock[1]) by the software team at RiboTargets (subsequently Vernalis (R&D) Ltd). In 2006, the software was licensed to the University of York for maintenance and distribution. In 2012, Vernalis and the University of York agreed to release the program as Open Source software. This version is licensed under GNU-LGPL version 3.0 with support from the University of Barcelona –

The major components of the platform now include fast intermolecular scoring functions (van der Waals, polar, desolvation) validated against protein and RNA targets, a Genetic Algorithm-based stochastic search engine, a wide variety of external Structure-Based Drug Discovery (SBDD) derived restraint terms (tethered template, pharmacophore, noe distance restraints), and novel Genetic Programming-based post-docking filtering. A variety of scripts are provided to perform automated validation experiments and to launch virtual screening campaigns.

This introductory guide is aimed at new users of rDock. It describes the minimal set of steps required to build rDock from the source code distribution, and to run one of the automated validation experiments provided in the test suite distribution. The instructions assume that you are comfortable with simple Linux command line administration tasks, and with building Linux applications from make files. Once you are familiar with these steps you should proceed to the User and Reference Guide for more detailed documentation on the usage of rDock.

[1] Validation of an empirical RNA-ligand scoring function for fast flexible docking using RiboDock, SD Morley and M Afshar, J. Comput.-Aided Mol. Des., 18 (2004) 189-208.

2 Prerequisites

rDock is supplied as source code, which means that you will have to compile the binary files (run-time libraries and executable programs) before you can use them. rDock has been developed largely on the Linux operating system, most recently with the GNU g++ compiler (tested under openSuSE 11.3. The code will almost certainly compile and run under other Linux distributions with little or no modification. For the moment, it has been tested in latest Ubuntu and openSuSE releases for both 32 and 64 bits system architectures (by November 2013) and compilation was possible without any code modification. However, no other distributions or compilers have been tested extensively to date.

For full production use, you would typically compile rDock on a separate build machine and run the docking calculations on a cluster of compute machines. However, for the purposes of getting started, these instructions assume that you will be compiling rDock and running the initial validation experiments on the same machine.

Required packages
Make sure you have the following packages installed on your machine before you continue. The versions listed are appropriate for openSuSE 11.3; other versions may be required for your particular Linux distribution.

Table 2.1. Required packages for building and running rDock

Package Description Required at Version

gcc GNU C compiler Compile-time > 3.3.4
g++ GNU C++ compiler Compile-time > 3.3.4
popt C++ command-line argument processing Run-time > 1.7-190
popt-devel Development files for popt library Run-time > 1.7-190
cppunit C++ unit test framework Compile-time > 1.10.2
cppunit-devel Development files for cppunit Compile-time > 1.10.2

3 Unpacking the distribution files

The rDock source files and test suite files are provided as independent gzipped tar (.tar.gz) distributions.
Depending on your requirements, the two distributions can be unpacked to entirely separate locations, or can be unpacked under the same location.

Table 3.1. rDock distribution files

File Description

rDock_[CODELINE]_src.tar.gz rDock source distribution
 [TEST]_rDock_TestSet.tar.gz Test suite data files and scripts

where [CODELINE], and [TEST] will vary depending on the release and test set. [CODELINE] represents the major version string (for example, 2013.1) and [TEST] represents the given dataset (ASTEX, RNA or DUD).

Procedure 3.1. Example unpacking procedure

Create a new directory for building rDock.

$ mkdir ~/dev

The directory you created is referred to as [BUILDDIR] in the subsequents steps.

Copy or download the distribution files to [BUILDDIR].

$ cp ~/mydownloads/rDock_2013.1_src.tar.gz ~/dev/

Extract the distributions.

$ cd ~/dev/
$ tar -xvzf rdock_2013.1_src.tar.gz

The distributions contain files with relative path names, and you should find the following subdirectories created under rDock_[CODELINE]_src. Note that the ./rDock_2013.1_src subdirectory may have a different name depending on the major version string (see above).

$ find . -type d

Make a note of the following locations for later use.

The rDock root directory is [BUILDDIR]/rDock_[CODELINE]_src and will be referred to as [RBT_ROOT] in later instructions. In this example, [RBT_ROOT] is  /dev/rDock_2013.1_src/.

4 Building rDock

rDock is written in C++ (with a small amount of C code from Numerical Recipes) and makes heavy use of the C++ Standard Template Library (STL). The majority of the source code is compiled into a single shared library ( The executable programs themselves are relatively light-weight command-line applications linked with

The tmake build system (from Trolltech) is used to generate makefiles automatically for a particular build target (i.e. combination of operating system and compiler). The source distribution comes with tmake templates defining the compiler options and flags for three Linux build targets (linux-g++ and linux-g++-64). The build targets have been tested under openSuSE 11.3 ( kernel) with GNU g++ (versions 3.3.4, 4.5.0 and 4.7.2).

Table 4.1. Standard tmake build targets provided.

Target Name Architecture Compiler Compiler flags (release build)

linux-g++ 32-bit g++ -m32 -O3 -ffast-math
linux-g++-64 64-bit g++ -m64 -O3 -ffast-math

Customising the tmake template for a build target. If none of the tmake templates are suitable for your machine, or if you wish to customise the compiler options, you should first customise one of the existing templates. The tmake template files are stored under [RBT_ROOT]/build/tmakelib/. Locate and edit the tmake.conf file for the build target you wish to customise. For example, to customise the linux-g++ build target, edit [RBT_ROOT]/build/tmakelib/linux-g++/tmake.conf and localise the values to suit your compiler.

Procedure 4.1. rDock build procedure

To build rDock, first go to the [RBT_ROOT]/build/ directory.

$ cd [RBT_ROOT]/build

4.1.1. Compile

Make one of the build targets listed below.

$ make linux-g++
$ make linux-g++-64

4.1.2. Test

Run the rDock unit tests to check build integrity. If no failed tests are reported you should be all

$ make test

4.1.3. Cleanup (optional)

To remove all intermediate build files from [RBT_ROOT]/build/, leaving just the final executables (in [RBT_ROOT]/bin/) and shared libraries (in [RBT_ROOT]/lib/):

$ make clean

To remove the final executables and shared libraries as well, returning to a source-only distribution:

$ make distclean

To continue with a short validation experiment (also found in the Getting Started pdf file), please visit the following page: Validation Sets.