### Executing a Python Vina Script

Source: https://autodock-vina.readthedocs.io/en/latest/_sources/docking_python.rst.txt

This console command shows how to navigate to the example directory and execute a Python script using the `python` interpreter. Replace `<examples_directory>` with the actual path to your Vina examples.

```console
$ cd <examples_directory>/python_scripting
$ python first_example.py
```

--------------------------------

### Installing Vina Python Bindings with Pip

Source: https://autodock-vina.readthedocs.io/en/latest/_sources/installation.rst.txt

Install the AutoDock Vina Python bindings and NumPy using pip. It is recommended to use a virtual environment for this installation.

```bash
$ pip install -U numpy vina
```

--------------------------------

### Compiling Vina Python Bindings from Source

Source: https://autodock-vina.readthedocs.io/en/latest/_sources/installation.rst.txt

Build and install the AutoDock Vina Python bindings. This process requires activating the Conda environment and installing dependencies.

```bash
$ conda activate vina
$ cd AutoDock-Vina/build/python
$ conda install -c conda-forge numpy boost-cpp swig
$ rm -rf build dist *.egg-info (to clean previous installation)
$ python setup.py build install
```

--------------------------------

### GPF File Content Example

Source: https://autodock-vina.readthedocs.io/en/latest/docking_zinc.html

This is an example of the content within a generated GPF file, detailing grid parameters, forcefield information, and atom types for AutoGrid.

```text
npts 40 30 50                        # num.grid points in xyz
parameter_file AD4Zn.dat             # force field default parameter file
gridfld protein_tz.maps.fld          # grid_data_file
spacing 0.375                        # spacing(A)
receptor_types A C TZ NA ZN OA N P SA HD # receptor atom types
ligand_types A C Cl NA OA N HD       # ligand atom types
receptor protein_tz.pdbqt            # macromolecule
gridcenter 18 134 -1                 # xyz-coordinates or auto
smooth 0.5                           # store minimum energy w/in rad(A)
map protein_tz.A.map                 # atom-specific affinity map
map protein_tz.C.map                 # atom-specific affinity map
map protein_tz.Cl.map                # atom-specific affinity map
map protein_tz.NA.map                # atom-specific affinity map
map protein_tz.OA.map                # atom-specific affinity map
map protein_tz.N.map                 # atom-specific affinity map
map protein_tz.HD.map                # atom-specific affinity map
elecmap protein_tz.e.map             # electrostatic potential map
dsolvmap protein_tz.d.map              # desolvation potential map
dielectric -0.1465                   # <0, AD4 distance-dep.diel;>0, constant
nbp_r_eps 0.25 23.2135 12 6 NA TZ
nbp_r_eps 2.1   3.8453 12 6 OA Zn
nbp_r_eps 2.25  7.5914 12 6 SA Zn
nbp_r_eps 1.0   0.0    12 6 HD Zn
nbp_r_eps 2.0   0.0060 12 6 NA Zn
nbp_r_eps 2.0   0.2966 12 6  N Zn

```

--------------------------------

### Basic AutoDock Vina Python Script

Source: https://autodock-vina.readthedocs.io/en/latest/_sources/docking_python.rst.txt

This script demonstrates a fundamental workflow: loading a receptor and ligand, computing Vina maps, scoring, minimizing, and docking. It saves the minimized pose and docked poses to PDBQT files. Ensure Vina is installed and receptor/ligand files are accessible.

```python
#! /usr/bin/env python
# -*- coding: utf-8 -*-
#
# My first example with AutoDock Vina in python
#

from vina import Vina


v = Vina(sf_name='vina')

v.set_receptor('1iep_receptor.pdbqt')

v.set_ligand_from_file('1iep_ligand.pdbqt')
v.compute_vina_maps(center=[15.190, 53.903, 16.917], box_size=[20, 20, 20])

# Score the current pose
energy = v.score()
print('Score before minimization: %.3f (kcal/mol)' % energy[0])

# Minimized locally the current pose
energy_minimized = v.optimize()
print('Score after minimization : %.3f (kcal/mol)' % energy_minimized[0])
v.write_pose('1iep_ligand_minimized.pdbqt', overwrite=True)

# Dock the ligand
v.dock(exhaustiveness=32, n_poses=20)
v.write_poses('1iep_ligand_vina_out.pdbqt', n_poses=5, overwrite=True)
```

--------------------------------

### mk_prepare_receptor.py Output Example

Source: https://autodock-vina.readthedocs.io/en/latest/docking_zinc.html

