{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Finding solvent-exposed residues " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We want to find residues that are within a certain distance $d$ near solvent molecules. Two approaches could be used\n", "\n", "1. simple distance criterion\n", "2. hydrogen-bonded residues\n", "\n", "For right now, we will just look at a simple distance criterion." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Packages\n", "\n", "We will use [MDAnalysis](https://mdanalysis.org) and other common Python packages:" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "import MDAnalysis as mda\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "\n", "%matplotlib inline\n", "plt.matplotlib.style.use(\"ggplot\")\n", "\n", "import pandas as pd" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Data\n", "For this example, we will use a short trajectory of the enzyme AdK in solvent (water and ions). The trajectory was produced with Gromacs and uses the OPLS-AA forcefield with TIP4P water. It is included as a test file (TPR topology and XTC trajectory)" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "collapsed": true }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/Volumes/Data/oliver/Biop/Projects/Methods/MDAnalysis/mdanalysis/testsuite/MDAnalysisTests/__init__.py:118: UserWarning: \n", "This call to matplotlib.use() has no effect because the backend has already\n", "been chosen; matplotlib.use() must be called *before* pylab, matplotlib.pyplot,\n", "or matplotlib.backends is imported for the first time.\n", "\n", "The backend was *originally* set to 'module://ipykernel.pylab.backend_inline' by the following code:\n", " File \"/Users/oliver/anaconda3/envs/mda_develop/lib/python3.6/runpy.py\", line 193, in _run_module_as_main\n", " \"__main__\", mod_spec)\n", " File \"/Users/oliver/anaconda3/envs/mda_develop/lib/python3.6/runpy.py\", line 85, in _run_code\n", " exec(code, run_globals)\n", " File \"/Users/oliver/anaconda3/envs/mda_develop/lib/python3.6/site-packages/ipykernel_launcher.py\", line 16, in \n", " app.launch_new_instance()\n", " File \"/Users/oliver/anaconda3/envs/mda_develop/lib/python3.6/site-packages/traitlets/config/application.py\", line 658, in launch_instance\n", " app.start()\n", " File \"/Users/oliver/anaconda3/envs/mda_develop/lib/python3.6/site-packages/ipykernel/kernelapp.py\", line 486, in start\n", " self.io_loop.start()\n", " File \"/Users/oliver/anaconda3/envs/mda_develop/lib/python3.6/site-packages/tornado/ioloop.py\", line 888, in start\n", " handler_func(fd_obj, events)\n", " File \"/Users/oliver/anaconda3/envs/mda_develop/lib/python3.6/site-packages/tornado/stack_context.py\", line 277, in null_wrapper\n", " return fn(*args, **kwargs)\n", " File \"/Users/oliver/anaconda3/envs/mda_develop/lib/python3.6/site-packages/zmq/eventloop/zmqstream.py\", line 450, in _handle_events\n", " self._handle_recv()\n", " File \"/Users/oliver/anaconda3/envs/mda_develop/lib/python3.6/site-packages/zmq/eventloop/zmqstream.py\", line 480, in _handle_recv\n", " self._run_callback(callback, msg)\n", " File \"/Users/oliver/anaconda3/envs/mda_develop/lib/python3.6/site-packages/zmq/eventloop/zmqstream.py\", line 432, in _run_callback\n", " callback(*args, **kwargs)\n", " File \"/Users/oliver/anaconda3/envs/mda_develop/lib/python3.6/site-packages/tornado/stack_context.py\", line 277, in null_wrapper\n", " return fn(*args, **kwargs)\n", " File \"/Users/oliver/anaconda3/envs/mda_develop/lib/python3.6/site-packages/ipykernel/kernelbase.py\", line 283, in dispatcher\n", " return self.dispatch_shell(stream, msg)\n", " File \"/Users/oliver/anaconda3/envs/mda_develop/lib/python3.6/site-packages/ipykernel/kernelbase.py\", line 233, in dispatch_shell\n", " handler(stream, idents, msg)\n", " File \"/Users/oliver/anaconda3/envs/mda_develop/lib/python3.6/site-packages/ipykernel/kernelbase.py\", line 399, in execute_request\n", " user_expressions, allow_stdin)\n", " File \"/Users/oliver/anaconda3/envs/mda_develop/lib/python3.6/site-packages/ipykernel/ipkernel.py\", line 208, in do_execute\n", " res = shell.run_cell(code, store_history=store_history, silent=silent)\n", " File \"/Users/oliver/anaconda3/envs/mda_develop/lib/python3.6/site-packages/ipykernel/zmqshell.py\", line 537, in run_cell\n", " return super(ZMQInteractiveShell, self).run_cell(*args, **kwargs)\n", " File \"/Users/oliver/anaconda3/envs/mda_develop/lib/python3.6/site-packages/IPython/core/interactiveshell.py\", line 2728, in run_cell\n", " interactivity=interactivity, compiler=compiler, result=result)\n", " File \"/Users/oliver/anaconda3/envs/mda_develop/lib/python3.6/site-packages/IPython/core/interactiveshell.py\", line 2850, in run_ast_nodes\n", " if self.run_code(code, result):\n", " File \"/Users/oliver/anaconda3/envs/mda_develop/lib/python3.6/site-packages/IPython/core/interactiveshell.py\", line 2910, in run_code\n", " exec(code_obj, self.user_global_ns, self.user_ns)\n", " File \"\", line 5, in \n", " get_ipython().run_line_magic('matplotlib', 'inline')\n", " File \"/Users/oliver/anaconda3/envs/mda_develop/lib/python3.6/site-packages/IPython/core/interactiveshell.py\", line 2095, in run_line_magic\n", " result = fn(*args,**kwargs)\n", " File \"\", line 2, in matplotlib\n", " File \"/Users/oliver/anaconda3/envs/mda_develop/lib/python3.6/site-packages/IPython/core/magic.py\", line 187, in \n", " call = lambda f, *a, **k: f(*a, **k)\n", " File \"/Users/oliver/anaconda3/envs/mda_develop/lib/python3.6/site-packages/IPython/core/magics/pylab.py\", line 99, in matplotlib\n", " gui, backend = self.shell.enable_matplotlib(args.gui)\n", " File \"/Users/oliver/anaconda3/envs/mda_develop/lib/python3.6/site-packages/IPython/core/interactiveshell.py\", line 2978, in enable_matplotlib\n", " pt.activate_matplotlib(backend)\n", " File \"/Users/oliver/anaconda3/envs/mda_develop/lib/python3.6/site-packages/IPython/core/pylabtools.py\", line 308, in activate_matplotlib\n", " matplotlib.pyplot.switch_backend(backend)\n", " File \"/Users/oliver/anaconda3/envs/mda_develop/lib/python3.6/site-packages/matplotlib/pyplot.py\", line 231, in switch_backend\n", " matplotlib.use(newbackend, warn=False, force=True)\n", " File \"/Users/oliver/anaconda3/envs/mda_develop/lib/python3.6/site-packages/matplotlib/__init__.py\", line 1400, in use\n", " reload(sys.modules['matplotlib.backends'])\n", " File \"/Users/oliver/anaconda3/envs/mda_develop/lib/python3.6/importlib/__init__.py\", line 166, in reload\n", " _bootstrap._exec(spec, module)\n", " File \"/Users/oliver/anaconda3/envs/mda_develop/lib/python3.6/site-packages/matplotlib/backends/__init__.py\", line 16, in \n", " line for line in traceback.format_stack()\n", "\n", "\n", " matplotlib.use('agg')\n" ] } ], "source": [ "from MDAnalysisTests.datafiles import TPR, XTC" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Analysis: find solvent-exposed residues\n", "\n", "We always start with a MDAnalysis `Universe`:" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "u = mda.Universe(TPR, XTC)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Distance-based analysis\n", "\n", "We want to find residues that have at least one atom within a cutoff $d = 3.5$ Å near a water molecule. (We might have to play with the value of $d$ but 3.5 Å is about the maximum distance for a hydrogen bond and is also less than the thickness of two hydration layers so it seems a reasonable starting point.)" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [], "source": [ "dmax = 3.5 # Ångstrom " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's say we are only interested in acidic residues: Asp and Glu, and we only want to consider the heavy atoms (not H):" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ ", , , ..., , , ]>\n" ] }, { "data": { "text/plain": [ "" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "acidics = u.select_atoms(\"resname ASP GLU and not name H*\")\n", "print(acidics.residues)\n", "acidics.residues" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Get the solvent molecules, and specifically, we will just use the central oxygen for the distance calculation:" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "11084\n" ] } ], "source": [ "water = u.select_atoms(\"resname SOL and name OW\")\n", "print(water.n_residues)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Basic algorithm " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "For each frame in the trajectory we will now calculate the distance between all atoms in the `acidics` group with the water oxygens in the `water` group, using the [distance_array()](https://www.mdanalysis.org/docs/documentation_pages/lib/distances.html#MDAnalysis.lib.distances.distance_array) function:\n", "$$\n", "d_{ij} = ||\\mathbf{r}^\\text{acidics}_i - \\mathbf{r}^\\text{water}_j||\n", "$$\n", "\n", "Because MD simulations are typically done with periodic boundary conditions, we use the minimum image convention to calculate the shortest distances taking PBC in account — this requires the `box` keyword of `distance_array()`.\n" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "from MDAnalysis.lib import distances" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "dij = distances.distance_array(acidics.positions, water.positions, \n", " box=u.trajectory.ts.dimensions)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now we need to find distances smaller than $d$ and find those rows $i$ (corresponding to an atom in an acidic residue) in which at least one column $d_{ij} \\le d$:" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(298, 11084)" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "dij.shape" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(298,)" ] }, "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ "exposed_atoms = np.any(dij <= dmax, axis=1)\n", "exposed_atoms.shape" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "For each atom in the acidic residue we now have an `True` entry if they are exposed and `False` if they are not.\n", "\n", "We now have to associate the exposed atoms again with the residues. We can use the `exposed_atoms` array as a Boolean index into our original `acidics` atomgroup and just pick out the residues:" ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [], "source": [ "exposed_residues = acidics[exposed_atoms].residues" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 36, "metadata": {}, "output_type": "execute_result" } ], "source": [ "exposed_residues" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "It looks as if all acidic residues are exposed." ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 38, "metadata": {}, "output_type": "execute_result" } ], "source": [ "exposed_residues == acidics.residues" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Trajectory analysis " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Right now we have calculated the distances for the first trajectory frame. We can do the analysis for multiple frames in a trajectory." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "First package the analysis into a simple function." ] }, { "cell_type": "code", "execution_count": 40, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "from MDAnalysis.lib import distances\n", "\n", "def get_exposed_residues(atoms, water, dmax=3.5):\n", " \"\"\"Find all residues for which atoms are within dmax of water.\"\"\"\n", " \n", " dij = distances.distance_array(atoms.positions, water.positions, \n", " box=atoms.universe.trajectory.ts.dimensions)\n", " exposed_atoms = np.any(dij <= dmax, axis=1)\n", " return atoms[exposed_atoms].residues" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Check that the function works:" ] }, { "cell_type": "code", "execution_count": 41, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 41, "metadata": {}, "output_type": "execute_result" } ], "source": [ "get_exposed_residues(acidics, water, dmax=3.5)" ] }, { "cell_type": "code", "execution_count": 44, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 44, "metadata": {}, "output_type": "execute_result" } ], "source": [ "get_exposed_residues(acidics, water, dmax=2.5)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now we will just count the number of exposed residues as a function of time (and using $d_\\text{max}=2.5$ Å to make it more interesting: " ] }, { "cell_type": "code", "execution_count": 65, "metadata": {}, "outputs": [], "source": [ "dmax = 2.5\n", "\n", "results = np.zeros((u.trajectory.n_frames, 2)) # (time, N_exposed)\n", "for i, ts in enumerate(u.trajectory):\n", " exposed_residues = get_exposed_residues(acidics, water, dmax=dmax)\n", " results[i, :] = (ts.time, exposed_residues.n_residues)" ] }, { "cell_type": "code", "execution_count": 67, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.plot(results[:, 0], results[:, 1], \n", " label=r\"$d_\\mathrm{{max}}={0:.1f}$ Å\".format(dmax))\n", "plt.xlabel(r\"time $t$ (ps)\")\n", "plt.ylabel(r\"exposed {} residues $N$\".format(\", \".join(set(acidics.resnames))))\n", "plt.legend(loc=\"best\");" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.6.4" } }, "nbformat": 4, "nbformat_minor": 2 }