LightningAutoDock Tools: Screening Using AutoDock4

The use of bioinformatic software has exploded in recent years. However, most tools still remain difficult to use and demand a lot of learning/practice. This highly limits the use of the otherwise accelerating world of bioinformatic tools. During our project we were faced with the demotivating entry barrier of the current molecular docking software. Our team needed a powerful and versatile tool to screen ligands onto a receptor protein - in our case the enzyme oxalate oxidase. The software that met our demands was AutoDock4 with its ability to analyse active sites containing metal ions. However, using this software is a nightmare. Besides the stability issues of the GUI of AutoDockTools (ADT), the core AutoDock4 software also lacks the ability to do multiple ligands screening in a single simulation session. Which became very important when we wanted to conduct a large scale docking simulation to check if our enzyme would react with anything unforeseen in the environment we wanted it to work in.

This flaw makes it a pain to analyse many ligands at once as one has to be seated by the computer when switching ligand. That requires users to perform docking simulations one by one, leading to long processing times.

To tackle this inefficiency of ADT and the entire docking process, from ligand file-structure download to result files, we developed a suite of Python-based tools to automate and streamline the entire process from ligand structure acquisition to docking and data analysis. Together these tools are called LightningAutoDock Tools (LAD Tools). However, beware that we didn’t design any protein preparation tool as there already exist many such tools - a great one being PDBFixer by OpenMM.

Anyways, our pipeline specifically optimises the workflow of molecular docking using AutoDock4 as the docking algorithm. This allows researchers to perform high-throughput ligand screening, which is vital for discovering the best candidates that bind to the protein of interest. The software was designed with errors handling in mind, as we experienced the frustration ourselves, when trying to dock through the AutoDockTools GUI. We fixed common issues like cmd prompt script pausing, missing grid maps, and parallelisation of CPU power. To view the tools please check our gitlab page.

In the following all four LAD Tools will be presented.

LightningScreen: Sourcing Ligand Structure Files for Screening

LightningScreen simplifies the process of obtaining ligand structures for docking simulations by automating the download of SDF files from databases like PubChem and ChemSpider. It uses a simple TXT file as input, which contains a list of the chemical compounds you need. The software fetches the relevant SDF structure files, ensuring that users can quickly gather all necessary ligand data without manual downloading and web searching. The python script also has a build in wiki search function, that will webscrape wikipedia.com for the compound, if the user types a chemical name that PubChem Explore doesn’t recognize.

How It Works:

• Users create a `screening_list.txt` file containing the names of the desired compounds.
• LightningScreen uses Python modules such as PubChemPy and RDKit to interface with public chemical databases.
• Once the list is provided, the program connects to the databases and downloads the SDF files for each compound in the list and outputs a download-folder.

Key Features:

• Automated compound retrieval: No need to manually search and download files from databases.
• Multi-format compatibility: While the default output is SDF, the script can be adapted to handle other formats like MOL2.
• Efficient data processing: Handles multiple ligands at once, saving time.
• Generates a log file with IUPAC names and web links for the compound in the database.

How to Use:

1. Install the necessary Python libraries: `pip install pubchempy rdkit wikipedia-api`.
2. Place your `screening_list.txt` file in the working directory.
3. Run the script with the command `python3 lightningScreen.py` in the terminal.
4. The downloaded SDF files will be saved in your workspace folder, ready for conversion.

This tool greatly accelerates the process of preparing ligands for docking, saving valuable time in the pre-docking phase.

LightningBabel: Preparing Ligand Molecules

LightningBabel automates the preparation of ligand molecules for docking simulations by converting the downloaded SDF files to the PDBQT format required by AutoDock4. It adds Gasteiger charges, ensures torsions are correctly assigned, and attaches polar hydrogens, which are essential for proper docking interactions. This tool leverages the OpenBabel library, streamlining what would otherwise be a time-consuming manual process in the OpenBabel GUI.

How It Works:

• After downloading the SDF files using LightningScreen, LightningBabel can convert them into PDBQT format.
• It assigns charges and sets torsion values using OpenBabel’s algorithms, optimising each molecule for docking.
• Users can batch process multiple ligands at once, making it ideal for high-throughput screening.

Key Features:

• Automated format conversion: Converts SDF (default), MOL2, or other common ligand formats to PDBQT.
• Gasteiger charge assignment: Ensures that the ligand molecules have proper charges for docking.
• Batch processing: Prepares multiple ligands in one run, significantly reducing manual intervention.

How to Use:

1. Install OpenBabel by running `pip install openbabel-wheel` (for Python3).
2. Create a folder named `sdf_ligands` and place your ligand files inside it. LightningScreen will generate this folder if you use that!
3. Run the script using the command `python lightningbabel3.py` for newest Python 3 (or `python2 lightningbabel.py` for Python 2).
4. The converted PDBQT files will be saved in the same directory in the folder “ligand_pdbqt”, ready for docking.

By automating the preparation of ligands, LightningBabel reduces user errors and speeds up the preparation of ligands for docking simulations.

LightningAutoDock: Automated Docking Using AutoDock4