This output indicates that the noncovalent cofactor 'FPP' was successfully created based on a CIF file from the PDB. It details the structure and atom names of the newly built template.

```json
{
    "ambiguous": {
        "FPP": ["FPP"]
    },
    "residue_templates": {
        "FPP": {
            "smiles": "[H]C(=C(C([H])([H])[H])C([H])([H])C([H])([H])C([H])=C(C([H])([H])[H])C([H])([H])[H])C([H])([H])OP(=O)([O-])OP(=O)([O-])[O-]",
            "atom_name": ["H2", "C2", "C3", "C4", "H41", "H42", "H43", "C5", "H51", "H52", "C6", "H61", "H62", "C7", "H7", "C8", "C10", "H101", "H102", "H103", "C9", "H91", "H92", "C11", "H111", "H112", "C12", "H12", "C13", "C14", "H141", "H142", "H143", "C15", "H151", "H152", "H153", "C1", "H11", "H12A", "O1", "PA", "O1A", "O2A", "O3A", "PB", "O1B", "O2B", "O3B"],
            "link_labels": {}
        }
    }
}

```

--------------------------------

### Install Meeko and related Python packages using pip

Source: https://autodock-vina.readthedocs.io/en/latest/_sources/docking_requirements.rst.txt

Installs Meeko and its dependencies using pip. It's recommended to use a virtual environment.

```bash
$ pip install -U numpy scipy rdkit vina meeko gemmi prody
```

--------------------------------

### Example Output: Vina Forcefield Docking Results

Source: https://autodock-vina.readthedocs.io/en/latest/docking_flexible.html

This output displays the results from a flexible docking calculation using the Vina forcefield. It includes docked poses with their affinity (kcal/mol) and rmsd values relative to the best mode.

```text
Scoring function :vina
Rigid receptor: 1fpu_receptor_rigid.pdbqt
Flex receptor: 1fpu_receptor_flex.pdbqt
Ligand: 1iep_ligand.pdbqt
Grid center: X 15.19 Y 53.903 Z 16.917
Grid size  : X 20 Y 20 Z 20
Grid space : 0.375
Exhaustiveness: 32
CPU: 0
Verbosity: 1

Computing Vina grid ... done.
Performing docking (random seed: 1431646130) ...
0%   10   20   30   40   50   60   70   80   90   100%
|----|----|----|----|----|----|----|----|----|----|
***************************************************

mode |   affinity | dist from best mode
    | (kcal/mol) | rmsd l.b.| rmsd u.b.
-----+------------+----------+----------
1       -11.63          0          0
2       -10.57      3.242      12.12
3        -10.3      3.974       11.9
4       -9.906      3.903      11.97
5       -9.895      2.609      12.28
6       -9.854      1.958      13.07
7       -8.849      2.059      12.19
8       -8.758      3.259      12.12
9       -8.543      3.981      12.35


```

--------------------------------

### Content of Grid Parameter File (GPF)

Source: https://autodock-vina.readthedocs.io/en/latest/_sources/docking_hydrated.rst.txt

This is an example of the content of a GPF file used for calculating affinity maps for AutoGrid4.

```console
parameter_file boron-silicon-atom_par.dat
npts 40 40 40
gridfld 1uw6_receptor.maps.fld
spacing 0.375
receptor_types HD C A N NA OA F P SA S Cl Br I Mg Ca Mn Fe Zn
ligand_types HD C A N NA OA F P SA S Cl CL Br BR I Si B
receptor 1uw6_receptor.pdbqt
gridcenter 83.640 69.684 -10.124
smooth 0.500
map 1uw6_receptor.HD.map
map 1uw6_receptor.C.map
map 1uw6_receptor.A.map
map 1uw6_receptor.N.map
map 1uw6_receptor.NA.map
map 1uw6_receptor.OA.map
map 1uw6_receptor.F.map
map 1uw6_receptor.P.map
map 1uw6_receptor.SA.map
map 1uw6_receptor.S.map
map 1uw6_receptor.Cl.map
map 1uw6_receptor.CL.map
map 1uw6_receptor.Br.map
map 1uw6_receptor.BR.map
map 1uw6_receptor.I.map
map 1uw6_receptor.Si.map
map 1uw6_receptor.B.map
elecmap 1uw6_receptor.e.map
dsolvmap 1uw6_receptor.d.map
dielectric -42.000
```

--------------------------------

### Example Output: AutoDock4 Forcefield Docking Results

Source: https://autodock-vina.readthedocs.io/en/latest/docking_flexible.html

