AutoGrow 3.0 is an evolutionary algorithm that optimizes candidate ligands for predicted binding affinity and other druglike properties. Though no substitute for the medicinal chemist, AutoGrow attempts to introduce some chemical intuition into the automated optimization process. By carefully crafting chemically feasible druglike molecules, we hope that AutoGrow 3.0 will help supplement the chemist's efforts.
A copy of AutoGrow 3.0 can be obtained from our sourceforge page. AutoGrow 3.0 is dependent on several other free software packages, including MGLTools, Open Babel, AutoDock Vina, and NumPy/SciPy. The program has been specifically tested on Ubuntu 12.10 with python 2.7.3, NumPy 1.6.2, SciPy 0.10.1, MGLTools 1.5.6rc3, Open Babel 2.3.2, and AutoDock Vina 1.1.2; Scientific Linux 6.2 with python 2.6.6, NumPy 1.6.2, SciPy 0.11.0, MGLTools 1.5.4, Open Babel 2.3.1, and AutoDock Vina 1.1.2; and Mac OS X 10.8.1 with python 2.7.2, NumPy 1.6.1, SciPy 0.12.0dev, MGLTools 1.5.6, Open Babel 2.3.1, and AutoDock Vina 1.1.2. Windows users can employ virtualization software (e.g., Oracle VM VirtualBox) to run Linux on their systems, making AutoGrow 3.0 accessible on that platform as well.

Though it is no longer supported, a copy of AutoGrow 2.0 can also be downloaded from the sourceforge page. The old AutoGrow 2.0 webpage describing program usage can be found here.

If you use AutoGrow 3.0, please be sure to cite our publication: {REF HERE}
As an evolutionary algorithm, AutoGrow 3.0 deals not with a single ligand, but with populations of ligands. These populations are divided into "generations." Each generation is subject to three operators, called mutation, crossover, and selection.

To derive a novel compound via mutation, AutoGrow 3.0 first randomly selects one of the many click-chemistry reactions programmed into AutoClickChem. A fragment that can participate in this reaction is then selected at random from a user-specified database and added to the known or suspected ligands by simulating the reaction in silico.

AutoClickChem performs two kinds of virtual reactions. Modification reactions involve replacing certain moieties with chemically reactive groups. For example, a halide atom can be replaced with an azide group. In contrast, joining reactions involve combining two distinct molecular models into one via simulated click-chemistry reactions. For example, a molecule containing an azide group can be joined to a molecule containing an alkyne group via a simulated azide-alkyne Huisgen cycloaddition. AutoGrow 3.0 allows the user to specify whether "mutant" ligands should be derived using both modification and joining reactions, or if joining reactions alone should be permitted.

The AutoGrow 3.0 crossover operator is based on the LigMerge algorithm. First, two "parent" molecules are aligned by superimposing the maximum (largest) substructure common to both. Novel compound are then generated by systematically mixing and matching the distinct fragments attached to the respective aligned substructures. In this way, "child" molecules can be generated that are topologically similar to but nevertheless distinct from their two "parents."

Once a generation of compounds has been created using the mutation and crossover operators, the selection operator is used to identify the ligands that are the most "fit." A number of criteria are used in selecting the top ligands. First, each ligand is evaluated for druglike properties using Open Babel and python definitions built with the pymolecule framework. Compounds that are not druglike are discarded. The user can select whether generated compounds must satisfy Lipinski's Rule of Fives with no violations, Lipinski's Rule of Fives with at most one violation, or the criteria described by Ghose et al.

The user can also instruct AutoGrow to discard any compounds that do not contain specific, key moieties. For example, suppose previous research has identified ten inhibitors that all contain a single carboxylate group. As the carboxylate group may be critical for binding, the user may wish to use AutoGrow to generate novel compounds from these ten that preserve this key moiety. However, AutoClickChem considers carboxylate groups to be reactive and tends to convert them into esters, amides, etc. Additionally, LigMerge could potentially generate compounds that do not contain the carboxylate group. To preserve this key moiety, the user can "mark" the two oxygen atoms of the carboxylate group by editing the PDB files of the ten known inhibitors and in every case appending an exclamation point to the atom names of the two carboxylate oxygen atoms. AutoGrow can then be instructed to discard all generated compounds that do not contain at least two marked atoms, thus preserving the key moiety.

Finally, those ligands that remain are subsequently docked into the receptor of interest using AutoDock Vina. Optionally, the docked poses can be reevaluated with NNScore 1.0 or NNScore 2.0. The best-scoring ligands are then selected to be the founders of the next generation. The compounds of this new generation are again created via mutation and crossover operators, this time applied to the best ligands of the previous generation, and the process begins anew, repeating until the user-specified number of generations has been completed.
COMMAND LINE PARAMETERS

