GNINA.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/pablo-arantes/Cloud-Bind/blob/main/GNINA.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pj2BWZxUDbEE"
      },
      "source": [
        "# **Hi there!**\n",
        "\n",
        "This is a Jupyter notebook for running molecular docking calculations with deep learning using Gnina docking software, which utilizes an ensemble of convolutional neural networks as a scoring function.\n",
        "\n",
        "The main goal of this notebook is to demonstrate how to harness the power of cloud-computing to perform drug binding structure prediction in a cheap and yet feasible fashion.\n",
        "\n",
        "---\n",
        "\n",
        " **This notebook is NOT a standard protocol for docking calculations and MD simulations!** It is just simple docking pipeline illustrating each step of a docking and MD protocol.\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "**Bugs**\n",
        "- If you encounter any bugs, please report the issue to https://github.com/pablo-arantes/Cloud-Bind/issues\n",
        "\n",
        "**Acknowledgments**\n",
        "- We would like to thank the [GNINA](https://github.com/gnina/gnina) team for doing an excellent job open sourcing the software.\n",
        "- We would like to thank the [Roitberg](https://roitberg.chem.ufl.edu/) team for developing the fantastic [TorchANI](https://github.com/aiqm/torchani).\n",
        "- We would like to thank [@ruiz_moreno_aj](https://twitter.com/ruiz_moreno_aj) for his work on [Jupyter Dock](https://github.com/AngelRuizMoreno/Jupyter_Dock)\n",
        "- We would like to thank the ChemosimLab ([@ChemosimLab](https://twitter.com/ChemosimLab)) team for their incredible [ProLIF](https://prolif.readthedocs.io/en/latest/index.html#) (Protein-Ligand Interaction Fingerprints) tool.\n",
        "- We would like to thank the [OpenBPMD](https://github.com/Gervasiolab/OpenBPMD) team for their open source implementation of binding pose metadynamics (BPMD).\n",
        "- Also, credit to [David Koes](https://github.com/dkoes) for his awesome [py3Dmol](https://3dmol.csb.pitt.edu/) plugin.\n",
        "- Finally, we would like to thank [Making it rain](https://github.com/pablo-arantes/making-it-rain) team, **Pablo R. Arantes** ([@pablitoarantes](https://twitter.com/pablitoarantes)), **Marcelo D. Polêto** ([@mdpoleto](https://twitter.com/mdpoleto)), **Conrado Pedebos** ([@ConradoPedebos](https://twitter.com/ConradoPedebos)) and **Rodrigo Ligabue-Braun** ([@ligabue_braun](https://twitter.com/ligabue_braun)), for their amazing work.\n",
        "- A Cloud-Bind by **Pablo R. Arantes** ([@pablitoarantes](https://twitter.com/pablitoarantes))\n",
        "\n",
        "- For related notebooks see: [Cloud-Bind](https://github.com/pablo-arantes/Cloud-Bind)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#@title **Install Conda Colab**\n",
        "#@markdown It will restart the kernel (session), don't worry.\n",
        "!pip install -q condacolab\n",
        "import condacolab\n",
        "condacolab.install()"
      ],
      "metadata": {
        "id": "k5xm80qcWGWd",
        "cellView": "form"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wH1oMiVUlxO_"
      },
      "source": [
        "#@title **Install dependencies**\n",
        "#@markdown It will take a few minutes, please, drink a coffee and wait. ;-)\n",
        "# install dependencies\n",
        "%%capture\n",
        "import sys\n",
        "import tarfile\n",
        "import os\n",
        "import subprocess\n",
        "import sys\n",
        "subprocess.run(\"rm -rf /usr/local/conda-meta/pinned\", shell=True)\n",
        "subprocess.run(\"pip -q install py3Dmol\", shell=True)\n",
        "subprocess.run(\"pip install git+https://github.com/pablo-arantes/biopandas\", shell=True)\n",
        "subprocess.run(\"pip install bio\", shell=True)\n",
        "subprocess.run(\"mamba install pytorch torchvision -c pytorch\", shell=True)\n",
        "subprocess.run(\"pip install torchani\", shell=True)\n",
        "subprocess.run(\"pip install ase\", shell=True)\n",
        "subprocess.run(\"mamba install -c conda-forge pdbfixer -y\", shell=True)\n",
        "subprocess.run(\"mamba install -c conda-forge parmed -y\", shell=True)\n",
        "subprocess.run(\"mamba install -c conda-forge openbabel -y\", shell=True)\n",
        "subprocess.run(\"mamba install -c conda-forge rdkit\", shell=True)\n",
        "subprocess.run(\"wget https://github.com/gnina/gnina/releases/download/v1.0.3/gnina\", shell=True)\n",
        "subprocess.run(\"chmod +x gnina\", shell=True)\n",
        "subprocess.run(\"wget https://github.com/rdk/p2rank/releases/download/2.4/p2rank_2.4.tar.gz\", shell=True)\n",
        "file = tarfile.open('p2rank_2.4.tar.gz')\n",
        "file.extractall('/content/')\n",
        "file.close()\n",
        "os.remove('p2rank_2.4.tar.gz')\n",
        "\n",
        "#load dependencies\n",
        "import parmed as pmd\n",
        "from biopandas.pdb import PandasPdb\n",
        "import urllib.request\n",
        "import numpy as np\n",
        "import py3Dmol\n",
        "import platform\n",
        "import scipy.cluster.hierarchy\n",
        "from scipy.spatial.distance import squareform\n",
        "import scipy.stats as stats\n",
        "import matplotlib.pyplot as plt\n",
        "import pandas as pd\n",
        "from scipy.interpolate import griddata\n",
        "import seaborn as sb\n",
        "from statistics import mean, stdev\n",
        "from matplotlib import colors\n",
        "from IPython.display import set_matplotlib_formats"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fDQnAKJLFxtt"
      },
      "source": [
        "## Using Google Drive to store simulation data\n",
        "\n",
        "Google Colab does not allow users to keep data on their computing nodes. However, we can use Google Drive to read, write, and store our simulations files. Therefore, we suggest to you to:\n",
        "\n",
        "1.   Create a folder in your own Google Drive and copy the necessary input files there.\n",
        "2.   Copy the path of your created directory. We will use it below."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Lm7Akepv_vl-",
        "cellView": "form"
      },
      "source": [
        "#@title ### **Import Google Drive**\n",
        "#@markdown Click in the \"Run\" buttom to make your Google Drive accessible.\n",
        "from google.colab import drive\n",
        "\n",
        "drive.mount('/content/drive', force_remount=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "form",
        "id": "n96Vyb3mMemN"
      },
      "source": [
        "#@title **Check if you correctly allocated GPU nodes**\n",
        "\n",
        "gpu_info = !nvidia-smi\n",
        "gpu_info = '\\n'.join(gpu_info)\n",
        "if gpu_info.find('failed') >= 0:\n",
        "  print('Select the Runtime > \"Change runtime type\" menu to enable a GPU accelerator, ')\n",
        "  print('and then re-execute this cell.')\n",
        "else:\n",
        "  print(gpu_info)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BZwl66HTGI7v"
      },
      "source": [
        "\n",
        "---\n",
        "# **Loading the necessary input files**\n",
        "\n",
        "At this point, we should have all libraries and dependencies installed.\n",
        "\n",
        "**Important**: Make sure the PDB file points to the correct structure.\n",
        "\n",
        "Below, you should provide the names of all input files and the pathway of your Google Drive folder containing them.\n",
        "\n",
        "**Please, don't use spaces in the files and folders names, i.e. MyDrive/protein_ligand and so on.**"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#@title **Please, provide the necessary input files below for receptor**:\n",
        "#@markdown **Important:** Run the cell to prepare your receptor and select your reference residue for the construction of an optimal box size for the docking calculations.\n",
        "from openmm.app.pdbfile import PDBFile\n",
        "\n",
        "import warnings\n",
        "warnings.filterwarnings('ignore')\n",
        "import os\n",
        "from Bio.PDB import PDBParser, PDBIO, Select\n",
        "from Bio.PDB import is_aa\n",
        "import pandas as pd\n",
        "from pdbfixer import PDBFixer\n",
        "\n",
        "Google_Drive_Path = '/content/' #@param {type:\"string\"}\n",
        "workDir = Google_Drive_Path\n",
        "\n",
        "workDir2 = os.path.join(workDir)\n",
        "workDir_check = os.path.exists(workDir2)\n",
        "if workDir_check == False:\n",
        "  os.mkdir(workDir2)\n",
        "else:\n",
        "  pass\n",
        "\n",
        "if os.path.exists(os.path.join(workDir, \"name_residues.txt\")):\n",
        "  os.remove(os.path.join(workDir, \"name_residues.txt\"))\n",
        "  os.remove(os.path.join(workDir,\"name_residues_receptor.txt\"))\n",
        "else:\n",
        "  pass\n",
        "\n",
        "temp = os.path.join(workDir, \"temp.pdb\")\n",
        "receptor = os.path.join(workDir, \"receptor.pdb\")\n",
        "ligand = os.path.join(workDir, \"ligand.sdf\")\n",
        "\n",
        "\n",
        "Query_PDB_ID = '3HTB' #@param {type:\"string\"}\n",
        "\n",
        "pdbfn = Query_PDB_ID + \".pdb\"\n",
        "url = 'https://files.rcsb.org/download/' + pdbfn\n",
        "outfnm = os.path.join(workDir, pdbfn)\n",
        "urllib.request.urlretrieve(url, outfnm)\n",
        "\n",
        "\n",
        "ppdb = PandasPdb().read_pdb(outfnm)\n",
        "ppdb.df['ATOM'] = ppdb.df['ATOM']\n",
        "ppdb.df['HETATM'] = ppdb.df['HETATM'][ppdb.df['HETATM']['residue_name'] != 'HOH']\n",
        "ppdb.to_pdb(path=temp, records=['ATOM', 'HETATM'], gz=False, append_newline=True)\n",
        "\n",
        "#prepare receptor\n",
        "ppdb = PandasPdb().read_pdb(outfnm)\n",
        "ppdb.df['ATOM'] = ppdb.df['ATOM']\n",
        "ppdb.df['HETATM'] = ppdb.df['HETATM'][ppdb.df['HETATM']['residue_name'] != 'HOH']\n",
        "ppdb.df['ATOM'] = ppdb.df['ATOM'][ppdb.df['ATOM']['atom_name'] != 'OXT']\n",
        "ppdb.df['ATOM']= ppdb.df['ATOM'][ppdb.df['ATOM']['element_symbol'] != 'H']\n",
        "ppdb.to_pdb(path=receptor, records=['ATOM', 'HETATM'], gz=False, append_newline=True)\n",
        "\n",
        "fixer = PDBFixer(filename=receptor)\n",
        "fixer.removeHeterogens()\n",
        "fixer.findMissingResidues()\n",
        "fixer.findMissingAtoms()\n",
        "fixer.addMissingAtoms()\n",
        "fixer.addMissingHydrogens(pH=7.4)\n",
        "PDBFile.writeFile(fixer.topology, fixer.positions, open(receptor, 'w'))\n",
        "\n",
        "\n",
        "path = '/content/'\n",
        "\n",
        "\n",
        "def is_het(residue):\n",
        "    res = residue.id[0]\n",
        "    return res != \" \" and res != \"W\"\n",
        "\n",
        "def aa(residue):\n",
        "    res = residue.id[0]\n",
        "    return res != \"W\"\n",
        "\n",
        "\n",
        "class ResidueSelect(Select):\n",
        "    def __init__(self, chain, residue):\n",
        "        self.chain = chain\n",
        "        self.residue = residue\n",
        "\n",
        "    def accept_chain(self, chain):\n",
        "        return chain.id == self.chain.id\n",
        "\n",
        "    def accept_residue(self, residue):\n",
        "        return residue == self.residue and aa(residue)\n",
        "\n",
        "def extract_ligands(path):\n",
        "    pdb = PDBParser().get_structure(temp, temp)\n",
        "    io = PDBIO()\n",
        "    io.set_structure(pdb)\n",
        "    i = 1\n",
        "    name_residues = []\n",
        "    for model in pdb:\n",
        "      for chain in model:\n",
        "        for residue in chain:\n",
        "          if not aa(residue):\n",
        "            continue\n",
        "          # print(f\"{chain[i].resname} {i}\")\n",
        "          name_residues.append(residue)\n",
        "          print((f\"saving {residue}\"), file=open(os.path.join(workDir, \"name_residues.txt\"), \"a\",))\n",
        "          i += 1\n",
        "\n",
        "extract_ligands(path)\n",
        "\n",
        "def extract_ligands2(path):\n",
        "    pdb = PDBParser().get_structure(receptor, receptor)\n",
        "    io = PDBIO()\n",
        "    io.set_structure(pdb)\n",
        "    i2 = 1\n",
        "    name_residues2 = []\n",
        "    for model in pdb:\n",
        "      for chain in model:\n",
        "        for residue in chain:\n",
        "          if not aa(residue):\n",
        "            continue\n",
        "          # print(f\"{chain[i].resname} {i}\")\n",
        "          name_residues2.append(residue)\n",
        "          print((f\"saving {residue}\"), file=open(os.path.join(workDir, \"name_residues_receptor.txt\"), \"a\",))\n",
        "          i2 += 1\n",
        "\n",
        "extract_ligands2(path)\n",
        "\n",
        "\n",
        "dataset = pd.read_csv(os.path.join(workDir, 'name_residues.txt'), delimiter = \" \", header=None)\n",
        "df = pd.DataFrame(dataset)\n",
        "df = df.iloc[:, [2]]\n",
        "new = df.to_numpy()\n",
        "\n",
        "dataset2 = pd.read_csv(os.path.join(workDir, 'name_residues_receptor.txt'), delimiter = \" \", header=None)\n",
        "df2 = pd.DataFrame(dataset2)\n",
        "df2 = df2.iloc[:, [2]]\n",
        "new2 = df2.to_numpy()\n",
        "\n",
        "b = 1\n",
        "res_number = []\n",
        "for j in new2:\n",
        "  res_number.append(b)\n",
        "  b += 1\n",
        "\n",
        "print(\"Residue\" + \" - \"  + \"Number\" )\n",
        "a = 1\n",
        "for j in new:\n",
        "  print(', '.join(j) + \" - \"  + str(a))\n",
        "  a += 1"
      ],
      "metadata": {
        "id": "NxmwlxdxlyiD",
        "cellView": "form"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@title **Predict ligand-binding pockets from your protein structure using P2Rank**:\n",
        "#@markdown **P2Rank** is a stand-alone command line program that predicts ligand-binding pockets from a protein structure. It achieves high prediction success rates without relying on an external software for computation of complex features or on a database of known protein-ligand templates.\n",
        "#@markdown P2Rank makes predictions by scoring and clustering points on the protein's solvent accessible surface. Ligandability score of individual points is determined by a machine learning based model trained on the dataset of known protein-ligand complexes. For more details see [here](https://github.com/rdk/p2rank).\n",
        "\n",
        "import subprocess\n",
        "import csv\n",
        "\n",
        "output_p2rank = os.path.join(workDir, \"output_p2rank\")\n",
        "p2rank = \"/content/p2rank_2.4/prank predict -f \" + str(receptor) + \" -o \" + str(output_p2rank)\n",
        "original_stdout = sys.stdout\n",
        "with open('p2rank.sh', 'w') as f:\n",
        "  sys.stdout = f\n",
        "  print(p2rank)\n",
        "  sys.stdout = original_stdout\n",
        "subprocess.run([\"chmod 700 p2rank.sh\"], shell=True)\n",
        "subprocess.run([\"./p2rank.sh\"], shell=True,)\n",
        "\n",
        "with open(os.path.join(workDir, \"output_p2rank/receptor.pdb_predictions.csv\"), 'r') as file:\n",
        "  csvreader = csv.reader(file)\n",
        "  residue = []\n",
        "  score = []\n",
        "  center_x = []\n",
        "  center_y = []\n",
        "  center_z = []\n",
        "  for row in csvreader:\n",
        "    residue.append(row[9:10])\n",
        "    score.append(row[2:3])\n",
        "    center_x.append(row[6:7])\n",
        "    center_y.append(row[7:8])\n",
        "    center_z.append(row[8:9])\n",
        "\n",
        "for i in range(1,len(residue)):\n",
        "  file = str((residue[i])[0]).split()\n",
        "  score_end = str((score[i])[0]).split()\n",
        "  center_x_end = str((center_x[i])[0]).split()\n",
        "  center_y_end = str((center_y[i])[0]).split()\n",
        "  center_z_end = str((center_z[i])[0]).split()\n",
        "  print(\"Pocket \" + str(i))\n",
        "  print(\"Score = \" + score_end[0])\n",
        "  final_residues = []\n",
        "  for i in range(0,len(file)):\n",
        "    test = file[i]\n",
        "    final_residues.append(int(test[2:]))\n",
        "  print(\"Selected Residues = \" + str(final_residues))\n",
        "  print(\"Center x = \"+ str(center_x_end[0]), \"Center y = \"+ str(center_y_end[0]), \"Center z = \"+ str(center_z_end[0]) + \"\\n\")"
      ],
      "metadata": {
        "cellView": "form",
        "id": "6zS9eKySxq13"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@title **Please, provide the pocket or residue number for the selection**:\n",
        "#@markdown **Important:** The selected pocket or residues will be used as a reference for the construction of an optimal box size for the ligand during the docking. If you want to select more than one residue, please, use comma to separte the numbers (i.e. 147,150,155,160). **Please, DO NOT USE SPACES BETWEEN THEM.**\n",
        "\n",
        "import re\n",
        "import csv\n",
        "\n",
        "if os.path.exists(os.path.join(workDir, \"name_residue.txt\")):\n",
        "  os.remove(os.path.join(workDir, \"name_residue.txt\"))\n",
        "else:\n",
        "  pass\n",
        "\n",
        "# Python code to convert string to list\n",
        "def Convert(string):\n",
        "\tli = list(string.split(\",\"))\n",
        "\treturn li\n",
        "\n",
        "def extract_ligands(path,residues):\n",
        "    pdb = PDBParser().get_structure(temp, temp)\n",
        "    io = PDBIO()\n",
        "    io.set_structure(pdb)\n",
        "    i = 1\n",
        "    name_residues = []\n",
        "    for model in pdb:\n",
        "      for chain in model:\n",
        "        for residue in chain:\n",
        "          if not aa(residue):\n",
        "            continue\n",
        "          if i == int(residues):\n",
        "            # print(residues)\n",
        "            print((f\"saving {residue}\"), file=open(os.path.join(workDir, \"name_residue.txt\"), \"a\",))\n",
        "            io.save(f\"res_{i}_certo.pdb\", ResidueSelect(chain, residue))\n",
        "          i += 1\n",
        "\n",
        "Selection = \"Residues\" #@param [\"Pocket\", \"Residues\"]\n",
        "\n",
        "number = '166' #@param {type:\"string\"}\n",
        "\n",
        "if Selection == \"Pocket\":\n",
        "  file = str((residue[int(number)])[0]).split()\n",
        "  score_end = str((score[int(number)])[0]).split()\n",
        "  center_x_end = str((center_x[int(number)])[0]).split()\n",
        "  center_y_end = str((center_y[int(number)])[0]).split()\n",
        "  center_z_end = str((center_z[int(number)])[0]).split()\n",
        "  center_x_gnina = float(center_x_end[0])\n",
        "  center_y_gnina = float(center_y_end[0])\n",
        "  center_z_gnina = float(center_z_end[0])\n",
        "  print(\"Pocket \" + str(number))\n",
        "  print(\"Score = \" + score_end[0])\n",
        "  print(\"Center x = \"+ str(center_x_end[0]), \"Center y = \"+ str(center_y_end[0]), \"Center z = \"+ str(center_z_end[0]) + \"\\n\")\n",
        "  final_residues = []\n",
        "  for i in range(0,len(file)):\n",
        "    test = file[i]\n",
        "    final_residues.append(int(test[2:]))\n",
        "  residues_num = final_residues\n",
        "else:\n",
        "  residues_num = Convert(number)\n",
        "\n",
        "filenames=[]\n",
        "for k in range(0, len(residues_num)):\n",
        "  extract_ligands(path, residues_num[k])\n",
        "  filenames.append(f\"res_{residues_num[k]}_certo.pdb\")\n",
        "\n",
        "\n",
        "with open('selection_merge.pdb', 'w') as outfile:\n",
        "    for fname in filenames:\n",
        "        with open(fname) as infile:\n",
        "            for line in infile:\n",
        "                outfile.write(line)\n",
        "\n",
        "# reading each line from original\n",
        "# text file\n",
        "file1 = open('/content/selection_merge.pdb', 'r')\n",
        "file2 = open('/content/selection_merge_end.pdb','w')\n",
        "\n",
        "for line in file1.readlines():\n",
        "\n",
        "    # reading all lines that begin\n",
        "    # with \"TextGenerator\"\n",
        "    x = re.findall(\"^END\", line)\n",
        "\n",
        "    if not x:\n",
        "        file2.write(line)\n",
        "\n",
        "# close and save the files\n",
        "file1.close()\n",
        "file2.close()\n",
        "\n",
        "dataset = pd.read_csv(os.path.join(workDir, \"name_residue.txt\"), delimiter = \" \", header=None)\n",
        "df = pd.DataFrame(dataset)\n",
        "df = df.iloc[:, [2]]\n",
        "new = df.to_numpy()\n",
        "\n",
        "print(\"Selected Residue\" + \" - \"  + \"Number\" )\n",
        "for j, i in zip(new, range(0, len(residues_num))):\n",
        "# for j in new:\n",
        "  print(', '.join(j) + \" - \"  + str(residues_num[i]))\n",
        "res_box = '/content/selection_merge_end.pdb'"
      ],
      "metadata": {
        "cellView": "form",
        "id": "8knPKMYiNcYE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@title **Receptor Visualization**:\n",
        "#@markdown Now the protein has been sanitized and the selection has been chosen, it would be recomended to visualize and check the protein (gray) and your selection (green).\n",
        "\n",
        "view = py3Dmol.view(js='https://3dmol.org/build/3Dmol.js',)\n",
        "view.removeAllModels()\n",
        "view.setViewStyle({'style':'outline','color':'black','width':0.1})\n",
        "\n",
        "view.addModel(open(receptor,'r').read(),format='pdb')\n",
        "Prot=view.getModel()\n",
        "Prot.setStyle({'cartoon':{'arrows':True, 'tubes':True, 'style':'oval', 'color':'white'}})\n",
        "view.addSurface(py3Dmol.VDW,{'opacity':0.6,'color':'white'})\n",
        "\n",
        "\n",
        "view.addModel(open(res_box,'r').read(),format='mol2')\n",
        "ref_m = view.getModel()\n",
        "ref_m.setStyle({},{'stick':{'colorscheme':'greenCarbon','radius':0.2}})\n",
        "\n",
        "view.zoomTo()\n",
        "view.show()"
      ],
      "metadata": {
        "cellView": "form",
        "id": "ak4T6zB-R-w4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@title **Please, provide the necessary input files for the ligand**:\n",
        "\n",
        "#@markdown Type the smiles or filename (PDB and MOL formats) of your molecule. **Ex: C=CC(=O)OC, molecule.pdb or molecule.mol**\n",
        "\n",
        "#@markdown Just remind you that if you want to use pdb or mol file, you should first upload the file here in Colab or in your Google Drive.\n",
        "\n",
        "#@markdown If you don't know the exactly smiles, please, check at https://pubchem.ncbi.nlm.nih.gov/\n",
        "\n",
        "from rdkit import Chem\n",
        "from rdkit.Chem import AllChem\n",
        "from rdkit.Chem import Draw\n",
        "from rdkit.Chem import rdMolTransforms\n",
        "from rdkit.Chem.Draw import rdMolDraw2D\n",
        "from rdkit.Chem import rdDepictor\n",
        "from IPython.display import SVG\n",
        "import ipywidgets as widgets\n",
        "import rdkit\n",
        "from rdkit.Chem.Draw import IPythonConsole\n",
        "AllChem.SetPreferCoordGen(True)\n",
        "from IPython.display import Image\n",
        "from openbabel import pybel\n",
        "import matplotlib.image as mpimg\n",
        "\n",
        "import os\n",
        "\n",
        "import py3Dmol\n",
        "\n",
        "\n",
        "Type = \"smiles\" #@param [\"smiles\", \"pdb\", \"mol\"]\n",
        "\n",
        "smiles_or_filename = 'CCCC1=CC=CC=C1O' #@param {type:\"string\"}\n",
        "\n",
        "if Type == \"smiles\":\n",
        "  Smiles = smiles_or_filename\n",
        "  smiles_fig = Chem.MolFromSmiles(Smiles)\n",
        "  hmol = Chem.AddHs(smiles_fig)\n",
        "  AllChem.EmbedMolecule(hmol)\n",
        "  hmol.GetConformer(0)\n",
        "  mp = AllChem.MMFFGetMoleculeProperties(hmol)\n",
        "  ff = AllChem.MMFFGetMoleculeForceField(hmol, mp)\n",
        "  # Optimize\n",
        "  AllChem.OptimizeMoleculeConfs(hmol, ff, numThreads=1, maxIters=1000)\n",
        "  AllChem.MolToMolFile(hmol, (os.path.join(workDir, \"ligand.mol\")))\n",
        "  AllChem.MolToPDBFile(hmol, (os.path.join(workDir, \"ligand.pdb\")))\n",
        "elif Type == \"pdb\":\n",
        "  pdb_name = os.path.join(workDir, smiles_or_filename)\n",
        "  mol= [m for m in pybel.readfile(filename=pdb_name, format='pdb')][0]\n",
        "  out=pybel.Outputfile(filename='mol.mol',format='mol',overwrite=True)\n",
        "  out.write(mol)\n",
        "  out.close()\n",
        "  mol = Chem.MolFromMolFile('mol.mol')\n",
        "  Smiles = Chem.MolToSmiles(mol)\n",
        "  smiles_fig = Chem.MolFromSmiles(Smiles)\n",
        "  hmol = Chem.AddHs(smiles_fig)\n",
        "  AllChem.EmbedMolecule(hmol)\n",
        "  hmol.GetConformer(0)\n",
        "  mp = AllChem.MMFFGetMoleculeProperties(hmol)\n",
        "  ff = AllChem.MMFFGetMoleculeForceField(hmol, mp)\n",
        "  # Optimize\n",
        "  AllChem.OptimizeMoleculeConfs(hmol, ff, numThreads=1, maxIters=1000)\n",
        "  AllChem.MolToMolFile(hmol, (os.path.join(workDir, \"ligand.mol\")))\n",
        "  AllChem.MolToPDBFile(hmol, (os.path.join(workDir, \"ligand.pdb\")))\n",
        "else:\n",
        "  mol_name = os.path.join(workDir, smiles_or_filename)\n",
        "  mol = Chem.MolFromMolFile(mol_name)\n",
        "  Smiles = Chem.MolToSmiles(mol)\n",
        "  smiles_fig = Chem.MolFromSmiles(Smiles)\n",
        "  hmol = Chem.AddHs(smiles_fig)\n",
        "  AllChem.EmbedMolecule(hmol)\n",
        "  hmol.GetConformer(0)\n",
        "  mp = AllChem.MMFFGetMoleculeProperties(hmol)\n",
        "  ff = AllChem.MMFFGetMoleculeForceField(hmol, mp)\n",
        "  # Optimize\n",
        "  AllChem.OptimizeMoleculeConfs(hmol, ff, numThreads=1, maxIters=1000)\n",
        "  AllChem.MolToMolFile(hmol, (os.path.join(workDir, \"ligand.mol\")))\n",
        "  AllChem.MolToPDBFile(hmol, (os.path.join(workDir, \"ligand.pdb\")))\n",
        "\n",
        "print(\"Smiles: \" + str(Smiles))\n",
        "smi = Draw.MolToFile(smiles_fig, size=(600, 600), filename=os.path.join(workDir,str(Smiles) + '.png'))\n",
        "img = mpimg.imread(os.path.join(workDir,str(Smiles) + '.png'))\n",
        "plt.figure(figsize = (8,8))\n",
        "imgplot = plt.imshow(img)\n",
        "plt.axis('off')\n",
        "plt.show()"
      ],
      "metadata": {
        "cellView": "form",
        "id": "KLwXCHI30fqz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from typing import List\n",
        "from ase import Atoms\n",
        "from ase.lattice.cubic import Diamond\n",
        "from ase.md.langevin import Langevin\n",
        "from ase.optimize import BFGS\n",
        "from ase import io\n",
        "from ase.io import read, write\n",
        "from ase import units\n",
        "from ase.constraints import ExternalForce, FixInternals\n",
        "import torch\n",
        "import torchani\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "from openbabel import pybel\n",
        "from torchani.units import HARTREE_TO_KCALMOL\n",
        "\n",
        "\n",
        "#@title **Ligand geometry optimization using TorchANI**:\n",
        "\n",
        "#@markdown Geometry optimization for the ligand 3D structure, using ANI-1x, ANI-1ccx or ANI-2x as the optimizing engine.\n",
        "\n",
        "#@markdown If you want to know more about **TorchANI**, please, check at https://aiqm.github.io/torchani/\n",
        "\n",
        "model_name = \"ANI-2x\" #@param [\"ANI-1x\", \"ANI-1ccx\", \"ANI-2x\"]\n",
        "\n",
        "#@markdown Convergence threshold for geometry optimization:\n",
        "\n",
        "opt_tol = 0.0001 #@param {type:\"slider\", min:0.0001, max:0.01, step:0.0001}\n",
        "\n",
        "\n",
        "\n",
        "# device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
        "device = torch.device('cpu')\n",
        "\n",
        "if model_name == \"ANI-2x\":\n",
        "  model = torchani.models.ANI2x(periodic_table_index=True).to(device)\n",
        "  calculator = torchani.models.ANI2x().ase()\n",
        "  print(\"Model = ANI2x\")\n",
        "elif model_name == \"ANI-1ccx\":\n",
        "  model = torchani.models.ANI1ccx(periodic_table_index=True).to(device)\n",
        "  calculator = torchani.models.ANI1ccx().ase()\n",
        "  print(\"Model = ANI1ccx\")\n",
        "elif model_name == \"ANI-1x\":\n",
        "  model = torchani.models.ANI1x(periodic_table_index=True).to(device)\n",
        "  calculator = torchani.models.ANI1x().ase()\n",
        "  print(\"Model = ANI1x\")\n",
        "else:\n",
        "  pass\n",
        "\n",
        "def mol2arr(mols, device=device):\n",
        "    coordinates = []\n",
        "    spices = []\n",
        "    for mol in mols:\n",
        "        pos = mol.GetConformer().GetPositions().tolist()\n",
        "        atomnums = [a.GetAtomicNum() for a in mol.GetAtoms()]\n",
        "        coordinates.append(pos)\n",
        "        spices.append(atomnums)\n",
        "    coordinates = torch.tensor(coordinates,\n",
        "                               requires_grad=True,\n",
        "                               device=device)\n",
        "    species = torch.tensor(spices, device=device)\n",
        "    return coordinates, species\n",
        "\n",
        "mol_deg = AllChem.MolFromMolFile ((os.path.join(workDir, \"ligand.mol\")), removeHs=False)\n",
        "mol = io.read(os.path.join(workDir, \"ligand.mol\"))\n",
        "coordinates, species = mol2arr([mol_deg], device)\n",
        "tensor1 = coordinates.detach().numpy()\n",
        "atoms = Atoms(mol, positions=tensor1[0])\n",
        "atoms.center(vacuum=3.0)\n",
        "atoms.set_calculator(calculator)\n",
        "print(\"Begin Geometry Optimization \")\n",
        "opt = BFGS(atoms)\n",
        "opt.run(fmax=opt_tol)\n",
        "# print()\n",
        "write((os.path.join(workDir, \"ligand_min.xyz\")), format=\"xyz\", images=atoms)\n",
        "\n",
        "atomic_symbols = []\n",
        "xyz_coordinates = []\n",
        "\n",
        "with open((os.path.join(workDir, \"ligand_min.xyz\")), \"r\") as file:\n",
        "  for line_number,line in enumerate(file):\n",
        "      if line_number == 0:\n",
        "          num_atoms = int(line)\n",
        "      elif line_number == 1:\n",
        "          comment = line # might have useful information\n",
        "      else:\n",
        "          atomic_symbol, x, y, z = line.split()\n",
        "          atomic_symbols.append(atomic_symbol)\n",
        "          xyz_coordinates.append([float(x),float(y),float(z)])\n",
        "\n",
        "from rdkit.Geometry import Point3D\n",
        "conf = mol_deg.GetConformer()\n",
        "\n",
        "for i in range(mol_deg.GetNumAtoms()):\n",
        "  x,y,z = xyz_coordinates[i]\n",
        "  conf.SetAtomPosition(i,Point3D(x,y,z))\n",
        "AllChem.MolToMolFile(mol_deg, (os.path.join(workDir, \"ligand_min.mol\")))\n",
        "AllChem.MolToPDBFile(mol_deg, (os.path.join(workDir, \"ligand_min.pdb\")))\n",
        "#convert to sdf format\n",
        "mol= [m for m in pybel.readfile(filename=os.path.join(workDir, \"ligand_min.mol\"), format='mol')][0]\n",
        "out=pybel.Outputfile(filename=ligand,format='sdf',overwrite=True)\n",
        "out.write(mol)\n",
        "out.close()\n",
        "\n",
        "\n",
        "#TorchANI Energies\n",
        "mol_deg = AllChem.MolFromMolFile ((os.path.join(workDir, \"ligand_min.mol\")), removeHs=False)\n",
        "coordinates, species = mol2arr([mol_deg], device)\n",
        "energy = model((species, coordinates)).energies\n",
        "derivative = torch.autograd.grad(energy.sum(), coordinates)[0]\n",
        "force = -derivative\n",
        "print('Energy:', energy.item())\n",
        "# print('Force:', force.squeeze())"
      ],
      "metadata": {
        "cellView": "form",
        "id": "hTcrO_yCzDEb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@title **Ligand Visualization**:\n",
        "#@markdown Now the ligand has been optimized, it would be recomended to visualize and check the ligand.\n",
        "\n",
        "view = py3Dmol.view(js='https://3dmol.org/build/3Dmol.js',)\n",
        "view.removeAllModels()\n",
        "view.setViewStyle({'style':'outline','color':'black','width':0.05})\n",
        "\n",
        "# view.addModel(open(receptor,'r').read(),format='pdb')\n",
        "# Prot=view.getModel()\n",
        "# Prot.setStyle({'cartoon':{'arrows':True, 'tubes':True, 'style':'oval', 'color':'white'}})\n",
        "# view.addSurface(py3Dmol.VDW,{'opacity':0.6,'color':'white'})\n",
        "\n",
        "view.addModel(open(ligand,'r').read(),format='mol2')\n",
        "ref_m = view.getModel()\n",
        "ref_m.setStyle({},{'stick':{'colorscheme':'greenCarbon','radius':0.2}})\n",
        "\n",
        "view.zoomTo()\n",
        "view.show()"
      ],
      "metadata": {
        "cellView": "form",
        "id": "0GZCAGa9_Y3k"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@title **Parameters for the docking calculation:**\n",
        "Output_name = 'output_docking' #@param {type:\"string\"}\n",
        "#@markdown Amount of buffer space to add the generated box (Angstroms):\n",
        "size = 4 #@param {type:\"slider\", min:1, max:20, step:1}\n",
        "\n",
        "#@markdown Exhaustiveness of the global search (roughly proportional to time):\n",
        "exhaustiveness = 8 #@param {type:\"slider\", min:2, max:64, step:2}\n",
        "\n",
        "#@markdown Explicit random seed:\n",
        "seed = \"0\" #@param {type:\"string\"}\n",
        "\n",
        "#@markdown Convolutional neural network (CNN) parameter:\n",
        "\n",
        "cnn_scoring = \"rescore (default)\" #@param [\"none\", \"rescore (default)\", \"refinement\", \"all\"]\n",
        "if cnn_scoring == \"rescore (default)\":\n",
        "  cnn_scoring = \"rescore\"\n",
        "  scoring_vinardo = \" \"\n",
        "elif cnn_scoring == \"none\":\n",
        "  scoring_vinardo = \" --scoring vinardo \"\n",
        "else:\n",
        "  scoring_vinardo = \" \"\n",
        "\n",
        "# if cnn_scoring == \"none\":\n",
        "#   scoring_vinardo = \" --scoring vinardo \"\n",
        "# else:\n",
        "#   scoring_vinardo = \" \"\n",
        "\n",
        "#@markdown **cnn_scoring** determines at what points of the docking procedure that the CNN scoring function is used.\n",
        "\n",
        "#@markdown **none** - No CNNs used for docking. Here, uses all the empirical scoring from [Vinardo](https://journals.plos.org/plosone/article?id=10.1371/journal.pone.0155183) scoring function.\n",
        "\n",
        "#@markdown **rescore** (default) - CNN used for reranking of final poses. Least computationally expensive CNN option.\n",
        "\n",
        "#@markdown **refinement** - CNN used to refine poses after Monte Carlo chains and for final ranking of output poses. 10x slower than rescore when using a GPU.\n",
        "\n",
        "#@markdown **all** - CNN used as the scoring function throughout the whole procedure. Extremely computationally intensive and not recommended.\n",
        "\n",
        "#@markdown The default CNN scoring function is an ensemble of 5 models selected to balance pose prediction performance and runtime: dense, general_default2018_3, dense_3, crossdock_default2018, and redock_default2018.\n",
        "\n",
        "import locale\n",
        "def getpreferredencoding(do_setlocale = True):\n",
        "    return \"UTF-8\"\n",
        "locale.getpreferredencoding = getpreferredencoding\n",
        "\n",
        "docking_output_gz = os.path.join(workDir, Output_name + \".sdf.gz\")\n",
        "docking_output = os.path.join(workDir, Output_name + \".sdf\")\n",
        "\n",
        "if os.path.exists(docking_output_gz):\n",
        "  os.remove(docking_output_gz)\n",
        "elif os.path.exists(docking_output):\n",
        "  os.remove(docking_output)\n",
        "else:\n",
        "  pass\n",
        "\n",
        "\n",
        "if Selection == \"Pocket\":\n",
        "  gnina = \"./gnina -r \" + str(receptor) + \" -l \" +  str(ligand) + \" --center_x \" + str(center_x_gnina) +  \" --center_y \" + str(center_y_gnina) +  \" --center_z \" + str(center_z_gnina) + \" --size_x \" + str(size) +  \" --size_y \" + str(size) +  \" --size_z \" + str(size) + \" --cnn_scoring \" + str(cnn_scoring) + \" --exhaustiveness \" + str(exhaustiveness) + \" -o \" + str(docking_output_gz) + str(scoring_vinardo) +  \"--num_modes 10 \" + \"--seed \" + str(int(seed))\n",
        "else:\n",
        "  gnina = \"./gnina -r \" + str(receptor) + \" -l \" +  str(ligand) + \" --autobox_ligand \" + str(res_box) +  \" --autobox_add \" + str(size) + \" --cnn_scoring \" + str(cnn_scoring) + \" --exhaustiveness \" + str(exhaustiveness) + \" -o \" + str(docking_output_gz) + str(scoring_vinardo) +  \"--num_modes 10 \" + \"--seed \" + str(int(seed))\n",
        "\n",
        "zip_gnina = \"gunzip \" + str(docking_output_gz)\n",
        "\n",
        "original_stdout = sys.stdout # Save a reference to the original standard output\n",
        "with open('gnina.sh', 'w') as f:\n",
        "    sys.stdout = f # Change the standard output to the file we created.\n",
        "    print(gnina)\n",
        "    print(zip_gnina)\n",
        "    sys.stdout = original_stdout # Reset the standard output to its original value\n",
        "\n",
        "!chmod 700 gnina.sh 2>&1 1>/dev/null\n",
        "!bash gnina.sh\n",
        "\n",
        "import gzip\n",
        "v = py3Dmol.view(js='https://3dmol.org/build/3Dmol.js',)\n",
        "v.setViewStyle({'style':'outline','color':'black','width':0.05})\n",
        "v.addModel(open(receptor).read())\n",
        "v.setStyle({'cartoon':{},'stick':{'colorscheme':'white','radius':.1}})\n",
        "v.addModel(open(res_box).read())\n",
        "v.setStyle({'model':1},{'stick':{'colorscheme':'dimgrayCarbon','radius':.175}})\n",
        "v.addModelsAsFrames(open(docking_output,'rt').read())\n",
        "v.setStyle({'model':2},{'stick':{'colorscheme':'greenCarbon'}})\n",
        "v.animate({'interval':1000})\n",
        "v.zoomTo({'model':1})\n",
        "v.rotate(90)"
      ],
      "metadata": {
        "id": "wyzlRC-sBY3J",
        "cellView": "form"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "from rdkit.Chem import rdFMCS,AllChem, Draw, PandasTools\n",
        "import seaborn as sns\n",
        "#@title **Docking Analysis:**\n",
        "Parameter = \"Affinity\" #@param [\"Affinity\", \"CNN pose score\", \"CNN affinity\"]\n",
        "\n",
        "Output_name = 'Affinity' #@param {type:\"string\"}\n",
        "\n",
        "VinaPoses=PandasTools.LoadSDF(docking_output)\n",
        "\n",
        "AllPoses=pd.concat([VinaPoses])\n",
        "# AllPoses.sort_values(by='CNNscore',inplace=False)\n",
        "# AllPoses['minimizedAffinity']=[float(i) for i in AllPoses['minimizedAffinity']]\n",
        "# AllPoses.sort_values(by='minimizedAffinity',inplace=True, ascending=False)\n",
        "# AllPoses.reset_index(drop=True, inplace=True)\n",
        "# x='CNNscore'\n",
        "\n",
        "parameter = Parameter\n",
        "if parameter == \"Affinity\":\n",
        "  AllPoses['minimizedAffinity']=[float(i) for i in AllPoses['minimizedAffinity']]\n",
        "  y='minimizedAffinity'\n",
        "elif parameter == \"CNN pose score\":\n",
        "  AllPoses['CNNscore']=[float(i) for i in AllPoses['CNNscore']]\n",
        "  y='CNNscore'\n",
        "else:\n",
        "  AllPoses['CNNaffinity']=[float(i) for i in AllPoses['CNNaffinity']]\n",
        "  y='CNNaffinity'\n",
        "\n",
        "plt.rcParams['axes.linewidth'] = 2\n",
        "fig = plt.figure(figsize=(8,6))\n",
        "ax = fig.add_subplot(111)\n",
        "# print(AllPoses)\n",
        "\n",
        "a = 0\n",
        "x_new =[]\n",
        "for i in AllPoses['minimizedAffinity']:\n",
        "  a = a + 1\n",
        "  x_new.append(a)\n",
        "\n",
        "# Keyword arguments for styling the plot\n",
        "kwargs = dict (linestyle='--', color='dodgerblue', marker ='o', linewidth=0.8, markersize=15)\n",
        "\n",
        "# Draw the plot\n",
        "line = sns.lineplot(x=x_new,y=y, data=AllPoses,**kwargs)\n",
        "\n",
        "if parameter == \"Affinity\":\n",
        "  plt.ylabel('Affinity (Kcal/mol)',fontsize=16,fontweight='bold')\n",
        "elif parameter == \"CNN pose score\":\n",
        "  plt.ylabel('CNN pose score',fontsize=16,fontweight='bold')\n",
        "else:\n",
        "  plt.ylabel('CNN affinity',fontsize=16,fontweight='bold')\n",
        "\n",
        "plt.xlabel('Mode Number',fontsize=16,fontweight='bold')\n",
        "plt.xticks(x_new[::1], fontsize = 12) # set divisor\n",
        "plt.yticks(fontsize = 12)\n",
        "ax.spines['top'].set_visible(False)\n",
        "ax.spines['right'].set_visible(False)\n",
        "plt.tight_layout()\n",
        "plt.tick_params ('both',width=2,labelsize=14)\n",
        "\n",
        "plt.savefig(os.path.join(workDir, Output_name + \".png\"), dpi=600, bbox_inches='tight')"
      ],
      "metadata": {
        "id": "dKMqp4TZmRDJ",
        "cellView": "form"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@title **Best pose selection:**\n",
        "\n",
        "mode_number = \"1\" #@param [\"1\", \"2\", \"3\", \"4\", \"5\", \"6\", \"7\", \"8\", \"9\", \"10\"]\n",
        "\n",
        "view = py3Dmol.view(js='https://3dmol.org/build/3Dmol.js',)\n",
        "view.removeAllModels()\n",
        "view.setViewStyle({'style':'outline','color':'black','width':0.05})\n",
        "\n",
        "view.addModel(open(receptor,'r').read(),'pdb')\n",
        "Prot=view.getModel()\n",
        "# Prot.setStyle({'cartoon':{'arrows':True, 'tubes':True, 'style':'oval', 'color':'white'},'stick':{'radius':.1}})\n",
        "Prot.setStyle({'cartoon':{'arrows':True, 'tubes':True, 'style':'oval', 'color':'white'}})\n",
        "view.addSurface(py3Dmol.VDW,{'opacity':0.2,'color':'white'})\n",
        "\n",
        "\n",
        "view.addModel(open(res_box,'r').read(),'pdb')\n",
        "ref_m = view.getModel()\n",
        "ref_m.setStyle({},{'stick':{'colorscheme':'grayCarbon','radius':0.2}})\n",
        "\n",
        "\n",
        "results=Chem.SDMolSupplier(docking_output,True)\n",
        "p=Chem.MolToMolBlock(results[(int(mode_number)-1)],False)\n",
        "p2=Chem.MolToMolFile(results[(int(mode_number)-1)],(os.path.join(workDir, str(int(mode_number)) + \"_pose.sdf\")))\n",
        "\n",
        "print('Reference: Gray | gnina Pose: Green')\n",
        "if cnn_scoring == \"none\":\n",
        "  print ('Affinity: {}'.format(results[(int(mode_number)-1)].GetProp('minimizedAffinity')))\n",
        "else:\n",
        "  print ('Affinity: {}'.format(results[(int(mode_number)-1)].GetProp('minimizedAffinity')))\n",
        "  print ('CNN Score: {}'.format(results[(int(mode_number)-1)].GetProp('CNNscore')))\n",
        "  print ('CNN Affinity: {}'.format(results[(int(mode_number)-1)].GetProp('CNNaffinity')))\n",
        "\n",
        "view.addModel(p,'mol')\n",
        "x = view.getModel()\n",
        "x.setStyle({},{'stick':{'colorscheme':'greenCarbon','radius':0.2}})\n",
        "\n",
        "view.zoomTo()\n",
        "view.show()"
      ],
      "metadata": {
        "cellView": "form",
        "id": "3GggfJfLIVe8"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}