This output shows the results of a flexible docking calculation using the AutoDock4 forcefield. It lists docked poses with their affinity (kcal/mol) and root-mean-square deviation (rmsd) from the best mode.

```text
Scoring function : ad4
Flex receptor: 1fpu_receptor_flex.pdbqt
Ligand: 1iep_ligand.pdbqt
Exhaustiveness: 32
CPU: 0
Verbosity: 1

Reading AD4.2 maps ... done.
Performing docking (random seed: 711073774) ...
0%   10   20   30   40   50   60   70   80   90   100%
|----|----|----|----|----|----|----|----|----|----|
***************************************************

mode |   affinity | dist from best mode
    | (kcal/mol) | rmsd l.b.| rmsd u.b.
-----+------------+----------+----------
1        -14.2          0          0
2          -14      1.163      1.777
3        -13.4      1.182      1.616
4       -11.92      1.521       2.19
5       -11.76      1.963      3.295
6       -11.68      2.872       10.9
7       -11.13      3.933      10.75
8       -10.99      3.702      11.82
9       -10.72       2.08      11.06


```

--------------------------------

### Prepare Multiple Ligands

Source: https://autodock-vina.readthedocs.io/en/latest/docking_multiple_ligands.html

Use scrub.py to add hydrogens and mk_prepare_ligand.py to convert SDF to PDBQT format for multiple ligands.

```bash
$ scrub.py 5x72_ligand_p59.sdf -o 5x72_ligand_p59H.sdf
$ mk_prepare_ligand.py -i 5x72_ligand_p59H.sdf -o 5x72_ligand_p59.pdbqt
$ scrub.py 5x72_ligand_p69.sdf -o 5x72_ligand_p69H.sdf
$ mk_prepare_ligand.py -i 5x72_ligand_p69H.sdf -o 5x72_ligand_p69.pdbqt

```

--------------------------------

### Installing NumPy and Vina in Conda Environment

Source: https://autodock-vina.readthedocs.io/en/latest/_sources/installation.rst.txt

Install NumPy and AutoDock Vina within an activated Conda environment. This command also installs necessary Boost libraries.

```bash
$ conda install -c conda-forge numpy swig boost-cpp libboost sphinx sphinx_rtd_theme
$ pip install vina
```

--------------------------------

### Install Meeko and related packages in a Conda environment

Source: https://autodock-vina.readthedocs.io/en/latest/docking_requirements.html

This sequence of commands installs Meeko and its dependencies within a Conda environment. It includes activating a 'vina' environment, setting Python to version 3.10 for ProDy compatibility, installing core packages via conda, and then installing ProDy via pip.

```bash
$ conda activate vina
$ conda install python=3.10    # for ProDy interoperability
$ conda install -c conda-forge numpy scipy rdkit vina meeko gemmi autogrid
$ pip install prody

```

--------------------------------

### Prepare Ligand and Add Hydrogens

Source: https://autodock-vina.readthedocs.io/en/latest/_sources/docking_zinc.rst.txt

Use scrub.py to add hydrogens and mk_prepare_ligand.py to convert SDF to PDBQT format.

```bash
$ scrub.py 1s63_ligand.sdf -o 1s63_ligandH.sdf 
$ mk_prepare_ligand.py -i 1s63_ligandH.sdf -o 1s63_ligand.pdbqt
```

--------------------------------

### Running Vina Executable

Source: https://autodock-vina.readthedocs.io/en/latest/installation.html

Execute the Vina program with the --help flag to see available options. Replace placeholders with your specific version and OS details.

```bash
./vina_<version number>_<OS name>_<architecture> --help

```

--------------------------------

### Installing Vina and Dependencies with Conda

Source: https://autodock-vina.readthedocs.io/en/latest/installation.html

Install NumPy, SWIG, Boost, and other necessary packages for Vina within a Conda environment. This command installs core dependencies and then uses pip for the Vina package itself.

```bash
conda install -c conda-forge numpy swig boost-cpp libboost sphinx sphinx_rtd_theme
pip install vina

```

--------------------------------

### Running Pre-compiled Vina Executable

Source: https://autodock-vina.readthedocs.io/en/latest/_sources/installation.rst.txt

Use this command to view the help message for a pre-compiled Vina executable. Ensure you replace placeholders with your specific version and system details.

```bash
./vina_<version number>_<OS name>_<architecture> --help
```

--------------------------------

### Install Meeko and ProDy in a Conda environment

Source: https://autodock-vina.readthedocs.io/en/latest/_sources/docking_requirements.rst.txt

Installs Meeko and ProDy within a Conda environment named 'vina'. It also sets Python to version 3.10 for ProDy interoperability and installs other dependencies.