PARAMETER
DEFAULT
DESCRIPTION

-directory_of_source_compounds
./
A directory containing the initial population of ligands to optimize, in PDB format.

-directory_of_fragments
{AUTOGROW_HOME}/fragments/MW_250/
A properly formatted directory containing fragments that can be added to the evolving ligands.

-filename_of_receptor
./
The filename of the receptor into which the evolving ligands will be docked, in PDB format.

-number_of_mutants
40
The number of 'mutant' ligands to create per generation.

-number_of_crossovers_first_generation
0
The number of 'crossover' ligands to create in the first generation. If only one or a few ligands are present in the directory specified by the -directory_of_source_compounds tag, it may not be possible to generate many crossover ligands in the first generation.

-number_of_mutants_first_generation
0
The number of 'mutant' ligands to create in the first generation. If only one or a few ligands are present in the directory specified by the -directory_of_source_compounds tag, it may not be possible to generate many crossover ligands in the first generation.

-number_of_crossovers
0
The number of 'crossover' ligands to create in subsequent generations.

-top_ones_to_advance_to_next_generation
10
The number of best-scoring ligands selected to serve as the founders of the next generation.

-num_generations
10
The number of generations to run.

-max_seconds_per_generation
1000000
The program is terminated if a generation runs for longer than the number of seconds specified by this tag.

-center_x
0.0
The x-coordinate of the center of the AutoDock-Vina box used for docking, typically corresponding to the location of the the active site.

-center_y
0.0
The y-coordinate of the center of the AutoDock-Vina box used for docking, typically corresponding to the location of the the active site.

-center_z
0.0
The z-coordinate of the center of the AutoDock-Vina box used for docking, typically corresponding to the location of the the active site.

-num_processors
all_processors
The number of processors to use, for use on multi-core machines.

-size_x
30.0
The size of the AutoDock-Vina docking box along the x axis.

-size_y
30.0
The size of the AutoDock-Vina docking box along the y axis.

-size_z
30.0
The size of the AutoDock-Vina docking box along the z axis.

-output_dir
./output/
The output directory to which all docking and scoring output files are written.

-vina_executable
(no default)
The absolute path to the AutoDock Vina executable. The location of this executable can also be specified by modifying the variable definition near the beginning of this script. Example: /home/myname/autodock_vina_1_1_2_linux_x86/bin/vina

-openbabel_bin_directory
(no default)
The absolute path to the Open Babel bin directory. The location of this directory can also be specified by modifying the variable definition near the beginning of this script. Example: /home/myname/openbabel-2.2.0/bin/

-obprop_executable
(no default)
AutoGrow attempts to locate the obprop executable based on the directory specified by the -openbabel_bin_directory tag, but, if desired, the location of this executable can be specified explicitly.

-babel_executable
(no default)
AutoGrow attempts to locate the babel executable based on the directory specified by the -openbabel_bin_directory tag, but, if desired, the location of this executable can be specified explicitly.

-mgltools_directory
(no default)
The absolute path to the main directory of MGLTools. The location of this directory can also be specified by modifying the variable definition near the beginning of this script. Example: /home/myname/MGLTools-1.5.4/

-prepare_ligand4.py
(no default)
AutoGrow attempts to locate the prepare_ligand4.py script based on the directory specified by the -mgltools_directory tag, but, if desired, the location of this script can be specified explicitly.

-prepare_receptor4.py
(no default)
AutoGrow attempts to locate the prepare_receptor4.py script based on the directory specified by the -mgltools_directory tag, but, if desired, the location of this script can be specified explicitly.

-mgl_python
(no default)
AutoGrow attempts to locate the python executable distributed with MGLTools based on the directory specified by the -mgltools_directory tag, but, if desired, the location of this executable can be specified explicitly.

-autoclickchem_script
{AUTOGROW_HOME}/support/autoclickchem/autoclickchem.py
The absolute path to the main AutoClickChem python file, in case you don't want to use the version that ships with AutoGrow.

-nn1_script
{AUTOGROW_HOME}/support/NNScore/NNScore_1.0/NNScore.py
The absolute path to the main NNScore 1.0 python file, in case you don't want to use the version of NNScore 1.0 that ships with AutoGrow.

-nn2_script
{AUTOGROW_HOME}/support/NNScore/NNScore_2.01/NNScore2.01.py
The absolute path to the main NNScore 2.0 python file, in case you don't want to use the version of NNScore 2.0 that ships with AutoGrow. Note that if NNScore 2.0 is used, the -vina_executable command-line parameter must point to a copy of Vina 1.1.2 specifically.

-scoring_function
VINA
Which scoring function to use when determining the best- binding ligands of each generation. Acceptable values are "VINA", "NN1", and "NN2" for the AutoDock Vina, NNScore 1.0, and NNScore 2.0 scoring functions, respectively. Note that if NNScore 2.0 is used, the -vina_executable command-line parameter must point to a copy of Vina 1.1.2 specifically.

