{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Quick start guide" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "MDAnalysis version: ≥ 0.18.0\n", "\n", "Last updated: Dec 2020\n", "\n", "This guide is designed as a basic introduction to MDAnalysis to get you up and running. You can see more complex tasks in our [Example notebooks](https://userguide.mdanalysis.org/stable/examples/README.html). This page outlines how to:\n", "\n", "* [load a molecular dynamics structure or trajectory](#Loading-a-structure-or-trajectory)\n", "* [work with AtomGroups, a central data structure in MDAnalysis](#Working-with-groups-of-atoms)\n", "* [work with a trajectory](#Working-with-trajectories)\n", "* [write out coordinates](#Writing-out-coordinates)\n", "\n", "* [use the analysis algorithms in MDAnalysis](#Analysis)\n", "* [correct and automated citation of MDAnalysis and algorithms](#References)" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "ExecuteTime": { "end_time": "2020-12-30T10:32:01.339751Z", "start_time": "2020-12-30T10:31:59.700676Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "1.0.0\n" ] } ], "source": [ "import MDAnalysis as mda\n", "from MDAnalysis.tests.datafiles import PSF, DCD, GRO, XTC\n", "\n", "print(mda.Universe(PSF, DCD))\n", "print(mda.__version__)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This tutorial assumes that you already have MDAnalysis installed. Running the cell above should give something similar to:\n", "\n", "```console\n", "\n", "1.0.0\n", "```\n", "If you get an error message, you need to install MDAnalysis. If your version is under `0.18.0`, you need to upgrade MDAnalysis. [Instructions for both are here.](https://www.mdanalysis.org/UserGuide/installation) After installing, restart this notebook." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Overview" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "MDAnalysis is a Python package that provides tools to access and analyse data in molecular dynamics trajectories. Several key data structures form the backbone of MDAnalysis.\n", "\n", "* A molecular system consists of particles. A particle is represented as an `Atom` object, even if it is a coarse-grained bead. \n", "* `Atom`s are grouped into [AtomGroup](https://www.mdanalysis.org/UserGuide/atomgroup)s. The `AtomGroup` is probably the most important class in MDAnalysis, as almost everything can be accessed through it. See [Working with atoms](#Working-with-groups-of-atoms) below. \n", "* A `Universe` contains all the particles in a molecular system in an `AtomGroup` accessible at the `.atoms` attribute, and combines it with a trajectory at `.trajectory`. \n", "\n", "A fundamental concept in MDAnalysis is that at any one time, \n", "only one time frame of the trajectory is being accessed. The \n", "`trajectory` attribute of a `Universe` is usually a file reader. \n", "Think of the trajectory as a function $X(t)$ of the frame index $t$ \n", "that only makes the data from this specific frame available. This structure is important \n", "because it allows MDAnalysis to work with trajectory files too large to fit \n", "into the computer's memory. \n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Loading a structure or trajectory" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Working with MDAnalysis typically starts with loading data into a `Universe`, the central data structure in MDAnalysis. The [user guide](https://www.mdanalysis.org/UserGuide/universe) has a complete explanation of ways to create and manipulate a `Universe`.\n", "\n", "\n", "The first arguments for creating a `Universe` are topology and trajectory files.\n", "\n", "* A **topology file** is always required for loading data into a Universe. A topology file lists atoms, residues, and their connectivity. MDAnalysis accepts the PSF, PDB, CRD, and GRO formats.\n", "\n", "* A topology file can then be followed by **any number of trajectory files**. A trajectory file contains a list of coordinates in the order defined in the topology. If no trajectory files are given, then only a structure is loaded. If multiple trajectory files are given, the trajectories are concatenated in the given order. MDAnalysis accepts single frames (e.g. PDB, CRD, GRO) and timeseries data (e.g. DCD, XTC, TRR, XYZ). " ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "False\n" ] } ], "source": [ "psf = mda.Universe(PSF)\n", "print(psf)\n", "print(hasattr(psf, 'trajectory'))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As PSF files don't contain any coordinate information and no trajectory file has been loaded, the `psf` universe does not contain a trajectory. If the topology file does contain coordinate information, a trajectory of 1 frame is created." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "1\n" ] } ], "source": [ "gro = mda.Universe(GRO)\n", "print(gro)\n", "print(len(gro.trajectory))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "For the remainder of this guide we will work with the universe `u`, created below. This is a simulation where the enzyme adenylate kinase samples a transition from a closed to an open conformation [(Beckstein *et al.*, 2009)](https://doi.org/10.1016/j.jmb.2009.09.009)." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "98\n" ] } ], "source": [ "u = mda.Universe(PSF, DCD)\n", "print(u)\n", "print(len(u.trajectory))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "\n", "**Note**\n", "\n", "The MDAnalysis test suite is packaged with a bunch of test files and trajectories, which are named after their file format. We are using these files throughout this guide for convenience. To analyse your own files, simply replace the `PSF` and `DCD` above with paths to your own files. For example:\n", "\n", "```python\n", "structure_only = mda.Universe(\"my_pdb_file.pdb\")\n", "```\n", "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Working with groups of atoms" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Most analysis requires creating and working with an `AtomGroup`, a collection of `Atom`s. For convenience, you can also work with chemically meaningful groups of `Atoms` such as a `Residue` or a `Segment`. These come with analogous containers to `AtomGroup`: `ResidueGroup` and `SegmentGroup`. For instance, the `.residues` attribute of a `Universe` returns a `ResidueGroup`." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ ", , , ..., , , ]>\n" ] } ], "source": [ "print(u.residues)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Selecting atoms" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The easiest way to access the particles of your `Universe` is with the `atoms` attribute:" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "u.atoms" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This returns an `AtomGroup`, which can be thought of as a list of `Atom` objects. Most analysis involves working with groups of atoms in `AtomGroup`s. `AtomGroup`s can easily be created by slicing another `AtomGroup`. For example, the below slice returns the last five atoms." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ ", , , , ]>\n" ] } ], "source": [ "last_five = u.atoms[-5:]\n", "print(last_five)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "MDAnalysis supports fancy indexing: passing an array or list of indices to get a new AtomGroup with the atoms at those indices in the old AtomGroup." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ ", , , , , ]>\n" ] } ], "source": [ "print(last_five[[0, 3, -1, 1, 3, 0]])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "MDAnalysis has also implemented a [powerful atom selection language](https://userguide.mdanalysis.org/stable/selections.html) that is similar to existing languages in [VMD](https://www.ks.uiuc.edu/Research/vmd/), [PyMol](https://pymol.org/2/), and other packages. This is available with the `.select_atoms()` function of an `AtomGroup` or `Universe` instance:" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ ", , , ..., , , ]>\n" ] } ], "source": [ "print(u.select_atoms('resname ASP or resname GLU'))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Numerical ranges can be written as `first-last` or `first:last` where the range is **inclusive**. Note that in slicing, the `last` index is not included." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "51\n", "50\n" ] } ], "source": [ "print(u.select_atoms('resid 50-100').n_residues)\n", "print(u.residues[50:100].n_residues)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Selections can also be combined with boolean operators, and allow wildcards. \n", "\n", "For example, the command below selects the $C_{\\alpha}$ atoms of glutamic acid and histidine in the first 100 residues of the protein. Glutamic acid is typically named \"GLU\", but histidine can be named \"HIS\", \"HSD\", or \"HSE\" depending on its protonation state and the force field used." ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "u.select_atoms(\"(resname GLU or resname HS*) and name CA and (resid 1:100)\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "\n", "**Note**\n", "\n", "An `AtomGroup` created from a selection is sorted and duplicate elements are removed. This is not true for an `AtomGroup` produced by slicing. Thus, slicing can be used when the order of atoms is crucial.\n", "
\n", "\n", "\n", "\n", "The [user guide](https://userguide.mdanalysis.org/stable/atomgroup.html) has a complete rundown of creating `AtomGroup`s through indexing, selection language, and set methods." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Getting atom information from AtomGroups" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "An `AtomGroup` can tell you information about the atoms inside it with a number of convenient attributes." ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['N' 'HT1' 'HT2' 'HT3' 'CA' 'HA' 'CB' 'HB1' 'HB2' 'CG' 'HG1' 'HG2' 'SD'\n", " 'CE' 'HE1' 'HE2' 'HE3' 'C' 'O' 'N']\n" ] } ], "source": [ "print(u.atoms[:20].names)" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[ 1.008 1.008 1.008 12.011 1.008 1.008 12.011 1.008 1.008 1.008\n", " 12.011 15.999 14.007 1.008 12.011 1.008 12.011 1.008 12.011 1.008]\n" ] } ], "source": [ "print(u.atoms[50:70].masses)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "It also knows which residues and segments the atoms belong to. The `.residues` and `.segments` return a `ResidueGroup` and `SegmentGroup`, respectively." ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ ", ]>\n", "]>\n" ] } ], "source": [ "print(u.atoms[:20].residues)\n", "print(u.atoms[-20:].segments)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note that there are no duplicates in the `ResidueGroup` and `SegmentGroup` above. To get residue attributes atom-wise, you can access them directly through `AtomGroup`." ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['MET' 'MET' 'MET' 'MET' 'MET' 'MET' 'MET' 'MET' 'MET' 'MET' 'MET' 'MET'\n", " 'MET' 'MET' 'MET' 'MET' 'MET' 'MET' 'MET' 'ARG']\n" ] } ], "source": [ "print(u.atoms[:20].resnames)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "You can group atoms together by topology attributes.\n", "\n", "For example, to group atoms with the same residue name and mass together:" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{('ALA', 'HN'): ,\n", " ('ALA', 'C'): ,\n", " ('ASP', 'N'): ,\n", " ('ASP', 'C'): ,\n", " ('THR', 'N'): ,\n", " ('GLU', 'N'): ,\n", " ('ILE', 'C'): ,\n", " ('LEU', 'N'): ,\n", " ('GLN', 'C'): ,\n", " ('ASN', 'O'): ,\n", " ('LYS', 'N'): ,\n", " ('ARG', 'N'): }" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "near_met = u.select_atoms('not resname MET and (around 2 resname MET)')\n", "near_met.groupby(['resnames', 'names'])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A complete list of topology attributes can be found [in the user guide.](https://userguide.mdanalysis.org/stable/topology_system.html)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### AtomGroup positions and methods" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The `.positions` attribute is probably the most important information you can get from an `AtomGroup`: a `numpy.ndarray` of coordinates, with the shape `(n_atoms, 3)`." ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[11.664622 8.393473 -8.983231 ]\n", " [11.414839 5.4344215 -6.5134845 ]\n", " [ 8.959755 5.612923 -3.6132305 ]\n", " [ 8.290068 3.075991 -0.79665166]\n", " [ 5.011126 3.7638984 1.130355 ]]\n", "(5, 3)\n" ] } ], "source": [ "ca = u.select_atoms('resid 1-5 and name CA')\n", "print(ca.positions)\n", "print(ca.positions.shape)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A number of other quantities have been defined for an AtomGroup, including:\n", "\n", "* `.center_of_mass()`\n", "* `.center_of_geometry()`\n", "* `.total_mass()`\n", "* `.total_charge()`\n", "* `.radius_of_gyration()`\n", "* `.bsphere()` (the bounding sphere of the selection)\n", "\n", "See the [user guide](https://userguide.mdanalysis.org/stable/topology_system.html) for a complete list and description of AtomGroup methods." ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[ 9.06808195 5.25614133 -3.75524844]\n" ] } ], "source": [ "print(ca.center_of_mass())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "\n", "**Note**\n", "\n", "The `.center_of_mass()` function, like many of the analysis modules in MDAnalysis, relies on having accurate mass properties available. **[Particle masses may not always be available or accurate!](https://userguide.mdanalysis.org/stable/formats/guessing.html#masses)**\n", "\n", "Currently, MDAnalysis assigns masses to particles based on their element or 'atom type', which is guessed from the particle name. If MDAnalysis guesses incorrectly (e.g. a calcium atom called CA is treated as a $C_{\\alpha}$), the mass of that atom will be inaccurate. If MDAnalysis has no idea what the particle is (e.g. coarse-grained beads), it will raise a warning, and give that particle a mass of 0. \n", "\n", "To be certain that MDAnalysis is using the correct masses, you can set them manually.\n", "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "MDAnalysis can also create [topology geometries](https://userguide.mdanalysis.org/stable/topology_system.html#topology-objects) such as bonds, angles, dihedral angles, and improper angles from an `AtomGroup`. This `AtomGroup` has a special requirement: only the atoms involved in the geometry can be in the group. For example, an `AtomGroup` used to create a bond can only have 2 atoms in it; an `AtomGroup` used to create a dihedral or improper angle must have 4 atoms." ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['N' 'HT1' 'HT2']\n" ] } ], "source": [ "nhh = u.atoms[:3]\n", "print(nhh.names)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "After a topology object such as an angle is created, the value of the angle (in degrees) can be calculated based on the positions of the atoms." ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "37.99234750892497\n" ] } ], "source": [ "angle_nhh = nhh.angle\n", "print(angle_nhh.value())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note that the order of the atoms matters for angles, dihedrals, and impropers. The value returned for an angle is the angle between first and third atom, with the apex at the second. Fancy indexing is one way to get an ordered AtomGroup.\n", "```\n", " 3\n", " /\n", " /\n", "2------1\n", "```" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['HT1' 'N' 'HT2']\n" ] } ], "source": [ "hnh = u.atoms[[1, 0, 2]]\n", "print(hnh.names)" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "106.20364651944931\n" ] } ], "source": [ "angle_hnh = hnh.angle\n", "print(angle_hnh.value())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Working with trajectories" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The [trajectory of a Universe contains the changing coordinate information](https://userguide.mdanalysis.org/stable/trajectories/trajectories.html). The number of frames in a trajectory is its length:" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "98\n" ] } ], "source": [ "print(len(u.trajectory))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The standard way to assess the information of each frame in a trajectory is to iterate over it. When the timestep changes, the universe only contains information associated with that timestep." ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Frame: 0, Time: 1 ps, Rgyr: 16.6690 A\n", "Frame: 1, Time: 2 ps, Rgyr: 16.6732 A\n", "Frame: 2, Time: 3 ps, Rgyr: 16.7315 A\n", "Frame: 3, Time: 4 ps, Rgyr: 16.7223 A\n", "Frame: 4, Time: 5 ps, Rgyr: 16.7440 A\n", "Frame: 5, Time: 6 ps, Rgyr: 16.7185 A\n", "Frame: 6, Time: 7 ps, Rgyr: 16.7741 A\n", "Frame: 7, Time: 8 ps, Rgyr: 16.7764 A\n", "Frame: 8, Time: 9 ps, Rgyr: 16.7894 A\n", "Frame: 9, Time: 10 ps, Rgyr: 16.8289 A\n", "Frame: 10, Time: 11 ps, Rgyr: 16.8521 A\n", "Frame: 11, Time: 12 ps, Rgyr: 16.8549 A\n", "Frame: 12, Time: 13 ps, Rgyr: 16.8723 A\n", "Frame: 13, Time: 14 ps, Rgyr: 16.9108 A\n", "Frame: 14, Time: 15 ps, Rgyr: 16.9494 A\n", "Frame: 15, Time: 16 ps, Rgyr: 16.9810 A\n", "Frame: 16, Time: 17 ps, Rgyr: 17.0033 A\n", "Frame: 17, Time: 18 ps, Rgyr: 17.0196 A\n", "Frame: 18, Time: 19 ps, Rgyr: 17.0784 A\n", "Frame: 19, Time: 20 ps, Rgyr: 17.1265 A\n" ] } ], "source": [ "for ts in u.trajectory[:20]:\n", " time = u.trajectory.time\n", " rgyr = u.atoms.radius_of_gyration()\n", " print(\"Frame: {:3d}, Time: {:4.0f} ps, Rgyr: {:.4f} A\".format(ts.frame, time, rgyr))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "After iteration, the trajectory 'resets' back to the first frame. Please see [the user guide](https://userguide.mdanalysis.org/stable/trajectories/trajectories.html) for more information." ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0\n" ] } ], "source": [ "print(u.trajectory.frame)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "You can set the timestep of the trajectory with the frame index:" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "10\n" ] } ], "source": [ "print(u.trajectory[10].frame)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This persists until the timestep is next changed." ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Frame: 10, Time: 11 ps, Rgyr: 16.8521 A\n" ] } ], "source": [ "frame = u.trajectory.frame\n", "time = u.trajectory.time\n", "rgyr = u.atoms.radius_of_gyration()\n", "print(\"Frame: {:3d}, Time: {:4.0f} ps, Rgyr: {:.4f} A\".format(frame, time, rgyr))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Generally, trajectory analysis first collects frame-wise data in a list." ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [], "source": [ "rgyr = []\n", "time = []\n", "protein = u.select_atoms(\"protein\")\n", "for ts in u.trajectory:\n", " time.append(u.trajectory.time)\n", " rgyr.append(protein.radius_of_gyration())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This can then be converted into other data structures, such as a numpy array or a pandas DataFrame. It can be plotted (as below), or used for further analysis. \n", "\n", "The following section requires the [pandas](https://pandas.pydata.org) package (installation: `conda install pandas` or `pip install pandas`) and [matplotlib](https://matplotlib.org/) (installation: `conda install matplotlib` or `pip install matplotlib`)" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
Radius of gyration (A)
Time (ps)
1.016.669018
2.016.673217
3.016.731454
4.016.722283
5.016.743961
\n", "
" ], "text/plain": [ " Radius of gyration (A)\n", "Time (ps) \n", "1.0 16.669018\n", "2.0 16.673217\n", "3.0 16.731454\n", "4.0 16.722283\n", "5.0 16.743961" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import pandas as pd\n", "rgyr_df = pd.DataFrame(rgyr, columns=['Radius of gyration (A)'], index=time)\n", "rgyr_df.index.name = 'Time (ps)'\n", "\n", "rgyr_df.head()" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 30, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "%matplotlib inline\n", "\n", "rgyr_df.plot(title='Radius of gyration')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Dynamic selection" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As seen above, coordinates change while iterating over the trajectory. Therefore, properties calculated from the coordinates, such as the radius of gyration, also change. \n", "\n", "Selections are often defined on static properties that do not change when moving through a trajectory. Above, the static selection is all the atoms that are in a protein. You can define the selection once and then recalculate the property of interest for each frame of the trajectory.\n", "\n", "However, some selections contain distance-dependent queries (such as `around` or `point`, [see selection keywords for more details](https://userguide.mdanalysis.org/stable/selections.html)). In this case, the selection should be updated for each time step using a dynamic selection by setting the keyword `updating=True`. This command gives an `UpdatingAtomGroup` rather than a static `AtomGroup`.\n", "\n" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n" ] }, { "data": { "text/plain": [ "" ] }, "execution_count": 31, "metadata": {}, "output_type": "execute_result" } ], "source": [ "dynamic = u.select_atoms('around 2 resname ALA', updating=True)\n", "print(type(dynamic))\n", "dynamic" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n" ] }, { "data": { "text/plain": [ "" ] }, "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ "static = u.select_atoms('around 2 resname ALA')\n", "print(type(static))\n", "static" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "When you call the next frame of the universe, the atoms in the dynamic selection are updated, whereas the atoms in the static selection remain the same." ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "u.trajectory.next()\n", "dynamic" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ "static" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Writing out coordinates" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "MDAnalysis supports [writing data out](https://userguide.mdanalysis.org/stable/selections.html) into a range of file formats, including both single frame formats (e.g. PDB, GRO) and trajectory writers (e.g. XTC, DCD, and multi-frame PDB files). (You can [also write selections out to other programs, such as VMD macros.](https://userguide.mdanalysis.org/stable/formats/selection_exporters.html))The user guide has a [complete list of formats](https://userguide.mdanalysis.org/stable/formats/index.html), each with their own [reference pages](https://userguide.mdanalysis.org/stable/formats/format_reference.html)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Single frame" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The most straightforward way to write to a file that can only hold a single frame is to use the `write()` method of any `AtomGroup`. MDAnalysis uses the file extension to determine the output file format. For instance, to only write out the $C_{\\alpha}$ atoms to a file in GRO format:\n", "\n", "```python\n", "ca = u.select_atoms('name CA')\n", "ca.write('calphas.gro')\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Trajectories" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The [standard way to write out trajectories](https://userguide.mdanalysis.org/stable/reading_and_writing.html#output) is to:\n", "\n", "1. Open a trajectory `Writer` and specify how many atoms a frame will contain\n", "2. Iterate through the trajectory and write coordinates frame-by-frame with `Writer.write()`\n", "3. If you do not use the context manager and the `with` statement below, you then need to close the trajectory with `.close()`.\n", "\n", "For instance, to write out the $C_{\\alpha}$ atoms to a trajectory in the XTC format:\n", "\n", "```python\n", "ca = u.select_atoms('name CA')\n", "with mda.Writer('calphas.xtc', ca.n_atoms) as w:\n", " for ts in u.trajectory:\n", " w.write(ca)\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Analysis" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "MDAnalysis comes with a [diverse set of analysis modules](https://docs.mdanalysis.org/stable/documentation_pages/analysis_modules.html), and the building blocks to [implement your own](https://userguide.mdanalysis.org/stable/examples/analysis/custom_trajectory_analysis.html). (Please see a list of analysis tutorials in the [user guide](https://userguide.mdanalysis.org/stable/examples/analysis/README.html).)\n", "\n", "The majority of these follow a common interface:\n", "\n", "1. Initialise the analysis with a `Universe` and other required parameters.\n", "2. Run the analysis with `.run()`. Optional arguments are the `start` frame index, `stop` frame index, `step` size, and toggling `verbose`. The default is to run analysis on the whole trajectory.\n", "3. Results are stored within the class.\n", "4. Often, a function is available to operate on single frames.\n", "\n", "**However, not all analysis uses this model. It is important to check the documentation for each analysis.** You can also see examples in the [Example gallery](https://userguide.mdanalysis.org/stable/examples/README.html).\n", "\n", "Below, simple RMSD analysis is shown. The `rms` module follows the interface above." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### RMSD" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Not all sub-modules of MDAnalysis are imported with `import MDAnalysis`. Most analysis modules have to be imported explicitly. " ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [], "source": [ "from MDAnalysis.analysis import rms" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "MDAnalysis provides a `rmsd()` function for calculating the RMSD between two numpy arrays of coordinates." ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "6.852774844656239" ] }, "execution_count": 36, "metadata": {}, "output_type": "execute_result" } ], "source": [ "bb = u.select_atoms('backbone')\n", "\n", "u.trajectory[0] # first frame\n", "first = bb.positions\n", "\n", "u.trajectory[-1] #last frame\n", "last = bb.positions\n", "\n", "rms.rmsd(first, last)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "An `RMSD` class is also provided to operate on trajectories. \n", "\n", "Below, the `RMSD` class is created. \n", "\n", "* The first argument is the `AtomGroup` or `Universe` for which the RMSD is calculated. \n", "* As a reference `AtomGroup` or `Universe` is not given as the second argument, the default is to align to the current frame of the first argument. Here it is set to the first frame. \n", "* We choose to align the trajectory over the backbone atoms, and then compute the RMSD for the backbone atoms (`select`). \n", "* Then, without re-aligning the trajectory, the RMSD is also computed (`groupselections`) for the $C_{\\alpha}$ atoms (`name CA`) and every protein atom (`protein`).\n", "\n", "The RMSD is computed when we call `.run()`." ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 37, "metadata": {}, "output_type": "execute_result" } ], "source": [ "u.trajectory[0] # set to first frame\n", "rmsd_analysis = rms.RMSD(u, select='backbone', groupselections=['name CA', 'protein'])\n", "rmsd_analysis.run()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The results are stored in the `.rmsd` attribute. This is an array with the shape `(n_frames, 2 + n_selections)`." ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(98, 5)\n" ] } ], "source": [ "print(rmsd_analysis.rmsd.shape)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can interpret this as an array with 98 rows and 5 columns. Each row is the RMSD associated with a frame in the trajectory. The columns are as follows:\n", "\n", "1. Frame number\n", "2. Time (ps)\n", "3. RMSD (backbone)\n", "4. RMSD (C-alpha)\n", "5. RMSD (protein)\n", "\n", "We can turn this into a `pandas` DataFrame and plot the results." ] }, { "cell_type": "code", "execution_count": 39, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
BackboneC-alphasProtein
Time (ps)
1.06.391203e-074.263638e-085.443850e-08
2.04.636592e-014.235205e-016.934167e-01
3.06.419340e-015.939111e-018.748416e-01
4.07.743983e-017.371346e-011.052780e+00
5.08.588600e-018.279498e-011.154986e+00
\n", "
" ], "text/plain": [ " Backbone C-alphas Protein\n", "Time (ps) \n", "1.0 6.391203e-07 4.263638e-08 5.443850e-08\n", "2.0 4.636592e-01 4.235205e-01 6.934167e-01\n", "3.0 6.419340e-01 5.939111e-01 8.748416e-01\n", "4.0 7.743983e-01 7.371346e-01 1.052780e+00\n", "5.0 8.588600e-01 8.279498e-01 1.154986e+00" ] }, "execution_count": 39, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import pandas as pd\n", "\n", "rmsd_df = pd.DataFrame(rmsd_analysis.rmsd[:, 2:],\n", " columns=['Backbone', 'C-alphas', 'Protein'],\n", " index=rmsd_analysis.rmsd[:, 1])\n", "rmsd_df.index.name = 'Time (ps)'\n", "rmsd_df.head()" ] }, { "cell_type": "code", "execution_count": 40, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 40, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "rmsd_df.plot(title='RMSD')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "See the [the RMSD and alignment notebooks](https://userguide.mdanalysis.org/stable/examples/analysis/README.html#alignments-and-rms-fitting) for more information." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## References" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "When using MDAnalysis in published work, please cite both these papers:\n", "\n", "* N. Michaud-Agrawal, E. J. Denning, T. B. Woolf, and O. Beckstein. MDAnalysis: A Toolkit for the Analysis of Molecular Dynamics Simulations. *J. Comput. Chem.* **32** (2011), 2319–2327. doi:[10.1002/jcc.21787](http://dx.doi.org/10.1002/jcc.21787)\n", "\n", "* R. J. Gowers, M. Linke, J. Barnoud, T. J. E. Reddy, M. N.\n", " Melo, S. L. Seyler, D. L. Dotson, J. Domanski, S. Buchoux, I. M. Kenney,\n", " and O. Beckstein. [MDAnalysis: A Python package for the rapid analysis of\n", " molecular dynamics simulations](http://conference.scipy.org/proceedings/scipy2016/oliver_beckstein.html). In S. Benthall and S. Rostrup, editors,\n", " *Proceedings of the 15th Python in Science Conference*, pages 98-105,\n", " Austin, TX, 2016. SciPy. doi:[10.25080/Majora-629e541a-00e](https://doi.org/10.25080/Majora-629e541a-00e)\n", " \n", "MDAnalysis includes many algorithms and modules that should also be individually cited. For example, if you use the `MDAnalysis.analysis.rms` or `MDAnalysis.analysis.align` modules, please cite:\n", "\n", "* Douglas L. Theobald. Rapid calculation of RMSD using a\n", " quaternion-based characteristic polynomial. *Acta Crystallographica A*\n", " **61** (2005), 478-480.\n", "* Pu Liu, Dmitris K. Agrafiotis, and Douglas L. Theobald. Fast\n", " determination of the optimal rotational matrix for macromolecular\n", " superpositions. *J. Comput. Chem.* **31** (2010), 1561–1563.\n", " \n", "The primary sources of each module will be in their documentation." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Automatic citations with duecredit" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Citations can be also be automatically generated using `duecredit`. [Complete installation and usage instructions can be found in the user guide](https://mdanalysis.org/UserGuide/references.html), but it is simple to generate a list of citations for your python script `my_script.py`.\n", "\n", "```console\n", "$ python -m duecredit my_script.py\n", "```\n", "\n", "This extracts citations into a hidden file, which can then be exported to different formats. For example, to display them as BibTeX, use the command:\n", "\n", "```console\n", "$ duecredit summary --format=bibtex\n", "```" ] } ], "metadata": { "celltoolbar": "Raw Cell Format", "kernelspec": { "display_name": "Python (mda-user-guide)", "language": "python", "name": "mda-user-guide" }, "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.8.3" }, "nbsphinx-toctree": { "maxdepth": 2, "numbered": true }, "toc": { "base_numbering": 1, "nav_menu": {}, "number_sections": false, "sideBar": true, "skip_h1_title": false, "title_cell": "Table of Contents", "title_sidebar": "Contents", "toc_cell": false, "toc_position": {}, "toc_section_display": true, "toc_window_display": false } }, "nbformat": 4, "nbformat_minor": 2 }