```bash
conda activate vina
conda install python=3.10    # for ProDy interoperability
conda install -c conda-forge numpy scipy rdkit vina meeko gemmi autogrid
pip install prody
```

--------------------------------

### Batch Docking with Ligand Wildcard (Windows)

Source: https://autodock-vina.readthedocs.io/en/latest/_sources/docking_in_batch.rst.txt

This command is for Windows and uses a combination of `ls` and a loop (`%`) to expand a wildcard for ligand files, suitable for batch docking. Pay attention to path separators and command syntax.

```bash
$vina --receptor 1iep_receptor.pdbqt --batch $(ls .\ligands\*.pdbqt | % {$_.FullName}) --config config.txt --dir poses
```

--------------------------------

### Install AutoGrid4 using Conda

Source: https://autodock-vina.readthedocs.io/en/latest/_sources/docking_requirements.rst.txt

Installs AutoGrid4 using the conda-forge channel. Alternatively, refer to the AutoGrid repository's README for building from source.

```bash
$ conda install -c conda-forge autogrid
```

--------------------------------

### Prepare Ligand with Meeko

Source: https://autodock-vina.readthedocs.io/en/latest/_sources/docking_basic.rst.txt

Generates a PDBQT file for the ligand using the Meeko Python package. Ensure the input ligand file is in SDF format for best results.

```bash
mk_prepare_ligand.py -i 1iep_ligand.sdf -o 1iep_ligand.pdbqt
```

--------------------------------

### Batch Docking with Wildcard Expansion (Windows)

Source: https://autodock-vina.readthedocs.io/en/latest/docking_in_batch.html

On Windows, use a command that correctly handles wildcard expansion and path separators for batch docking. The output directory is specified using `--dir`.

```bash
vina --receptor 1iep_receptor.pdbqt --batch $(ls .\ligands\*.pdbqt | % {$_.FullName}) --config config.txt --dir poses
```

--------------------------------

### Prepare Multiple Ligands for Docking

Source: https://autodock-vina.readthedocs.io/en/latest/_sources/docking_multiple_ligands.rst.txt

Prepare two ligands by adding hydrogen atoms using scrub.py and then generating PDBQT files with mk_prepare_ligand.py.

```bash
$ scrub.py 5x72_ligand_p59.sdf -o 5x72_ligand_p59H.sdf 
$ mk_prepare_ligand.py -i 5x72_ligand_p59H.sdf -o 5x72_ligand_p59.pdbqt
$ scrub.py 5x72_ligand_p69.sdf -o 5x72_ligand_p69H.sdf 
$ mk_prepare_ligand.py -i 5x72_ligand_p69H.sdf -o 5x72_ligand_p69.pdbqt
```

--------------------------------

### Batch Docking with Multiple Ligand Files (Linux/macOS)

Source: https://autodock-vina.readthedocs.io/en/latest/_sources/docking_in_batch.rst.txt

Use this command to dock multiple specified ligand files against a single receptor. The `--batch` option can be repeated for each ligand file.

```bash
$vina --receptor 1iep_receptor.pdbqt --batch ligands/1iep_ligand_1.pdbqt --batch ligands/1iep_ligand_2.pdbqt --batch ligands/1iep_ligand_3.pdbqt --config config.txt --dir poses
```

--------------------------------

### MapWater Script Output

Source: https://autodock-vina.readthedocs.io/en/latest/_sources/docking_hydrated.rst.txt

Example output from the mapwater.py script, showing the generation of the water affinity map.

```console
ADD PWD AND FILE SUMMARY
receptor :  1uw6_receptor.pdbqt
    OA map -> 1uw6_receptor.OA.map
    HD map -> 1uw6_receptor.HD.map
=> Water map weight : DEFAULT [ 0.60 ]

MapWater generator
=====================
mode      :  BEST
weight    :   0.6
HD_weight :   1.0
OA_weight :   1.0
entropy   :   -0.2

        Output info  
--------------------
filename  : 1uw6_receptor.W.map
OA points : 91.66%
HD points : 8.34%

lowest  map value : -0.98
highest map value : -0.01
```

--------------------------------

### Batch Docking with Wildcard Expansion (Linux/macOS)

Source: https://autodock-vina.readthedocs.io/en/latest/docking_in_batch.html

Utilize shell wildcard expansion with the `--batch` option to include all ligands matching a pattern. The output directory must be specified.

```bash
vina --receptor 1iep_receptor.pdbqt --batch ligands/1iep_ligand_*.pdbqt --config config.txt --dir poses
```