-use_lipinski_filter
TRUE
Only advance ligands judged druglike because they satisfy Lipinski's Rule of Five. Allow for one violation, per Lipinski's recommendations. Acceptable values are "TRUE" and "FALSE".

-use_strict_lipinski_filter
TRUE
Only advance ligands judged druglike because they satisfy Lipinski's Rule of Five. Ignoring Lipinski's recommendations (which allow for one violation), permit no violations. Acceptable values are "TRUE" and "FALSE".

-use_ghose_filter
FALSE
Only advance ligands judged druglike based on the criteria proposed by Ghose et al. Acceptable values are "TRUE" and "FALSE".

-score_by_ligand_efficiency
FALSE
Use ligand efficiency (predicted binding affinity divided by the number of heavy atoms in the ligand) instead of the predicted binding affinity alone to assess the goodness of binding. Acceptable values are "TRUE" and "FALSE".

-allow_modification_without_frag_addition
FALSE
Do not use those AutoClickChem reactions that modify compounds without adding new fragments. For example, converting a halide to an azide is considered a modification. On the other hand, merging two compounds via an azide-alkyne cycloaddition is a fragment addition. Acceptable values are "TRUE" and "FALSE".

-maintain_core
FALSE
Sometimes users may wish to ensure that selected atoms from the starting compounds are always present in all ligands subsequently generated. For example, perhaps the starting compounds are known inhibitors, and a certain chemical moiety that is common among them is known to be critical for binding and so should not be modified. These "core" atoms are marked by placing a single exclamation mark in the atom name of the associated PDB file. If the -maintain_core flag is set to TRUE, AutoGrow will only generate compounds that contain a certain number of marked, "core" atoms. The minimum number of marked atoms permissible is set by the -minimum_core_atoms_required flag. Acceptable values are "TRUE" and "FALSE".

-minimum_core_atoms_required
1
This flag is only used if the -maintain_core flag is set to TRUE. AutoGrow will only generate compounds that contain at the very least this number of atoms marked by placing a single exclamation point in the atom name. To protect a deprotonated carboxylate group from being converted to an amide, for example, the user could mark the associated carbon and oxygen atoms by putting an "!" in their atom names. The minimum_core_atoms_required tag could then be set to 3, thus requiring that all these carboxylate atoms be present in every generated ligand, thereby preventing AutoGrow from converting this carboxylate group into an amide.

-additional_autoclickchem_parameters
 
If you'd like to pass specific commandline parameters to AutoClickChem (e.g., to limit the types of click-chemistry reactions performed), used this parameter. Enclose AutoClickChem parameters in quotes.


EXAMPLE

python autogrow3.py -number_of_mutants 20 -number_of_crossovers 10 -top_ones_to_advance_to_next_generation 10 -center_x 37.641998 -center_y 25.400999 -center_z 15.80400 -size_x 30.0 -size_y 30.0 -size_z 30. -directory_of_source_compounds ./benzenes/ -directory_of_fragments ./fragments/MW_150/ -filename_of_receptor ./receptors/myreceptor.pdb -output_dir ./output/ -mgltools_directory /SOME_PATH/mgltools_x86_64Linux2_1.5.4 -vina_executable /SOME_PATH/autodock_vina_1_1_2/bin/vina -obprop_executable /SOME_PATH/obprop -openbabel_bin_directory /SOME_PATH/bin -num_generations 10 -use_strict_lipinski_filter TRUE -use_ghose_filter FALSE -allow_modification_without_frag_addition TRUE -maintain_core FALSE
AutoGrow 3.0 includes a subdirectory called tutorial with files that show how to use the software.

