Rotamerically Induced Perturbations

Rotamerically Induced Perturbations

The Rotamerically Induced Perturbation (RIP) method generates local perturbations that are capable of inducing several Ångstroms of conformational change in just picoseconds of a Molecular-Dynamics (MD) simulation. It is particularly useful for identifying potentially mobile loops and helices in a protein structure.

A good example (on the right) is the RIP perturbation on TRP-83 in the Ligand-Binding Domain of the Estrogen Receptor, which produces a dramatic 10 Å motion of the allosteric effector Helix 12 in just 10 ps of simulation.


To get an idea of what RIP is capable of, check out the gallery of large conformational changes.

I have carried out the RIP flexibility analysis for 36 different structures, including a bunch of proteases, nuclear-receptors, PDZ domains (apo and ligand-bound), and several of the usual suspects.

For a quick 10 minute test to see if RIP works, follow the instructions to simulate the enkephalin peptide.

To illustrate how to properly use the RIP scripts, here is a detailed worked example for a flexibility analysis of the zinc-finger mimic .

Download and Installation

The RIP package is a series of PYTHON scripts that runs AMBER11. It has been tested on a MacOSX and LINUX environment:

You can run the scripts directly in its directory, or put the scripts in the PATH of your shell resource file. It's also a good idea to add the location of the scripts to the PYTHONPATH environment variable so that you can import the library into your own PYTHON scripts.

Pre-requisites. The RIP scripts relies on quite a few other packages. For basic functionality, you will need to install the following before anything will work:

Alas AMBER costs ~$400, but it's the MD package I know best, which has a decent GBSA force-field that is necessary for RIP to work (otherwise the energies will leech into the solvent). RIP requires AMBER on the command-line: make sure the AMBER programs are in the system PATH. This version of RIP has been tested with AMBER11.

PYTHON is available on most systems, but I've only tested it on PYTHON 2.5 and PYTHON 2.6. RIP does not work with PYTHON 3.0 as the external modules have not been ported.

For the PYTHON library NUMPY, the best way is to install the python package manager PIP, then at the command line:

sudo pip install numpy

Optional Packages. Although the flexibility analysis generates results as text files, there is an option that generates viewable images in HTML format from the text files. To do that, you will also need to install the following:

In particular the scripts, SHOWPDB.PY and PYTRAJ.PY, are wrappers for PYMOL to generate images and movies of the simulations. An older version of PYMOL is freely available that should work with this library. You will need to obtain an academic license for the latest version.

Once PYMOL is installed, you must edit SHOWPDB.PY and PYTRAJ.PY by finding the variable 'pymol' in the scripts (should be at the top of the file), and setting 'pymol' to the full pathname of the PYMOL executable, which on my machine is:

pymol = "/Applications/"

For the PYTHON libraries MATPLOTLIB, PIL and MAKO, the best way is to install with PIP (if you're lucky):

sudo pip install matplotlib pil mako

Before you run the scripts, don't forget to

source ~/.cshrc  [or]  source ~/.bash_profile

General Schema of the Library

The Rotamer Induced Perturbation is implemented as a PYTHON wrapper around the AMBER molecular dynamics package. Whilst portions of the wrapper library also works with NAMD, this has yet to be tested extensively.

The RIP scripts rests on PDBSTRUCT, a light-weight library that reads straight-forward PDB files and returns a PYTHON object that allows fine-grained manipulation of a protein structure. The PDBSTRUCT objects can be written back to PDB files or MD restart files.

The RIP scripts provides a abstraction layer to the MD simulations, where in the future, other different packages may be plugged in. At the moment, only AMBER has been extensively tested, where AMBER was chosen because it supports implicit solvent force-fields. The scripts pre-processes PDB files (removing alternate conformations, adding terminii groups, defining disulfide bonds, etc.) so that they can be automatically fed into the AMBER topology preparation program TLEAP. The RIP scripts then run short 100 fs constant-energy MD trajectories. Between each run, velocities are directly changed, which effectively implements RIP in 100 fs pulses.

Finally, there are a bunch of analysis tools, including wrapper scripts for PYMOL, AMBER trajectory readers, and routines to analyze flexibility.

Running on a Cluster

Running the RIP perturbations on a single computer is slow. Fortunately, as RIP perturbations are independent of each other, they do not cross-talk and can be easily farmed out to nodes on a parallel cluster.

I imagine that everybody has their own cluster set-up - incidentally, I developed RIP on a Rocks Cluster - so the exact method of parallelization will be different. Regardless, PERTURB.PY is written such that independent copies of PERTURB.PY can be run simultaneously. Each copy of PERTURB.PY reads all CONFIG files found in the starting directory. Given the list of residues in a CONFIG file, PERTURB.PY will only start a RIP for a residue if the directory for that residue has not been created. Otherwise it will pass over to the next one. Thus only one copy of PERTURB.PY will be responsible for the simulation of a single RIP perturbation. In order to (hopefully) avoid race conditions, PERTURB.PY will pause for a few random microseconds between each residue.

Before the RIP perturbations can be run, the system needs to be pre- equilibrated. Since all the RIP perturbations start from the same equilibration, the first copy of PERTURB.PY will write the file 'equil_started' and carry out the equilibration. The other copies of PERTURB.PY will wait for the first copy to write the file 'equil_finished' before starting their scheduled RIP perturbations.

In your cluster, make sure all nodes have access to the same disk drive, and run one copy of PERTURB.PY on each node. The input parameter to PERTURB.PY is the directory that contains the CONFIG file.

In terms of timings, I've found that for AMBER implicit solvent simulations, the simulation time scales as ~ n1.6 for n residues. Since RIP carries out n independent simulations of equal length, the simulation time for an RIP analysis should scale at ~ n2.6. For very large proteins, one might focus on residues within 10 Ångstroms of the surface, as perturbation deep inside the protein will not be able to generate any large conformational changes.

More Info

Reference: "Probing the Flexibility of Large Conformational Changes in Protein Structures through Local Perturbations" by Bosco K. Ho and David A. Agard. PLoS Comput Biol 5(4): e1000343.

This work was funded by HHMI in the laboratory of David Agard.

I have released the code under the GPL2 license. Everybody is free to do whatever you want with it, but if you release a modified version of it, it too must be free to use and modify.

If you have questions or bug reports, email:

© May 2011, Bosco K. Ho.


blog comments powered by Disqus