--------------------------------

### Vina Forcefield Docking Output

Source: https://autodock-vina.readthedocs.io/en/latest/docking_basic.html

Example output when using the Vina forcefield with exhaustiveness set to 32. The best score is expected to be around -13 kcal/mol.

```text
Scoring function : vina
Rigid receptor: 1iep_receptor.pdbqt
Ligand: 1iep_ligand.pdbqt
Grid center: X 15.19 Y 53.903 Z 16.917
Grid size  : X 20 Y 20 Z 20
Grid space : 0.375
Exhaustiveness: 32
CPU: 0
Verbosity: 1

Computing Vina grid ... done.
Performing docking (random seed: -1622165383) ...
0%   10   20   30   40   50   60   70   80   90   100%
|----|----|----|----|----|----|----|----|----|----|
***************************************************

mode |   affinity | dist from best mode
    | (kcal/mol) | rmsd l.b.| rmsd u.b.
-----+------------+----------+----------
1       -13.23          0          0
2       -11.29     0.9857      1.681
3       -11.28      3.044      12.41
4       -11.15      3.813      12.24
5       -9.746      3.313      12.36
6       -9.132      1.736      13.47
7       -9.079      2.559      12.78
8       -8.931      3.951      12.69
9       -8.762      3.541      12.21


```

--------------------------------

### zinc_pseudo.py Output Example

Source: https://autodock-vina.readthedocs.io/en/latest/docking_zinc.html

This message confirms that the `zinc_pseudo.py` script successfully added one tetrahedral zinc pseudo atom (TZ) to the receptor PDBQT file.

```text
Wrote 1 TZ atoms on protein_tz.pdbqt.

```

--------------------------------

### AutoDock Vina Output with AD4 Scoring

Source: https://autodock-vina.readthedocs.io/en/latest/_sources/docking_multiple_ligands.rst.txt

Example output from AutoDock Vina when using the AD4 scoring function. It lists modes, binding affinities, and RMSD values.

```console
Scoring function : ad4
Ligands:
- 5x72_ligand_p59.pdbqt
- 5x72_ligand_p69.pdbqt
Exhaustiveness: 32
CPU: 0
Verbosity: 1

Reading AD4.2 maps ... done.
Performing docking (random seed: -1370364650) ... 
0%   10   20   30   40   50   60   70   80   90   100%
|----|----|----|----|----|----|----|----|----|----|
***************************************************

mode |   affinity | dist from best mode
    | (kcal/mol) | rmsd l.b.| rmsd u.b.
-----+------------+----------+----------
1       -17.67          0          0
2       -17.61      1.124      3.731
3       -17.45      1.837      3.718
4       -17.41      1.981      9.343
5       -17.17      1.242      3.802
6       -17.17      1.436      9.123
7       -17.11      1.478       5.26
8        -17.1       1.62      8.954
9          -17      1.669       9.66
```

--------------------------------

### Adjusting Hydrogen Bond Weight in Vina

Source: https://autodock-vina.readthedocs.io/en/latest/_sources/faq.rst.txt

You can modify the weights of scoring function terms, such as hydrogen bonds, via the command line. This example doubles the strength of all hydrogen bonds.

```bash
vina --weight_hydrogen -1.2 ...
```

--------------------------------

### Prepare Receptor with Meeko

Source: https://autodock-vina.readthedocs.io/en/latest/_sources/docking_basic.rst.txt

Generates a PDBQT file for the receptor, including polar hydrogens and partial charges. It also creates configuration files for docking and visualization.

```bash
mk_prepare_receptor.py -i 1iep_receptorH.pdb -o 1iep_receptor -p -v \
--box_size 20 20 20 --box_center 15.190 53.903 16.917
```

--------------------------------

### Compiling Vina Binary from Source

Source: https://autodock-vina.readthedocs.io/en/latest/_sources/installation.rst.txt

Compile the Vina executable from the source code. You may need to adjust the Makefile to specify the Boost library path.

```bash
$ cd AutoDock-Vina/build/linux/release
$ make
```

--------------------------------

### AutoDock4 Forcefield Docking Results Output

Source: https://autodock-vina.readthedocs.io/en/latest/docking_multiple_ligands.html

Example output from AutoDock Vina using the AutoDock4 scoring function. It shows predicted binding affinities and distances from the best mode for multiple poses.

