诚求iphone4 dock激活码 ！！！！！！！！！！！！ID是：00FCBFAA5C。 在线等，谢谢哪位大侠了。万分感谢_百度知道
诚求iphone4 dock激活码 ！！！！！！！！！！！！ID是：00FCBFAA5C。 在线等，谢谢哪位大侠了。万分感谢
另外问一下，是dock好还是scrollingboard好？
我有更好的答案
飞行模式下激活,关闭wifi
太谢谢了，大侠，刚刚才看到，可是你们两个都帮我回答了，我把分给谁呢？
采纳率：80%
来自团队：
注册码：1、飞行模式下输入注册码。2、关闭wifi。3、如果激活后重启进入还提示注册，那么在关机前先开飞行模式。这样开机的时候就无法进行验证，同样可以继续使用。
也很感谢你啊，可是你们两个人都回答了，我把分给谁？
自己选择，给谁都一样！
那我就给先说的吧。实在不好意思啊大侠，抱歉的很。不过真的很感谢，因为我确实不太懂弄手机的这些东东。谢谢了哈
为您推荐：
其他类似问题
iphone4的相关知识
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。求 iPhone DOCK激活码 id是D34A2BBA2D 我的激活码 谢还有就是飞行模式下激活后联网再次提示激活怎么办_百度知道
求 iPhone DOCK激活码 id是D34A2BBA2D 我的激活码 谢还有就是飞行模式下激活后联网再次提示激活怎么办
我有更好的答案
。这个是你的激活码 谁都用不了
为您推荐：
其他类似问题
飞行模式的相关知识
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。DOCK 6.8 User Manual
DOCK 6.8 Users Manual
Principal contributors to the current code:
William Joseph Allen (TACC)
Trent Balius (UCSF)
Scott Brozell (Rutgers University)
Lingling Jiang (Columbia University)
P. Therese Lang (UCB)
T. Dwight McGee Jr. (SUNY-Stony Brook)
Demetri Moustakas (Harvard)
Sudipto Mukherjee (Temple)
Yuchen Zhou (SUNY-Stony Brook)
Robert Rizzo (SUNY-Stony Brook)
David Case (Rutgers University)
Brian Shoichet (UCSF)
Irwin Kuntz (UCSF)
For more information about previous contributors, please see
Copyright &
Regents of the University of California
All Rights Reserved
Last updated April 26, 2017
Table of Contents
Introduction
1.1. General
DOCK addresses the
problem of
"docking" molecules to each other. In general, "docking" is the
identification of the low-energy binding modes of a small molecule, or
ligand, within the active site of a macromolecule, or receptor, whose
structure is known. A compound that interacts strongly with, or binds,
a receptor associated with a disease may inhibit its function and thus
act as a drug. Solving the docking problem computationally requires an
accurate representation of the molecular energetics as well as an
efficient algorithm to search the potential binding modes.
Historically, the
DOCK algorithm
addressed rigid body docking using a geometric matching algorithm to
superimpose the ligand onto a negative image of the binding pocket.
Important features that improved the algorithm's ability to find the
lowest-energy binding mode, including force-field based scoring,
on-the-fly optimization, an improved matching algorithm for rigid body
docking and an algorithm for flexible ligand docking, have been added
over the years. For more information on past versions of DOCK, click .
With the release
of DOCK 6, we continue to improve the algorithm's ability to predict
binding poses by adding new features like
force-field scoring enhanced by solvation and receptor flexibility. For more
information about the current release of DOCK, click .
What Can DOCK Do for You
We and others have used DOCK for the
following applications:
predict binding modes of small
molecule-protein complexes
search databases of ligands for
compounds that inhibit enzyme activity
search databases of ligands for
compounds that bind a particular protein
search databases of ligands for
compounds that bind nucleic acid targets
examine possible binding
orientations of protein-protein and protein-DNA complexes
help guide synthetic efforts by
examining small molecules that are computationally derivatized
many more...
1.3. Installation
based scientific software and
follows a common installation recipe:
download, unpack, configure, build, and test.
The simple configuration scheme of DOCK is based on plain text files.
Building and testing employ the
DOCK installation is so simple and transparent that users
have a reasonable chance of correcting problems themselves.
Start with a plain serial installation.
Follow the detailed steps (1. through 5.) enumerated below.
The appropriate configuration
see step 3.
Subsequently, additional executables can be installed
for parallel, pbsa, see step 6.
(Here is a quick start for an example gnu serial and parallel installation:
setenv MPICH_HOME /).
If problems occur then read the diagnostics carefully and apply the
To observe what's under the hood, view the configuration
file (install/config.h) that is created by configure,
and execute make -n for a dry run.
Consult the .
Search the
mailing list archive.
NOTE FOR WINDOWS
USERS: DOCK and its accessories must be run using a Unix-like
environment such as Cygwin
We recommend a full Unix installation.
In particular, when you install your emulator,
make sure to also install compilers, Unix shells, and perl ( Devel for Cygwin ).
All steps below should be performed
using Cygwin or another Unix emulator for Windows.
See also the .
(1) Unpack the distribution
using the following command:
[user@dock ~]
tar -zxvf dock.6.8.tar.gz
(2) Enter the installation directory:
[user@dock ~] cd dock6/install
(3) Configure the Makefile for the
appropriate operating system:
[user@dock ~] ./configure
[configuration file]
AUTHOR: Scott Brozell
USAGE: configure [-help]
[configuration file]
for a complete list see the configure -help output.
-help #emit the usage statement
configuration file #input file
containing operating system appropriate variables
Configuration Files
GNU compilers
recent GNU compilers and
gnu.parallel
GNU compilers with parallel processing capability
GNU compilers with PB/SA (ZAP library) capability
gnu.parallel.pbsa
GNU compilers with parallel processing and PB/SA (ZAP library) capabilities
IBM AIX and native compilers
Intel compilers
Intel compilers and
intel.parallel
Intel compilers with parallel processing capability
intel.intelmpi.parallel
Intel compilers with parallel processing capability (specific to Intel MPI)
PGI compilers
SGI native compilers
DESCRIPTION:
Create the DOCK configuration file, config.h, by copying an existing
configuration file that is selected using the arguments. When invoked
without arguments, print this usage statement and if the configuration
file exists then print its creation stamp. Some configuration files
require that environment
these requirements are
listed in the files and emitted by configure.
Note that as of version 6.6 gfortran is the default Fortran compiler in
the gnu config files (replacing g77).
But other Fortran c simply hand edit install/config.h
to use alternatives.
(4) Build the desired DOCK executable(s) via
one of the following commands:
[user@dock ~] make all # builds all
the DOCK programs
[user@dock ~] make dock # builds only the dock program
[user@dock ~] make utils # builds only the accessory programs
Test the built executable(s) via these commands:
[user@dock ~] make check
The test directory contains the DOCK quality control
(QC) suite. It produces pass/fail results via fast regression tests.
The suite should complete in l five minutes is typical.
Un-passed tests should be examined to determine their significance.
The make check command executed from the test directory emits all
the differences uncovered during testing.
The make clean command executed from the test directory removes all files
pro this command is automatically
executed by the main mak however, to run tests from
a subdirectory of the test directory, one should explicitly execute make clean.
NOTE: Some failures are not significant.
For example, differences in the tails of floating point numbers may not
be significant.
The sources of such differences are frequently
platform dependencies from computer hardware, operating systems,
and compilers that impact arithmetic precision and
random number generators.
In addition, the reference outputs as of version 6.4 are from a 64 bit
platform and as of version 6.6 use gfortran gcc version 4.4.5,
and this can cause false positives on 32 bit platforms or
in particular, differing numbers of Orientations or
Conformations and different Contact or Grid scores.
We are working on increasing the QC suite's resilience to these issues.
For now, apply common sense and good judgment to determine
the significance of a possible failure.
Note that some number of failures is
rarely an indication of real problems, but if almost
every test fails then something is amiss.
Some features of DOCK
( aka ChemGrid Score)
require an electrostatic potential map which is usually generated by DelPhi.
Testing of these features requires that the environment variable
DELPHI_PATH be defined to the full path of the DelPhi executable.
is not distributed with DOCK; see also
(6) OPTIONAL: Alternate executables.
(i) DOCK with parallel processing functionality
requires a Message Passing Interface (MPI) library.
Because of the vagaries of MPI libraries, building parallel DOCK
has more pitfalls than installing the serial version.
The MPI library must be installed and running on the system if the
parallel features of DOCK are to be used.
Currently, the DOCK installation mechanism only directly supports
the MPICH2 and MPICH implementations.
(But other MPI implementations can be accommodated probably
with the only extra effort of editing the config.h file.)
The MPICH2 library is freely available from Argonne National Labs
Once MPI is installed, define the environment variable MPICH_HOME
to the top level MPICH2 directory.
MPICH_HOME will be referenced by all stages of the build procedure -
from configuration through testing.
for execution information.
WARNING: The parallel configuration files have been
tailored to a typical MPICH2 build.
Linking problems, such as undefined references and cannot find libbla_bla,
can occur due to idiosyncrasies in the MPI installation.
One corrective approach is t
add to the LIBS definition in
config.h the link flags (-L and -l) from the command:
$MPICH_HOME/mpicc -
in general, the LIBS should contain those link flags in the same order.
(ii) DOCK with PB/SA scoring requires OpenEye Toolkits.
In particular, DOCK uses the APIs as in OEChem TK 1.7.0 and Zap TK 2.1.1.
These can be obtained from OpenEye
Once they are installed, define the environment variable ZAP_HOME to the
directory that contains the ZAP library.
ZAP_HOME is used during
installation and testing.
For execution the environment variable
OE_LICENSE must also be defined to the full path of the license file.
(Here is a quick start for an example gnu pbsa installation after
already building and testing a serial gnu installation:
./configure gnu.
setenv ZAP_HOME /openeye/toolkits/1.7.0-3/redhat-RHEL5-g++4.1-x64/;
setenv OE_LICENSE /openeye/oe_license.
1.4. What's New in DOCK 6
Version 6.0
The new features of DOCK 6 include: additional
scoring options DOCK 3.5 scoring-including Delphi
electrostatics, ligand conformational entropy corrections, ligand
desolvation,
Hawkins-Cramer-Truhlar GB/SA
solvation scoring with opt PB/SA solvation
AMBER scoring-including
the full AMBER
molecular mechanics scoring function w conjugate
gradient minimization and molecular dynamics simulation capabilities.
Version 6.1
The newly added features for this incremental release of DOCK 6 include
a new pruning algorithm during the anchor-and-grow algorithm,
a distance-based movable region and
a mildly performance optimized nothing movable region for AMBER score,
cleaner output and more complete output files for AMBER score,
the ability to perform ranking and/or clustering on ligands
between primary and secondary scoring,
and more dynamic output when secondary scoring is employed.
Version 6.2
The newly added features for this incremental release of DOCK 6 include
greater control over the output of conformations,
improved memory efficiency for grid reading,
a distance dependent dielectric control for continuous score,
and for AMBER score
better error reporting and robustness of the preparation scripts,
a metal ions library, a cofactor library, a hook for a user library,
support for RNA receptors,
a minimization convergence criterion control,
and the ability to skip inadequately prepped ligands.
Version 6.3
The newly added features for this incremental release of DOCK 6 include
more robust input file processing,
support for OpenEye Toolkits version 1.7.0 for PB/SA score,
and for AMBER score
improved support for RNA receptors,
the option to use the existing ligand charges during preparation,
better error reporting and robustness of the preparation scripts.
In particular, for AMBER scoring of RNA receptors,
the distance movable region can be applied with explicit waters
and the preparation can neutralize to a total charge of zero
and can solvate with water. See
Version 6.4
The newly added features for this incremental release of DOCK 6 include:
resolving ligand internal clashes of flexible ligands (more than seven
rotatable bonds) by inclusion of an internal energy function at
an ability to output growth trees as multi mol2 printing of growth statistics in
restrained minimization with an RMSD tether, a torsion pre-minimizer.
Version 6.5
The newly added features for this incremental release of DOCK 6 include:
Now an anchor can be chosen by specifying an atom in that fragment. In addition, the number of anchors used can be limited during multi-anchor docking.
The new scoring function called footprint score(the old descriptor score) has been introduced, which includes a
hydrogen bond term and footprint similarity scoring. See
PB/SA score has undergone some generalizations and efficiency improvements that
make docking, as opposed to rescoring, more tractable for nontrivial systems.
For AMBER score the cofactors library, leaprc.dock.cofactors,
and the ions library, leaprc.dock.ions, have grown substantially.
Version 6.6
The newly added features for this incremental release of DOCK 6 include:
A new grid-based footprint scoring function, a SASA-based scoring function,
calculation of RMSD using the Hungarian Algorithm, and inclusion of orienting statistics.
Version 6.7
This incremental release of DOCK 6 includes updates to the default values for
several input parameters based mainly on a performance assessment by
using large data sets and employing multiple metrics.
Version 6.8
The newly added features for this incremental release of DOCK 6 include:
A new pharmacophore-based similarity scoring function by ,
a Tanimoto scoring function, a Hungarian Matching Similarity scoring function, a volume-based similarity scoring function,
and a hybrid "descriptor" score to combine component scoring functions in DOCK.
Overview of the DOCK Suite of Programs
1.5.1. Programs
The relationship between the main
programs in the dock suite is depicted in Figure 1. These routines will
be described below.
programs in DOCK suite
The program
identifies the active site, and other sites of interest, and generates
the sphere centers that fill the site. It has been described in the
original paper (). The program
generates the scoring grids
). Within the DOCK suite of
programs, the program DOCK matches spheres
(generated by ) with ligand atoms and uses
scoring grids (from
evaluate ligand orientations ( and
). Program DOCK also minimizes
energy based scores ().
1.5.2. General Concepts
The DOCK suite of programs is designed to find
favorable orientations of a ligand in a “receptor.”
It can be subdivided into
(i) those programs related directly
to docking of ligands and
(ii) accessory programs.
We limit the discussion in this
section to only
those programs and methods related to docking a ligand in a receptor. A
typical receptor might be an enzyme with a well-defined active site,
though any macromolecule may be used (e.g. a structural protein, a
nucleic acid strand, a “true” receptor).
We’ll use an
enzyme as an example in the rest of this discussion.
The starting point of all docking
calculations is
generally the crystal or NMR structure of an enzyme from an
enzyme-ligand complex. The ligand structure may be taken from the
crystal structure of the enzyme-ligand complex or from a database of
compounds, such as the ZINC database ().
The primary consideration in the design of our docking programs has
been to develop methods which are both rapid and reasonably accurate.
These programs can be separated functionally into roughly two parts,
each somewhat independent of the other:
(i) Routines which determine the
orientation of a ligand relative to the receptor and
(ii) Routines which evaluate (score) a ligand orientation.
There is a lot of flexibility. You can generate
orientations outside of DOCK and score them with the DOCK evaluation
functions. Alternatively, you can develop your own scoring routines to
replace the functions supplied with DOCK.
The ligand orientation in a receptor site is broken
down into a series of steps, in different programs. First, a potential
site of interest on the receptor is identified. (Often, the active site
is the site of interest and is known a priori.) Within this site,
points are identified where ligand atoms may be located. A routine from
the DOCK suite of programs identifies these points, called sphere
centers, by generating a set of overlapping spheres which fill the
site. Rather than using DOCK to generate these sphere centers,
important positions within the active site may be identified by some
other mechanism and used by DOCK as sphere centers. For example, the
positions of atoms from the bound ligand may be used as these sphere
centers. Or, a grid may be generated within the site and each grid
point may be considered as a sphere center. Our sphere centers,
however, attempt to capture shape characteristics of the active site
(or site of interest) with a minimum number of points and without the
bias of previously known ligand binding modes.
To orient a ligand within the active
site, some of
the sphere centers are “matched” with ligand atoms.
is, a sphere center is “paired” with an ligand
atom. Many
sets of these atom-sphere pairs are generated, each set containing only
a small number of sphere-atom pairs. In order to limit the number of
possible sets of atom-sphere pairs, a longest distance heuristic is
(long) inter-sphere distances are roughly equal to the
corresponding (long) inter-atomic ligand distances. A set of
atom-sphere pairs is used to calculate an orientation of the ligand
within the site of interest. The set of sphere-atom pairs which are
used to generate an orientation is often referred to as a match. The
translation vector and rotation matrix which minimizes the rmsd of
(transformed) ligand atoms and matching sphere centers of the
sphere-atom set are calculated and used to orient the entire ligand
within the active site.
The orientation of the ligand is
evaluated with a
shape scoring function and/or a function approximating the
ligand-enzyme binding energy. Most evaluations are done on (scoring)
grids in order to minimize the overall computational time. At each grid
point, the enzyme contributions to the score are stored. That is,
receptor contributions to the score, potentially repetitive and time
consuming, are
the appropriate terms are then
simply fetched from memory.
The ligand-enzyme binding energy is
taken to be
approximately the sum of the van der Waal attractive, van der Waal
dispersive, and Coulombic electrostatic energies. Approximations are
made to the usual molecular mechanics attractive and dispersive terms
for use on a grid. To generate the energy score, the ligand atom terms
are combined with the receptor terms from the nearest grid point, or
combined with receptor terms from a “virtual” grid
with interpolated receptor values. The score is the sum of over all
ligand atoms for these combined terms. In this case, the energy score
is determined by both ligand atom types and ligand atom positions on
the energy grids.
As a final step, in the energy
scoring scheme, the
orientation of the ligand may be varied slightly to minimize the energy
score. That is, after the initial orientation and evaluation (scoring)
of the ligand, a simplex minimization is used to locate the nearest
local energy minimum. The sphere centers themselves are simply
approximations to pos the orientations generated
by the sphere-atom pairing, although reasonable, may not be minimal in
1.5.3. Specific Concepts
(A) Sphere Centers
Spheres are generated to fill the target site.
The sphere centers are putative ligand atom positions. Their use is an
attempt to limit the enormous number of possible orientations within
the active site. Like ligand atoms, these spheres touch the surface of
the molecule and do not intersect the molecule. The spheres are allowed
to int i.e., they have volumes which overlap. Each
sphere is represented by the coordinates of its center and its radius.
Only the coordinates of the sphere centers are used to orient ligands
within the active site (see above). Sphere radii are used in
clustering.
The number of orientations of the ligand in free
space is vast. The number of orientations possible from all sets of
sphere-atom pairings is smaller but still large and cannot be generated
and evaluated (scored) in a reasonable length of time. Consequently,
various filters are used to eliminate from consideration, before
evaluation, sets of sphere-atoms pairs, which will generate poorly
scoring orientations. That is, only a small subset of the number of
possible ligand orientations are actually generated and scored. The
distance tolerance is one filter. Sphere “coloring”
identification of “critical” spheres are other
Sphere-sphere distances are compared
to atom-atom
distances. Sets of sphere-atom pairs are generated in the following
manner: sphere i is
paired with atom I
if and only if for every sphere j in
the set and for every atom J
in the set,
is the distance between sphere i and sphere
j, dIJ is the
distance between atom I and atom J,
and epsilon is a somewhat small user-defined
(B) Chemical Matching
DOCK spheres are generated without
regard to the
chemical properties of the nearby receptor atoms. Sphere
“chemical matching” or
“coloring” associates a
chemical property to spheres and a sphere of one
“color”
can only be matched with a ligand atom of complementary color. These
chemical properties may be things such as “hydrogen-bond
donor,” “hydrogen-bond acceptor,”
“hydrophobe,”
“electro-positive,”
“electro-negative,” “neutral,”
etc. Neither the
colors themselves, nor the complementarity of the colors, are
determined by the DOCK DOCK simply uses these
labels. With the inclusion of coloring, only ligand atoms with the
appropriate chemical properties are matched to the complementary
colored spheres. It is probably more likely, then, that the orientation
generated will produce a favorable score. Conversely, by excluding
colored spheres from pairing with certain ligand atoms, the number of
(probably) unfavorable orientations which are generated and evaluated
can be reduced. Note that requiring complementarity in matching does
not mean that all ligand atoms will lie in chemically complementary
regions of the enzyme. Rather, only those ligand atoms, when paired
with a colored sphere which is part of the sphere-atom match, will be
guaranteed to be in the chemically complementary region of the enzyme
(provided chirality of the spheres is the same as that of the matching
ligand atoms).
(C) Critical Points
The "critical point" filter requires
that certain spheres be part of the set of sphere-atom pairs used to
orient the ligand ().
Designating spheres as critical points forces the ligand to have at
least one atom in that area of the enzyme, where that sphere is
located. This filter may be useful, for example, when it is known that
a ligand must occupy a particular area of an active site. This filter
removes from consideration any orientation that does not guarantee at
least one ligand atom in critical areas of the enzyme (provided
chirality of the spheres is the same as that of the matching ligand
(D) Bump Filter
After a ligand is oriented within
the active
site, the orientation is evaluated. In an attempt to reduce the total
computational time, after the ligand is oriented in the site, it is
possible to first check whether or not ligand atoms occupy space
already occupied by the receptor. If too many of such
“bumps” are found, then the ligand is likely to
the receptor eve consequently, the ligand
orientation is discarded before evaluation.
1.5.4. Units
The units of the DOCK suite of programs
are lengths in angstroms, masses in atomic mass units,
charges in electron charges units, and energies in kcal/mol.
For Amber score internally and on input of charges from a prmtop file
the charges are scaled by
2.1. Overview
This section is intended as a
reference manual for
the features of the DOCK Suite of Programs. It is intended to give an
overview of the ideas which form the basis of the DOCK suite of
programs and to detail the available user parameters. It is not
intended to be a substitute for all the papers written on DOCK.
In general, this document is geared
towards the
experienced user and introduces new features and concepts in version
6. If you are new to DOCK, we strongly recommend you look at the
tutorials on the DOCK web site at ,
which go into much greater practical detail.
2.2. History
Version 1.0/1.1
Authors: Robert Sheridan, Renee
DesJarlais, Irwin Kuntz
The program DOCK is an automatic procedure for
docking a molecule into a receptor site. The receptor site is
characterized by centers, which may come from sphgen or any other
source. The molecule being docked is characterized by ligand centers,
which may be its non-hydrogen atoms or volume-filling spheres
calculated in sphgen. The ligand centers and receptor centers are
matched based on comparison of ligand-center/ligand-center and
receptor-center/receptor-center distances. Sets of ligand centers match
sets of receptor centers if all the internal distances match, within a
value of distance_tolerance. Ligand-receptor pairs are added to the set
until at least nodes_minimum pairs have been found. At least three
pairs must be found to uniquely determine a rotation/translation matrix
that will orient the ligand in the receptor site. A least-squares
fitting procedure is used ().
Once an orientation has been found, it is evaluated by any of several
scoring functions. DOCK may be used to explore the binding modes of an
individual molecule, or be used to screen a database of molecules to
identify potential ligands.
Version 2.0
Authors: Brian Shoichet, Dale Bodian, Irwin Kuntz
DOCK version 2.0 was written to give the user
greater control over the thoroughness of the matching procedure, and
thus over the number of orientations found and the CPU time required
In addition, certain algorithmic shortcomings of earlier versions were
overcome. Versions 2.0 and higher are particularly useful for
macromolecular docking ()
and applications which demand detailed exploration of ligand binding
modes. In these cases, users are encouraged to run CLUSTER in
conjunction with sphgen and DOCK.
To allow for greater control over
searches of
orientation space, the ligand and receptor centers are pre-organized
according to their internal distances. Starting with any given center,
all the other centers are presorted into “bins”
their distance to the first center. All centers are tried in turn as
“first” positions, and all the points in a bin
been chosen for matching are tried sequentially. Ligand and receptor
bins are chosen for matching when they have the same distance limits
from their respective “first” points. The number of
in each bin determines how many sets of points in the receptor and the
ligand will ultimately be compared. In general, the wider the bins, the
greater the number of orientations generated. Thus, the thoroughness of
the search is under user control.
Version 3.0
Authors: Elaine Meng, Brian Shoichet,
Irwin Kuntz
Version 3.0 retained the matching
features of version 2.0, and introduced options for scoring
Besides the simple contact scores mentioned above, one can also obtain
molecular mechanics interaction energies using grid files calculated by
CHEMGRID (which is now superseded by GRID in version 4.0). More
information about the ligand and receptor molecules is required to
perform these higher-level kinds of scoring. Point charges on the
receptor and ligand atoms are needed for electrostatic scoring, and
atom-type information is needed for the van der Waals portion of the
force field score. Input formats (some of them new in version 3.5) are
discussed in various parts
one example of a
“complete format” (including point charges and atom
information) is SYBYL MOL2 format. Parameterization of the receptor is
discussed in the documentation for CHEMGRID. In DOCK, ligand parameters
are read in along
input formats are described
below. Currently, the options are: contact scoring only, contact
scoring plus Delphi electrostatic scoring, and contact scoring plus
force field scoring. Atom-type information and point charges are not
required for contact scoring only.
Version 3.5
Authors: Mike Connolly, Daniel
Gschwend, Andy Good, Connie Oshiro, Irwin Kuntz
Version 3.5 added several features:
score optimization, degeneracy checking, chemical matching and critical
clustering.
Version 4.0
Authors: Todd Ewing, Irwin Kuntz
Version 4.0 was a major rewrite and update of DOCK
A new matching engine was developed which is more robust, efficient,
and easier to use ().
Orientational sampling can now be controlled directly by specifying the
number of desired orientations. Additional features include chemical
scoring, chemical screening, and ligand flexibility.
Version 5.0-5.4
Authors: Demetri Moustakas, P. Therese
Lang, Scott Pegg, Scott Brozell, Irwin Kuntz
Version 5 was rewritten in C++ in a modular format,
which allows for easy implementation of new scoring functions, sampling
methods and analysis tools ().
Additional new features include MPI parallelization, exhaustive
orientation searching, improved conformation searching, GB/SA solvation
scoring, and post-screening pose clustering.
Version 6.0-6.7
Authors: P. Therese Lang, Demetri Moustakas, Scott Brozell,
Noel Carrascal, Sudipto Mukherjee, Trent Balius, William Joseph Allen, Patrick Holden,
Scott Pegg, Kaushik Raha, Devleena Shivakumar,
Robert Rizzo, David Case, Brian Shoichet, Irwin Kuntz
DOCK 6 is an extension of the DOCK 5 code base. It
includes the implementation of Hawkins-Cramer-Truhlar GB/SA solvation
scoring with salt screening and PB/SA solvation scoring through
OpenEye's Zap Library. Additional flexibility has been added to scoring
options during minimization. The new code also incorporates DOCK
version 3.5.54 scoring features like Delphi electrostatics,
ligand desolvation, and receptor
desolvation. Finally, DOCK 6 introduces new code that allows access to
the NAB library of functions such as receptor flexibility, the full
AMBER molecular mechanics scoring function with implicit solvent,
conjugate gradient minimization, and molecular dynamics simulation
capabilities.
Command-line Arguments
DOCK must be run from the command line in a standard unix
shell. It reads an input parameter file containing field/value pairs:
USAGE: dock6 -i dock.in [-o dock.out] [-v]
DESCRIPTION:
DOCK may be executed in either interactive or batch mode, depending on
whether the output is written to a file. In interactive mode, the user is
requested only for parameters relevant to the particular run and
default values are provided. This mode is recommended for the initial
construction of the input file and for short calculations. In batch
mode, input parameters are read in from the input file and all output
is written to the output file. This mode is recommended for long
calculations once an input file has been generated interactively.
-i dock.in #input file containing user-defined parameters
-help #emit the usage statement.
-v #verbosity flag that prints additional
information and warnings for scoring functions
-o dock.out #output file containing the parameters
used in the calculation, summary information for each molecule docked,
and all warning messages
Interactive mode
USAGE: dock6 -i dock.in
DESCRIPTION:
When launched this way, DOCK will extract all
relevant parameters from dock.in (or any file supplied by the user). If
additional parameters are needed (or if the dock.infile is non-existent
or empty), DOCK will request them one at a time from the user.
Reasonable default values are presented. Any parameters supplied by the
user will be automatically appended to the dock.in file. If the user
would like to change any previously entered values, the user can edit
the dock.in file using a text editor.
Batch mode
USAGE: dock6 -i dock.in -o dock.out
DESCRIPTION:
When launched in this way, DOCK will run in batch
mode, extracting all relevant parameters from dock.in (or any file
supplied by the user) and will write out all output to dock.out (or any
file supplied by the user). If any parameters are missing or incorrect,
then execution will halt and an appropriate error message will be
reported in dock.out.
Parallel DOCK
USAGE: mpirun [-machinefile
machfile] [-np #_of_proc] dock6.mpi -i dock.in -o dock.out [-v]
DESCRIPTION:
If DOCK has been built for parallel processing
(see ) then
DOCK can be run in parallel.
a single master processor with the remaining processors acting as slaves.
If np = 1, the code defaults to non-MPI behavior.
There is a minimal difference in performance between 1 and 2 processors.
Improved performance is only evident with more than 2 processors.
ADDITIONAL OPTIONS:
-machinefile #simple text
file containing the names of the computers (nodes) to be used
-np # specifies the number of processors which typically is the
same as the number of lines in the machinefile
MPICH2 QUICK START:
MPICH2, unlike MPICH, requires command line initialization.
If your system administrators have not initialized MPICH2 then
follow these steps:
Create a .mpd.conf file in your home directory containing
secretword=mysecretword.
Create a .mpd.hosts file in your home directory containing
a list of machine names, one per line.
Start the MPICH2 daemons by executing mpdboot.
Verify the start up of the MPICH2 daemons by executing mpdtrace -l.
Finally execute DOCK using mpiexec or mpirun.
For further information see the
PB/SA DOCK
USAGE: dock6.pbsa -i dock.in [-o dock.out] [-v]
DESCRIPTION:
If you have compiled DOCK for use
with the ZAP library (see ),
DOCK can be run using the ZAP PB/SA scoring function.
The environment variable
OE_LICENSE must be defined to the full path of the license file.
Parameter Parser
In , dock will dynamically ask the user to enter the
appropriate user parameters. The generic format for the questions is:
parameter_name [default value]
(legal values):
The parameter parser requires that the
values entered for a parameter exactly match one of the legal values.
For example:
Example A: program_location
[Hello_World!] ():
Example B: #_red_balloons [99] ():
Example C: glass_status [half_full]
(half_full half_empty):
In Example A, the parameter
"program_location" can
be assigned any string value, and in Example B, the parameter
"#_red_balloons" can be assigned any integer value. However, in Example
C, the parameter value "glass_status" can only be assigned the strings
"half_full" or "half_empty". If no parameter are assigned by the user,
the default value--in brackets--will be used.
In , all parameters in the dock.in file, must be:
parameter_name value
Note that the parameter_name and corresponding
value must be separated by white space, namely, blanks or tabs.
2.5. Ligand File
Before you can dock a ligand, you will need atom
types and charges for every atom in the ligand. Currently, DOCK only
reads the Tripos MOL2 format. For a single ligand (or several ligands),
you can use Chimera in combination with
to prepare a MOL2
file for the ligand (see )
or various other visualization packages. During the docking procedure,
ligands are read in from a single MOL2 or multi-MOL2 file. Atom and
bond types are assigned using the DOCK 4 atom/bond typing .
NOTE: The following parameter
definitions will use the format below:
parameter_name [default] (value):
#description
In some cases, parameters are only
(questions will only be asked) if the parameter above is enforced.
These parameters are indicated below by additional indentation.
Molecule Library Parameters
ligand_atom_file [database.mol2]
# The ligand input filename
limit_max_ligands [no] (yes, no):
#Limit the number of ligands to be read in from a library
max_ligands[1000]:
#maximum number of ligands that will be read in from a library
skip_molecule [no] (yes, no):
#Skip some number of molecules at the beginning of a library
initial_skip [0] (int):
# The number of molecules to skip over at the beginning of a library
read_mol_solvation [no] (yes, no):
#Flag to read atomic desolvation information from ligand file
calculate_rmsd [no] (yes, no):
#Flag to calculate the heavy atom RMSD between the final ligand pose
#and its initial structure.
use_rmsd_reference_mol [no] (yes, no):
#Specify alternative geometric location for reference structure for RMSD
#calculation
rmsd_reference_filename [ligand_rmsd.mol2]
#File containing alternative geometric location for reference structure for
#RMSD calculation
2.5.1. Ligand RMSD
Three types of root mean square distance (RMSD) values are reported when "calculate_rmsd = yes". These values can be found in the header of the output MOL2 file. Note: Ligand RMSD calculations cannot be performed when running DOCK in parallel.
(1) Standard heavy-atom RMSD (HA_RMSDs): This is the standard pair-wise RMSD calculation between the non-hydrogen atoms of a reference conformation a and a pose conformation b for a ligand with N total heavy atoms of index i:
If the HA_RMSDs is "-1000.0", then there is an inconsistency in the number of heavy atoms between the reference and the docked conformer.
(2) Minimum-distance heavy-atom RMSD (HA_RMSDm): This measure is based on the RMSD implementation used in Autodock Vina (), which does not explicitly enforce one-to-one mapping. Rather, atom pairings between reference conformation a and pose conformation b are determined by the minimum distance to any atom of the same element type, and it may be an under-prediction of the true RMSD.
(3) Hungarian (symmetry-corrected) heavy-atom RMSD (HA_RMSDh):
The final RMSD implementation is based on an O(N^4) implementation of the Hungarian algorithm (; ). The algorithm solves the optimal assignment between a set of reference ligand atoms a and a set of pose ligand atoms b of the same size. For all groups of atoms of the same Sybyl atom type, a cost matrix M is populated where each matrix element mij is equal to the distance-squared between reference atom ai and pose atom bj. The Hungarian algorithm is used to determine one-to-one assignments between reference and pose ligand atoms such that the total distance between atoms is minimized. The new assignments c(i) are fed into the standard RMSD function in order to compute a symmetry-corrected RMSD. If the HA_RMSDh is "-1000.0",
then there is an inconsistency in the number of atoms of at least one atom type between the reference and the docked conformer.
Database Filter
The Database Filter is designed for on-the-fly filtering of small molecules from the database during docking. Filtering small molecules by heavy atoms, rotatable bonds, molecular weight and formal charge is currently supported. This routine is designed to be modular so that other descriptors can be easily added. The default values are deliberately set to allow most small molecules to pass through. One use of this routine would be to partition a database into subsets such as "0-7 rotbonds" or "300-500 molwt" or "neutral charge". Another use would be to exclude ligands that are too small (500 amu) for a particular target. This routine can also be used to filter a database without performing any docking.
Database Filter Parameters
use_database_filter [no] (yes, no):
#Flag to use the Database Filter
dbfilter_max_heavy_atoms [999] (int):
# Maximum number of ligand heavy atoms
dbfilter_min_heavy_atoms [0] (int):
# Minimum number of ligand heavy atoms
dbfilter_max_rot_bonds [999] (int):
# Maximum number of ligand rotatable bonds
dbfilter_min_rot_bonds [0] (int):
# Minimum number of ligand rotatable bonds
dbfilter_max_molwt [9999.0] (float):
# Maximum ligand molecular weight
dbfilter_min_molwt [0.0] (int):
# Minimum ligand molecular weight
dbfilter_max_formal_charge [10.0] (float):
# Maximum ligand formal charge
dbfilter_min_formal_charge [-10.0] (float):
# Minimum ligand formal charge
Orienting the Ligand
2.7.1. Sphere
The rigid body orienting code is written as a
direct implementation of the isomorphous subgraph matching method of
Crippen and Kuhl ().
All receptor sphere pairs and atom center pairs are considered for
inclusion in a matching clique. This is more computationally demanding
than the clique matching algorithm implemented in previous versions
that used a distance binning algorithm to restrict the clique search,
in which pairs of spheres and atom centers were binned by distance.
Only sphere pairs and center pairs that were within the same distance
bin were considered as potential matches
The clique matching implementation avoids bin
boundaries that prevent some receptor sphere and ligand atom pairs from
matching, and, as a result, it can find good matches missed by previous
versions of DOCK. The rigid body rotation code has also been corrected
to avoid a singularity that occurred if the spheres in the match lay
within the same plane.
There are two types of ligand
orientation currently available:
(1) Automated Matching —Specify the
number of orientations, and DOCK will generate matches until enough
orientations passing the bump filter have been formed. Matches are
formed best first, with respect to the difference in the ligand and
site point internal distances.
(2) Manual Matching —Specify the distance and node
parameters,
and DOCK will generate all the matches which satisfy them. The number
of orientations scored is equal to the total matches minus the
orientations discarded by the user applied filters.
Multiple orientations may be
written out for each molecule using the write_orientations parameter
otherwise only the best orientation is recorded.
Note that this feature is available only in serial DOCK;
in parallel DOCK only the best orientation is emitted.
In addition, now "VERBOSE ORIENTING STATS" are now printed when the verbose flag is used.
This prints orienting parameters, residual statistics, statistics on the nodes used in the match.
section below for an example of the output.
2.7.2. Critical
The critical_points feature is used
to focus the orientation search into a subsite of the receptor active
For example, identifying molecules that interact with catalytic
residues might be of chief interest. Any number of points may be
identified as critical
in the sphgen documentation for information on labeling spheres),
and any number of groupings of these
points may be identified.
Cliques are checked for critical points
the criterion is that every grouping must have a coincident sphere
and the first coincident sphere found in a grouping terminates
further searching of that grouping.
An alternative to using critical points is to
discard all site points that are some distance away from the subsite of
interest, while retaining enough site points to define unique ligand
orientations. This feature can be highly effective at reducing matching
by five-fold or more. It is particularly useful to also assign chemical
labels to the critical points to further focus sampling.
In this case cliques are checked first for satisfaction of the
critical points criterion and then for satisfaction of the
chemical matching criteria.
2.7.3. Chemical
The chemical_matching feature is used to
incorporate information about the chemical complementarity of a ligand
orientation into the matching process. In this feature, chemical labels
are assigned to site points
in the sphgen documentation for information on labeling spheres)
and ligand atoms (see )
The site point labels are based on the local receptor environment. The
ligand atom labels are based on user-adjustable chemical functionality
rules. These labeling rules are identified with the chemical_defn_file
parameter and reside in an editable file (see ).
A node in a match will produce an unfavorable interaction if the atom
and site point components have labels which violate a chemical match
rule. The chemical matching rules are identified with the
chemical_match_file parameter and reside in an editable file (see ).
If a match will produce unfavorable interactions, then the match is
discarded. The speed-up from this technique depends how extensively
site points have been labeled and the stringency of the match rules,
but an improvement of two-fold or more can be expected.
Macromolecular Docking
Although DOCK is typically applied to small
ligand molecules, it can be used to study macromolecular ligands,
for example protein-protein and protein-DNA complexes.
The chief difference in protocol is that to use the
match_receptor_sites procedure for the orientation search, special
ligand centers must be used to represent the ligand. This is signaled
by setting the ligand_centers parameter. The ligand centers may be
constructed by
must reside in a file identified with the ligand_center_file parameter.
for examples and discussion of
macromolecular docking.
NOTE: The following parameter
definitions will use the format below:
parameter_name [default] (value):
#description
In some cases, parameters are only
(questions will only be asked) if the parameter above is enforced.
These parameters are indicated below by additional indentation.
Orient Ligand Parameters
orient_ligand [yes] (yes, no):
#Flag to orient ligand to spheres
automated_matching [yes] (yes, no):
# Flag to perform automated matching instead of manual matching
(If automated_matching = no, then
manual_matching is used)
distance_tolerance [0.25] (float):
#The tolerance in angstroms within which a pair of spheres is
considered equivalent to
#a pair of centers
distance_minimum [2.0] (float):
#The shortest distance allowed between 2 spheres (any sphere pair with
#distance is disregarded)
nodes_minimum [3] (int):
#The minimum number of nodes in a clique
nodes_maximum [10] (int):
#The maximum number of nodes in a clique
receptor_site_file [receptor.sph] (string):
# The file containing the receptor spheres
max_orientations [1000] (int):
# The maximum number of orientations that will be cycled through
critical_points [no] (yes, no):
#Flag to use critical point sphere labeling to target orientations to
particular spheres
chemical_matching [no] (yes, no):
#Flag to use chemical coloring of spheres to match chemical labels on
ligand atoms
chem_match_tbl [chem_match.tbl]
#File defining the legal chemical type matches/pairings
use_ligand_spheres [no] (yes/no):
#Flag to enable a sphere file representing ligand heavy atoms to be
used to orient the ligand
#Typically used for macromolecular docking
ligand_sphere_file [ligand.sph] (string):
#The file containing the receptor spheres
Internal Energy Calculation
During growth and minimization, an internal energy scoring function can be used. The goal of the internal energy function
is to reduce the occurrence of internal clashes during the torsional optimization. This function computes the repulsive Lennard-Jones term between all ligand atom pairs, excluding all 1-2, 1-3, and 1-4 pairs. (Currently, attractive Lennard-Jones and Coulombic the aim is to eliminate internal clashes not to optimize the internal geometry. In addition, since there is no dihedral term in the force field, if the attractive terms are included the molecule might appear less physical.)
The internal energy
if cut on, it is reported in the output mol2 file and is used to prune conformers during growth. (This pruning
is separate from the pruning that occurs based on interaction energy).
We recommend the use of the internal energy function for all calculations.
Internal Energy Parameters
use_internal_energy [yes] (yes no):
#Flag to use Internal energy (only repulsive VDW) for growth and/or minimization
internal_energy_rep_exp [12] (int):
#The VDW exponent. The code is optimized for the use of the default value.
Other values will result in significant slow down.
internal_energy_cutoff [100.0] (float):
#All conformers with an internal energy value above this cutoff are pruned.
Internal Energy Output Components
Internal_energy_repulsive:
#sum of the repulsive van der Waals interactions between non-bonded ligand atom pairs
2.9. Ligand
Flexibility
The internal degrees of freedom of the ligand can be sampled
with the anchor-and-grow incremental construction approach.
This conformational search algorithm has been validated
for binding mode prediction on sets of ligands that have
no more than seven rotatable bonds
Anchor-and-Grow
The process of docking a molecule using the
anchor-first strategy is shown in the Workflow for Anchor-and-Grow Algorithm
First, the largest rigid substructure of the ligand (anchor)
is identified (see) and
rigidly oriented in the active site (orientation) by matching its heavy
atoms centers to the receptor sphere centers
The anchor orientations are evaluated and optimized using the scoring
function (see ) and
the energy minimizer (see ).
In general,
the orientations are then ranked according to their score, spatially
clustered by heavy atom root mean squared deviation (RMSD), and pruned
(see ). Next, the remaining flexible
portion of the ligand (see)
is built onto the best anchor orientations within the context of the
receptor (grow). It is assumed that the shape of the binding site will
help restrict the sampling of ligand conformations to those that are
most relevant for the receptor geometry.
for Anchor-and-Grow Algorithm
Starting with version 6.8,
ligand conformational searching is enabled when the
conformer_search_type
input parameter is set to flex.
In versions 6.7 and earlier of DOCK, the corresponding input parameter
was flexible_ligand [yes] (yes no).
Only the torsion
angles are modified, not the bond lengths or angles. Therefore, the
input geometry of the molecule needs to be of good quality. A structure
generated by ZINC is sufficient.
The torsion angle positions reside in an editable
file (see flex_drive.tbl on page 111) which is identified with the
flex_drive_file parameter. Internal clashes are detected during the
torsion drive search based on the clash_overlap or internal_energy
parameters, which are independent of scoring function.
Identification of Rigid Segments
A flexible molecule is treated as a collection of
rigid segments. Each segment contains the largest set of adjacent atoms
separated by non-rotatable bonds. Segments are separated by rotatable
The first step in segmentation is ring identification.
All bonds within molecular rings are treated as rigid.
This classification scheme is a first-order approximation of molecular
flexibility, since some amount of flexibility can exist in non-aromatic
rings. To treat such phenomenon as sugar puckering and chair-boat
hexane conformations, the user will need to supply each ring
conformation as a separate input molecule. Additional bonds may be
specified as rigid by the user
Identification
of Rigid Anchor and Flexible Bonds
The second step is flexible bond
identification. Each flexible bond is associated with a label defined
in an editable file (see ).
The parameter file is identified with the flex_definition_file
parameter. Each label in the file contains a definition based on the
atom types (and chemical environment) of the bonded atoms. Each label
is also flagged as minimizable. Typically, bonds with some degree of
double bond character are excluded from minimization so that planarity
is preserved. Each label is also associated with a set of preferred
torsion positions. The location of each flexible bond is used to
partition the molecule into rigid segments. A segment is the largest
local set of atoms that contains only non-flexible bonds.
Manual Specification of Non-rotatable Bonds
The user can specify additional bonds to be
non-rotatable, to supplement the ring bonds automatically identified by
DOCK. Such a technique could be used to preserve the conformation of
part of a molecule and isolate it from the conformation search.
Non-rotatable bonds are identified in the Tripos MOL2 format file
containing the molecule. The bonds are designated as members of a
STATIC BOND SET named RIGID (see ).
Creation of the RIGID set can be done within
Chimera. With the molecule of interest loaded into Chimera, select the
portion of the ligand you would like to remain rigid. Then select on
File & Save MOL2. Make sure the "Write current selection to @
SETS section of file" is checked and save the file.
Alternatively, the RIGID set can be entered into
the MOL2 file by hand. To do this, go to the end of the MOL2 file. If
no sets currently exist, then add a SET identifier on a new line. It
should contain the text "@&TRIPOS&SET". On a new line add
the text "RIGID STATIC BONDS &user& **** Comment". On the
enter the number of bonds that will be included in the set, followed by
the numerical identifier of each bond in the set.
Identification of Flexible Layers
Anchor Selection
An anchor segment is normally selected from
the rigid segments in an automatic fashion
to override this behavior).
The molecule is divided into segments that
overlap at each rotatable bond. The segment with the largest number of
heavy atoms is selected as the first anchor, number of attachment points are also considered.
All segments with more heavy
atoms then min_anchor_size are tried separately as anchors.
The number of anchors can be limited by setting the limit_max_anchors flag to "yes"; max_anchor_num is used to specify the maximum number of anchors to be used (anchors are ordered by heavy atoms and attachment points):
min_anchor_size 5
limit_max_anchors yes
max_anchor_num 5
At most 5 anchors are used and all anchors have at least 5 heavy atoms.
To use a single specific anchor (e.g scaffold with known bonding pose), specify an atom name and its corresponding atom number in the chosen fragment (e.g. if atom number 10 is C16):
user_specified_anchor yes
atom_in_anchor C16,10
Identification
of Overlapping Segments
When an anchor has been selected,
then the molecule is redivided into non-overlapping segments, which are
then arranged concentrically about the anchor segment. Segments are
reattached to the anchor according to the innermost layer first and
within a layer to the largest segment first.
Non-Overlapping Segments
The anchor is processed separately
(either oriented, scored, and/or minimized). The remaining segments are
subsequently re-attached during the conformation search. The
interaction energy between the receptor and the ligand can be optimized
with a simplex minimizer (see ).
Pruning the Conformation Search Tree
Starting with version 6.1,
there are two methods for pruning.
The first method is the one that existed
it is the default and corresponds to input parameter
pruning_use_clustering = yes.
In this method
pruning attempts to retain the best, most diverse configurations using
a top-first pruning algorithm, which proceeds as follows. The
configurations are ranked according to score. The top-ranked
configuration is set aside and used as a reference configuration for
the first round of pruning. All remaining configurations are considered
candidates for removal. A root-mean-squared distance (RMSD) between
each candidate and the reference configuration is computed.
Each candidate is then evaluated for removal
based on its rank and RMSD using the inequality:
If the factor is greater than
number_confs_for_next_growth, as appropriate, the candidate is removed.
Based on this factor, a configuration with rank 2
and 0.2 angstroms RMSD is comparable to a configuration with rank 20
and 2.0 angstroms RMSD. The next best scoring configuration which
survives the first pass of removal is then set aside and used as a
reference configuration for the second round of pruning, and so on.
This pruning method biases its search time towards molecules that sample a
more diverse set of binding modes. As the values of
num_anchors_orients_for_growth and number_confs_for_next_growth are
increased, the anchor-first method approaches an exhaustive search.
In the second method, the goal is to bias
the sampling towards
conformations that are close to the correct binding mode (as optimized
using a test set of experimentally solved structures). Much as the
method above, the algorithm ranks the generated poses and
conformations. Then, all poses that violate a user-defined score cutoff
are removed. To facilitate the speed of the calculation, the remaining
list is additionally pared back to a user-defined length.
In this method, the sampling is driven towards molecules that sample
to the experimentally determined binding site, and the result is
a significantly less diverse set of final poses.
Time Requirements
The time demand grows linearly with the
num_anchors_orients_for_growth, the number_confs_for_next_growth, the
number of flexible bonds and the number of torsion positions per bond,
as well as the number of anchor segments explored for a given molecule.
Using the notation in the , the time demand can be expressed
additional terms are:
NA is the number of anchor segments tried per
NB is the number of rotatable bonds per molecule.
Growth Tree and Statistics
Dock uses Breadth First Search to sample the conformational space of the ligand. The tree is pruned at every stage of growth to remove unsuitable conformations.
In order to be as space efficient as possible, DOCK only saves one level of growth at a time unless "write_growth_tree" is turned on.
In order to construct the growth tree it was necessary to do the following:
(1) Retain all levels of growth (before and after minimization) in memory.
(2) Link every conformer to its parent conformer during growth.
(3) While writing out the tree, the traversal starts from a fully grown ligand (leaf), moving up the branch (parent conformer) until the ligand anchor (root) is reached. Finally, the growth tree branch is printed as a multi-mol2 file starting from the anchor to the fully grown ligand, including minimizations. This newly implemented feature allows visualization of all stages of growth and optimize behavior of current DOCK routines. Note that the growth trees can easily be visualized using the Viewdock module in the UCSF chimera program. Extra information regarding conformer number, anchor number, parent conformer etc. can also be accessed directly using this tool.
Format for branch files name is as follows:
${Ligand name}_anchor${anchor number}_branch${conformer number of fully grown mol.}.mol2
e.g. LIG1_anchor1_branch4.mol2
The ligand name is that specified in the mol2 file.
The anchor number indicates what fragment or portion of the molecule was used as the anchor.
The every conformer (both partially and fully grown) is assigned a unique number.
we recommend that users cat files together and compress them.
cat *_branch*.mol2 > growth_tree.mol2; gzip growth_tree.mol2
In addition, growth statistics are printed to the output files if the verbose flag is used.
-----------------------------------
VERBOSE MOLECULE STATS
Number of heavy atoms = 30
Number of rotatable bonds = 7
Formal Charge = 1.00
Molecular Weight = 429.56
Heavy Atoms = 30
-----------------------------------
VERBOSE ORIENTING STATS :
Orienting 10 anchor heavy atom centers
Sphere Center Matching Parameters:
tolerance: 0.25; dist_min: 2; min_nodes: 3; max_nodes: 10
Num of cliques generated: 2298
Residual Info:
min residual:
median residual: 0.3932
max residual:
mean residual:
std residual:
Node Sizes:
min nodes:
max nodes:
mean nodes:
# of anchor positions: 1000
-----------------------------------
VERBOSE GROWTH STATS : ANCHOR #1
32/1000 anchor orients retained (max 1000) t=9.06s
Lyr 1-1 Segs|Lyr 2-1 Segs|Lyr 3-2 Segs|Lyr 4-2 Segs|Lyr 5-1 Segs|
Lyr:1 Seg:0 Bond:8 : Sampling 6 dihedrals C6(C.ar)
Lyr:1 Seg:0 24/192 retained, Pruning: 6-score 162-clustered
Lyr:2 Seg:0 Bond:5 : Sampling 3 dihedrals C4(C.ar)
Lyr:2 Seg:0 51/72 retained, Pruning: 21-clustered
Lyr:3 Seg:0 Bond:1 : Sampling 3 dihedrals C3(C.3)
Lyr:3 Seg:0 105/153 retained, Pruning: 7-score 41-clustered
Lyr:3 Seg:1 Bond:3 : Sampling 6 dihedrals N4(N.am)
Lyr:3 Seg:1 86/630 retained, Pruning: 8-score 536-clustered
Lyr:4 Seg:0 Bond:43 : Sampling 3 dihedrals C16(C.ar)
Lyr:4 Seg:0 90/258 retained, Pruning: 168-clustered
Lyr:4 Seg:1 Bond:26 : Sampling 2 dihedrals C11(C.3)
Lyr:4 Seg:1 147/180 retained, Pruning: 5-score 28-clustered
Lyr:5 Seg:0 Bond:46 : Sampling 6 dihedrals C17(C.ar)
Lyr:5 Seg:0 104/882 retained, Pruning: 15-outside grid 22-score 741-clustered
These are the verbose growth statistics for flexible docking to 1PPH (thrombin). These are printed only when the verbose flag is enabled in the command line. This feature is useful for debugging incomplete growths and other possible issues with the growth routines. This feature is also useful to show progress when docking in larger peptide-like ligands (20+ rotatable bonds) which can take several hours. Cumulative timing in seconds (e.g. t=13.37s) is shown at the end of each line to allow quick profiling of the slowest steps during docking. A separate section is printed for each anchor sampled when using multiple anchors. For anchor #1, the orienting routine produces 1000 orients, and 37 are retained after clustering and minimization. The ligand has 7 rotatable bonds. The second line shows the assignment of layers and segments. For details on the terminology, please consult the DOCK 4 paper. subsequently, two lines of information are printed for each torsion sampled.
Lyr:1 Seg:0 indicates that this is Layer #1 and Segment #0. Layer and segment number starts from zero, and corresponds to the array indices used internally. Bond:8 refers to bond number in the mol2 file read in. "Sampling 6 dihedrals C6(C.ar)  C4(C.ar)  C3(C.3)  C1(C.3)" specifies the exact torsion being sampled. Six dihedral positions are being sampled in this case, as determined by the drive_id in flex_drive.tbl. 21/246 retained means 21 conformers were retained from the 246 conformers generated during growth (41 conformers x 6 dihedral positions = 246 new conformers). The Pruning: section demonstrates how these (246-21) or 225 conformers were pruned: 2 conformers were outside the energy grid, 5 conformers exceeded the score cut-off (see pruning_conformer_score_cutoff) and 218 conformers were clustered. Typically clustering removes the greatest number of conformers during each torsion grown as controlled by the pruning_clustering_cutoff parameter. The reader is encouraged to verify that the number of conformers retained can be calculated as above at each stage of growth. If the growth tree is turned on, the total number of conformers stored in the growth tree are also reported.
NOTE: The following parameter
definitions will use the format below:
parameter_name [default] (value):
#description
In some cases, parameters are only needed
(questions will only be asked) if the parameter above is enforced.
These parameters are indicated below by additional indentation.
Flexible Ligand Parameters
conformer_search_type [flex] (rigid | flex):
#Flag to perform ligand conformational searching
user_specified_anchor [no] (yes no):
#Flag to let the user choose the anchor segment for growth.
atom_in_anchor [C1,1] ():
#Specify an atom within the chosen anchor segment.
limit_max_anchors [no] (yes no):
#Flag to limit the number of anchors used during multi-anchor docking.
max_anchor_num [1] ():
#The maximum number of anchor segments to be used.
min_anchor_size [5] (int):
#The minimum number of heavy atoms for an anchor segment.
#Set this to a high number (40) to use a single anchor.
#For multi-anchor docking, use 5 or 6 (pyrrole or benzene ring respectively).
pruning_use_clustering [yes] (yes, no):
#Flag to enable clustering during pruning
(if pruning_use_clustering = yes)
pruning_max_orients [1000] (int):
#The maximum number of anchor orientations carried forward in the
#anchor and grow search (previously num_anchor_orients_for_growth)
pruning_clustering_cutoff [100] (int):
#The pruning value cutoff for anchor orientations promoted to the
#conformational search (previously number_confs_for_next_growth and
#referred to as N_c in the equation in Pruning the Conformation Search Tree)
(if pruning_use_clustering = no)
pruning_max_orients [1000] (int):
#Maximum number of anchor orientations promoted to the conformational search
pruning_orient_score_cutoff [25.0] (float):
#Maximum score for anchor after minimization
pruning_max_conformers [75] (int):
#Maximum number of anchor orientation