This is the core of all the LAD Tools which took weeks to develop and has been the primary focus of our drylab work. LightningAutoDock automates the docking of multiple ligands using AutoDock4, with parallelization support to take advantage of modern multi-core systems. It allows users to dock hundreds of ligands on a target receptor while managing all setup files, grid maps, and handling common errors like missing files or freezing command prompts. This significantly reduces the time needed for large-scale docking simulations.

How It Works:

• LightningAutoDock reads “receptor.pdbqt” and ligand files, prepares the necessary docking files, and runs AutoGrid4 and AutoDock4 automatically.
• The program enables parallel processing, allowing multiple ligands to be docked simultaneously, maximising compute resource efficiency.
• It handles errors like missing grid maps or file inconsistencies, which can otherwise halt a docking process.

Key Features:

• Parallel docking: Utilises multiple CPU cores to run multiple dockings in parallel.
• Automated setup: Automatically configures all required files and parameters for AutoDock4.
• Error handling: Avoids common issues like script freezing or missing grid maps.
• Cmd prompt activity: Ensures the terminal remains active during long docking runs, preventing pauses or freezes.

How to Use:

1. Install AutoDock4 and ensure MGLTools (version 1.5.7) is installed with Python 2.7.11.
2. Prepare your ligand and receptor files (PDBQT format) in the working directory.
3. Set up your workspace following the guide in the installation instructions.
4. Run the script using `python lightningautodock.py` from your workspace folder.
5. The docking simulations will begin and run in parallel based on the number of cores specified.

This software is ideal for users conducting large-scale screenings (or just single ligand files), as it automates both the setup and execution of the docking process, significantly reducing the workload.

LightningViewer: Sorting Data Results from Docking Simulations

LightningViewer makes it easy to analyse the results from docking simulations from AutoDock4 by filtering ligand conformations based on binding affinity in kcal/mol. The software extracts relevant docking data from DLG files (the output file of AutoDock4), helping users quickly identify the top binding ligands for their receptor of interest. It allows for customised thresholds to filter out weak interactions and focuses on high-affinity results.

How It Works:

• LightningViewer reads DLG files from AutoDock4 and extracts ligand conformations based on a user-defined binding energy threshold.
• It creates an output folder with PDBQT files for only those conformations that meet the threshold.
• This enables users to focus only on the most promising ligands, streamlining the post-docking analysis process.

Key Features:

• Binding affinity filtering: Extracts conformations based on user-defined energy thresholds (e.g., -8 kcal/mol). Or for example top 10 strongest ligand interactions
• Automatic file sorting: Saves qualifying conformations in a dedicated folder for easy access.
• Batch processing: Reads and processes multiple DLG files at once, making it suitable for high-throughput screening.

How to Use:

1. Place your DLG files in the script directory.
2. Run the script using `python lightningviewer.py` from the command line.
3. Enter your desired binding affinity threshold when prompted (e.g., -8.0 kcal/mol) or if you need for example the top 20 ligand interactions (either in each ligand result file or for the entire number of the ligand files).
4. The filtered PDBQT files will be saved in a `filtered_results_BE-< threshold >` folder or ‘top_10_results (if you choose 10)’.

This tool helps users sift through vast amounts of docking data to quickly identify the most promising ligand candidates, making post-docking analysis both faster and more focused.

These tools collectively form a streamlined pipeline for ligand screening, from data acquisition to docking and result analysis, making the process significantly faster and more reliable than traditional methods.

Our Visions in Drylab

Our hope is to help other bioinformatic students and researchers harness the power of AutoDock4 docking simulations and the tools related to docking. Our values in the drylab have been centered around accessibility, transparency, and collaboration. We believe in the importance of using open-source and free software, as these tools are available to everyone and not restricted behind expensive licenses. By advocating for the use of such software, we aim to create an environment where research can be shared, replicated, and built upon by a global community without financial barriers. This aligns with our commitment to promoting innovation and inclusivity in the scientific field of bioinfomatics.

Conclusion

In conclusion, the development of the LightningAutoDock (LAD) Tools represents a significant advancement within molecular docking. We have addressed the inefficiencies and frustrations associated with existing tools like AutoDock4, and created a suite of software solutions that streamline the entire ligand screening process—from data acquisition to docking simulations and result analysis. All to make the process of docking multiple ligands much easier, faster and simpler.

The introduction of LightningScreen, LightningBabel, LightningAutoDock, and LightningViewer has drastically simplified tasks such as ligand retrieval, file preparation, automated docking, and post-docking analysis. These tools enable high-throughput ligand screening, allowing researchers to perform large-scale simulations with minimal manual intervention and significantly reduced error rates. Moreover, the ability to handle parallel docking and automated error correction ensures that researchers can maximize computational resources efficiently.

Our hope is that these tools will empower students, researchers, and professionals alike to harness the full potential of molecular docking simulations, without the steep learning curve and time-consuming processes we faced. By making AutoDock4 more accessible and versatile, we aim to empower more people to use docking. We invite the research community to explore our tools, which are freely available on our GitLab page, and to contribute to further improvements as we continue to develop this platform.