```text
Scoring function : ad4
Ligands:
- 5x72_ligand_p59.pdbqt
- 5x72_ligand_p69.pdbqt
Exhaustiveness: 32
CPU: 0
Verbosity: 1

Reading AD4.2 maps ... done.
Performing docking (random seed: -1370364650) ...
0%   10   20   30   40   50   60   70   80   90   100%
|----|----|----|----|----|----|----|----|----|----|
***************************************************

mode |   affinity | dist from best mode
    | (kcal/mol) | rmsd l.b.| rmsd u.b.
-----+------------+----------+----------
1       -17.67          0          0
2       -17.61      1.124      3.731
3       -17.45      1.837      3.718
4       -17.41      1.981      9.343
5       -17.17      1.242      3.802
6       -17.17      1.436      9.123
7       -17.11      1.478       5.26
8        -17.0      1.62      8.954
9          -17      1.669       9.66

```

--------------------------------

### Prepare Receptor for Multiple Ligand Docking

Source: https://autodock-vina.readthedocs.io/en/latest/docking_multiple_ligands.html

Use the Meeko script to prepare the receptor PDBQT file and generate the Vina box configuration file. This command includes options for specifying box center, size, and handling alternate locations.

```bash
$ mk_prepare_receptor.py -i 5x72_receptorH.pdb -o 5x72_receptor -p -v \
--box_center -15.000 15.000 129.000 --box_size 30 24 24 \
--default_altloc A -a

```

--------------------------------

### Initializing the Vina Object

Source: https://autodock-vina.readthedocs.io/en/latest/_sources/docking_python.rst.txt

Creates an instance of the Vina class, specifying the forcefield to be used (e.g., 'vina', 'ad4', 'vinardo'). You can also configure the number of CPUs to use; 'cpu=0' defaults to all available CPUs.

```python
v = Vina(sf_name='vina')
```

--------------------------------

### Vina Docking Simulation Output

Source: https://autodock-vina.readthedocs.io/en/latest/docking_hydrated.html

Example output from a Vina docking simulation, showing scoring function details, ligand information, and a table of docking modes with their affinities and root-mean-square deviations (RMSD).

```text
Scoring function : ad4
Ligand: 1uw6_ligand.pdbqt
Exhaustiveness: 32
CPU: 0
Verbosity: 1

Reading AD4.2 maps ... done.
Performing docking (random seed: 1952347903) ...
0%   10   20   30   40   50   60   70   80   90   100%
|----|----|----|----|----|----|----|----|----|----|
***************************************************

mode |   affinity | dist from best mode
    | (kcal/mol) | rmsd l.b.| rmsd u.b.
-----+------------+----------+----------
1       -8.261          0          0
2       -7.673      1.124      1.239
3       -7.489      2.051       2.49
4       -7.225      2.441      3.621
5       -7.211      1.905      2.479
6       -7.065      2.469       5.79
7       -6.978      3.059      5.719
8       -6.968      2.339      3.029
9       -6.931      3.448      5.773


```

--------------------------------

### Prepare Receptor and Generate GPF File

Source: https://autodock-vina.readthedocs.io/en/latest/docking_flexible.html

Use mk_prepare_receptor.py to prepare the receptor and generate a GPF file for affinity map calculations. Specify box size, center, and atom types.

```bash
$ mk_prepare_receptor.py -i 1fpu_receptorH.pdb -o 1fpu_receptor -p -v -g \
--box_size 20 20 20 --box_center 15.190 53.903 16.917 \
-f A:315 -a

```

--------------------------------

### AutoDock4 Forcefield Docking Results

Source: https://autodock-vina.readthedocs.io/en/latest/_sources/docking_flexible.rst.txt

Example output from AutoDock Vina when using the AutoDock4 forcefield. It shows the scoring function, input files, and a table of docking modes with affinity and RMSD values.

```console
Scoring function : ad4
Flex receptor: 1fpu_receptor_flex.pdbqt
Ligand: 1iep_ligand.pdbqt
Exhaustiveness: 32
CPU: 0
Verbosity: 1

Reading AD4.2 maps ... done.
Performing docking (random seed: 711073774) ... 
0%   10   20   30   40   50   60   70   80   90   100%
|----|----|----|----|----|----|----|----|----|----|
***************************************************

mode |   affinity | dist from best mode
    | (kcal/mol) | rmsd l.b.| rmsd u.b.
-----+------------+----------+----------
1        -14.2          0          0
2          -14      1.163      1.777
3        -13.4      1.182      1.616
4       -11.92      1.521       2.19
5       -11.76      1.963      3.295
6       -11.68      2.872       10.9
7       -11.13      3.933      10.75
8       -10.99      3.702      11.82
9       -10.72       2.08      11.06
```

--------------------------------