Step 1: Begin by changing to the tutorial directory: cd /PATH/TO/AUTOGROW3/tutorial/
Step 2: AutoGrow 3.0 can be run from this directory thusly: python ../autogrow_3_0.py
Step 3: Specify a PDB model of the target protein receptor. In this tutorial, a model of TbREL1 (PDB ID: 1XDN), a potential African-sleep-sickness drug target, will be used. The center of the TbREL1 active site is roughly located at (39.5, 23.7, 15.0). A box 30.0 x 30.0 x 20.0 centered on that point should encompass the entire site. These are the AutoGrow 3.0 parameters required: -filename_of_receptor 1xdn_receptor.pdb -center_x 39.5 -center_y 23.7 -center_z 15.0 -size_x 30.0 -size_y 30.0 -size_z 20.0
Step 4: Specify which click-chemisty reactions to use in ligand building. In this example, we'll use the azide-alkyne Huisgen cycloaddition. Though it's a bit redundant here, we'll also tell AutoGrow 3.0 to avoid click-chemistry reactions that merely swap compound moieties (e.g., Br => azide), favoring instead joining reactions that actually add new fragments. -additional_autoclickchem_parameters "-all_reactions +azide_and_alkyne_to_azole" -allow_modification_without_frag_addition FALSE
Step 5: Specify the source compounds that will be optimized into predicted ligands. The tutorial directory contains a subdirectory called starting_compounds with 117 naphthalene PDB files chosen because a number of experimentally validated TbREL1 inhibitors contain naphthalene substructures. Additionally, these naphthalene models contain azide and/or alkyne groups, so they can participate in the azide-alkyne Huisgen cycloaddition. The fragments that will be added to these naphthalene building blocks via this cycloaddition reaction will be drawn from one of the AutoGrow 3.0 default fragment libraries. -directory_of_source_compounds ./starting_compounds/ -directory_of_fragments ../fragments/MW_250/
Step 6: A number of parameters must also be included to control the behavior of the genetic algorithm. Note that the first generation is special in that it can have a different number of mutants and crossovers than subsequent generations. -number_of_mutants_first_generation 10 -number_of_crossovers_first_generation 10 -number_of_mutants 10 -number_of_crossovers 10 -top_ones_to_advance_to_next_generation 5 -num_generations 50 -max_seconds_per_generation 1000000
Step 7: Aside from judging ligand fitness by the docking score, AutoGrow 3.0 can be instructed to selectively advance only drug-like compounds to subsequent generations. In the current example, we're going to require that ligands satisfy Lipinski's Rule of Fives as well as the drug-like criteria described by Ghose et al. We're also going to evaluate compound fitness using the AutoDock Vina scoring function. The actual docking score will be used, rather than ligand efficiency (score / number of heavy atoms). -use_lipinski_filter TRUE -use_strict_lipinski_filter TRUE -use_ghose_filter TRUE -scoring_function VINA -score_by_ligand_efficiency FALSE
Step 8: AutoGrow 3.0 can be instructed to favor compounds that contain certain key moieties. In the current example, however, we do not need this functionality. -maintain_core FALSE -minimum_core_atoms_required 0
Step 9: AutoGrow 3.0 requires a number of additional open-source programs. The locations of these programs and/or their directories must also be specified. Take care to specify the correct paths here. -vina_executable should point to the actual vina executable, not a directory. In contrast, -openbabel_bin_directory points to a directory that contains the executable files babel and obprop, and -mgltools_directory points to a directory that contains subdirectories with names like bin and MGLToolsPckgs. -vina_executable /PATH/TO/VINA/EXECUTABLE/vina -openbabel_bin_directory /PATH/TO/OPENBABEL/BIN/DIR/bin/ -mgltools_directory /PATH/TO/MGLTOOLS/DIRECTORY/MGLTools-1.5.4/
Step 10: AutoGrow 3.0 runs much faster on multiple processors. -num_processors 4
Step 11: Finally, the user must specify the directory where the AutoGrow 3.0 output will be written. -output_dir ./autogrow_output/
So, putting all this together, we have the following command line: python ../autogrow_3_0.py -filename_of_receptor 1xdn_receptor.pdb -center_x 39.5 -center_y 23.7 -center_z 15.0 -size_x 30.0 -size_y 30.0 -size_z 20.0 -additional_autoclickchem_parameters "-all_reactions +azide_and_alkyne_to_azole" -allow_modification_without_frag_addition FALSE -directory_of_source_compounds ./starting_compounds/ -directory_of_fragments ../fragments/MW_250/ -number_of_mutants_first_generation 10 -number_of_crossovers_first_generation 10 -number_of_mutants 10 -number_of_crossovers 10 -top_ones_to_advance_to_next_generation 5 -num_generations 50 -max_seconds_per_generation 1000000 -use_lipinski_filter TRUE -use_strict_lipinski_filter TRUE -use_ghose_filter TRUE -scoring_function VINA -score_by_ligand_efficiency FALSE -maintain_core FALSE -minimum_core_atoms_required 0 -vina_executable /PATH/TO/VINA/EXECUTABLE/vina -openbabel_bin_directory /PATH/TO/OPENBABEL/BIN/DIR/bin/ -mgltools_directory /PATH/TO/MGLTOOLS/DIRECTORY/MGLTools-1.5.4/ -num_processors 4 -output_dir ./autogrow_output/
This is the command line contained in the run_example_linux_or_macosx file.
AutoGrow 3.0 Download
MGLTools
Open Babel
AutoDock Vina
Numpy
Scipy
Oracle VM VirtualBox
AutoClickChem
LigMerge
pymolecule
NNScore 1.0
NNScore 2.0
AutoGrow 2.0
Copyright 2012 Dr. Jacob D. Durrant. All Rights Reserved.