### Vina Forcefield Docking Results

Source: https://autodock-vina.readthedocs.io/en/latest/_sources/docking_flexible.rst.txt

Example output from AutoDock Vina when using the Vina forcefield. It includes details about the receptor, ligand, grid parameters, and a table of docking modes with affinity and RMSD values.

```console
Scoring function :vina
Rigid receptor: 1fpu_receptor_rigid.pdbqt
Flex receptor: 1fpu_receptor_flex.pdbqt
Ligand: 1iep_ligand.pdbqt
Grid center: X 15.19 Y 53.903 Z 16.917
Grid size  : X 20 Y 20 Z 20
Grid space : 0.375
Exhaustiveness: 32
CPU: 0
Verbosity: 1

Computing Vina grid ... done.
Performing docking (random seed: 1431646130) ... 
0%   10   20   30   40   50   60   70   80   90   100%
|----|----|----|----|----|----|----|----|----|----|
***************************************************

mode |   affinity | dist from best mode
    | (kcal/mol) | rmsd l.b.| rmsd u.b.
-----+------------+----------+----------
1       -11.63          0          0
2       -10.57      3.242      12.12
3        -10.3      3.974       11.9
4       -9.906      3.903      11.97
5       -9.895      2.609      12.28
6       -9.854      1.958      13.07
7       -8.849      2.059      12.19
8       -8.758      3.259      12.12
9       -8.543      3.981      12.35
```

--------------------------------

### AutoDock Forcefield Docking Output

Source: https://autodock-vina.readthedocs.io/en/latest/docking_basic.html

Example output when using the AutoDock forcefield with exhaustiveness set to 32. The predicted free energy of binding is expected to be around -14 kcal/mol for poses similar to the crystallographic pose.

```text
Scoring function : ad4
Ligand: 1iep_ligand.pdbqt
Exhaustiveness: 32
CPU: 0
Verbosity: 1

Reading AD4.2 maps ... done.
Performing docking (random seed: 1045208650) ...
0%   10   20   30   40   50   60   70   80   90   100%
|----|----|----|----|----|----|----|----|----|----|
***************************************************

mode |   affinity | dist from best mode
    | (kcal/mol) | rmsd l.b.| rmsd u.b.
-----+------------+----------+----------
1       -14.72          0          0
2       -14.63      0.862      1.051
3       -13.12      1.152      1.877
4        -11.7      4.989      11.38
5       -11.44      3.619      11.51
6       -11.39       1.36      2.222
7       -11.21      3.773      12.06
8       -10.71      2.043      13.49
9       -10.41      1.748      2.955


```

--------------------------------

### Run Docking with Vina Forcefield and Configuration File

Source: https://autodock-vina.readthedocs.io/en/latest/docking_multiple_ligands.html

Execute docking using the Vina forcefield, referencing a configuration file for grid box parameters. Vina computes affinity maps internally.

```bash
$vina --receptor 5x72_receptor.pdbqt --ligand 5x72_ligand_p59.pdbqt 5x72_ligand_p69.pdbqt \
       --config 5x72_receptor.box.txt \
       --exhaustiveness=32 --out 5x72_ligand_vina_out.pdbqt

```

--------------------------------

### Prepare Ligand for Docking

Source: https://autodock-vina.readthedocs.io/en/latest/docking_basic.html

Use the `mk_prepare_ligand.py` script to convert a ligand SDF file into a PDBQT format, which is suitable for docking.

```bash
$ mk_prepare_ligand.py -i 1iep_ligand.sdf -o 1iep_ligand.pdbqt

```

--------------------------------

### Vina Forcefield Docking Results Output

Source: https://autodock-vina.readthedocs.io/en/latest/docking_multiple_ligands.html

Example output from AutoDock Vina using the Vina scoring function. It displays binding affinities and distances from the best mode, similar to the AD4 output but with Vina's internal scoring.

```text
Scoring function :vina
Rigid receptor: 5x72_receptor.pdbqt
Ligands:
- 5x72_ligand_p59.pdbqt
- 5x72_ligand_p69.pdbqt
Grid center: X -15 Y 15 Z 129
Grid size  : X 30 Y 24 Z 24
Grid space : 0.375
Exhaustiveness: 32
CPU: 0
Verbosity: 1

Computing Vina grid ... done.
Performing docking (random seed: -1632509975) ...
0%   10   20   30   40   50   60   70   80   90   100%
|----|----|----|----|----|----|----|----|----|----|
***************************************************

mode |   affinity | dist from best mode
    | (kcal/mol) | rmsd l.b.| rmsd u.b.
-----+------------+----------+----------
1       -19.04          0          0
2       -18.33       1.22       3.81
3       -17.27      1.247      3.007
4       -17.22      1.432      3.286
5       -16.45      1.099      3.717
6       -16.35        1.7      4.839
7       -16.24      1.335      5.195
8          -16      2.332      9.449
9       -15.29      7.079       13.5

```

--------------------------------

### Prepare Receptor with Meeko Script

Source: https://autodock-vina.readthedocs.io/en/latest/docking_basic.html

Use the mk_prepare_receptor.py script to generate a PDBQT file for the receptor, including polar hydrogens and partial charges. This script also generates configuration files for docking.

```bash
$ mk_prepare_receptor.py -i 1iep_receptorH.pdb -o 1iep_receptor -p -v \
--box_size 20 20 20 --box_center 15.190 53.903 16.917

```

--------------------------------

### Run Vina with Flexible Side Chains

Source: https://autodock-vina.readthedocs.io/en/latest/_sources/faq.rst.txt

Use this command to perform docking when the receptor has flexible side chains. Ensure you have correctly prepared the rigid and flexible parts of the receptor and the ligand PDBQT files.

```bash
vina --config conf --receptor rigid.pdbqt --flex side_chains.pdbqt --ligand ligand.pdbqt
```

--------------------------------

### AutoDock Vina Output Summary

Source: https://autodock-vina.readthedocs.io/en/latest/_sources/docking_zinc.rst.txt

This console output shows a summary of the Vina run parameters and settings.

```console
Scoring function : ad4
Ligand: 1s63_ligand.pdbqt
Exhaustiveness: 32
CPU: 0
Verbosity: 1
```

--------------------------------

### Prepare Flexible Receptor with Meeko

Source: https://autodock-vina.readthedocs.io/en/latest/docking_flexible.html

Use the Meeko script to prepare a receptor for flexible docking, specifying flexible side chains and box parameters. This generates separate PDBQT files for the rigid and flexible parts of the receptor.

```bash
mk_prepare_receptor.py -i 1fpu_receptorH.pdb -o 1fpu_receptor -p -v \
--box_size 20 20 20 --box_center 15.190 53.903 16.917 \
-f A:315 -a

```

--------------------------------

### Prepare Receptor and Generate GPF File

Source: https://autodock-vina.readthedocs.io/en/latest/docking_hydrated.html

Prepare the receptor PDB file and generate a GPF (Grid Parameter File) for affinity map calculation. The -g option is crucial for creating the GPF file.

```bash
$ mk_prepare_receptor.py -i 1uw6_receptorH.pdb -o 1uw6_receptor -p -g \
--box_center 83.640 69.684 -10.124 --box_size 15 15 15
```

--------------------------------

### Prepare Receptor and Add Zinc Pseudo Atoms

Source: https://autodock-vina.readthedocs.io/en/latest/docking_zinc.html

Use these commands to prepare the receptor PDB file and add zinc pseudo atoms. The first command generates the PDBQT file, and the second adds the tetrahedral zinc pseudo atoms.

```bash
$ mk_prepare_receptor.py -i proteinH.pdb -o protein -p
$ pythonsh <script_directory>/zinc_pseudo.py -r protein.pdbqt -o protein_tz.pdbqt

```

--------------------------------

### Creating and Activating a Conda Environment

Source: https://autodock-vina.readthedocs.io/en/latest/_sources/installation.rst.txt

Set up a dedicated Conda environment for AutoDock Vina and activate it. This ensures isolated dependencies for the project.

```bash
$ conda create -n vina python=3
$ conda activate vina
$ conda config --env --add channels conda-forge
```

--------------------------------

### Prepare Receptor for Multiple Ligand Docking

Source: https://autodock-vina.readthedocs.io/en/latest/_sources/docking_multiple_ligands.rst.txt

Use mk_prepare_receptor.py to create PDBQT and vina box TXT files for the receptor. The -a option ignores partially resolved residues.

```bash
$ mk_prepare_receptor.py -i 5x72_receptorH.pdb -o 5x72_receptor -p -v \
    --box_center -15.000 15.000 129.000 --box_size 30 24 24 \
    --default_altloc A -a
```

--------------------------------

### Initializing the Vina Object

Source: https://autodock-vina.readthedocs.io/en/latest/docking_python.html

Creates a Vina object, specifying the forcefield to be used (e.g., 'vina', 'ad4', 'vinardo'). You can also set the number of CPUs to use for docking.

```python
v = Vina(sf_name='vina')

```