GROMACS Tutorial

KALP15 in DPPC

Justin A. Lemkul

Department of Pharmaceutical Sciences, University of Maryland, Baltimore

This tutorial will guide the user through the preparation and simulation of a simple membrane protein, in this caseKALP15, in a model membrane, DPPC. The tutorial assumes the user has already successfully completed the Lysozymetutorial, some other tutorial, or is otherwise well-­versed in GROMACS simulation methods and topology organization. Thelevel of detail in this tutorial will be focused on membrane protein-­specific considerations, and will not provide anexhaustive explanation of every step, as with the Lysozyme tutorial.

This tutorial assumes you are using GROMACS version 4.5.3 or newer. Many of the filenames, command line options,and other assorted details will be very different if you attempt to use a pre-­4.5 version of GROMACS. For the GROMACS2013 workshop at the University of Virginia, it is assumed that you are using GROMACS version 4.6.3.

Step One: Prepare the Topology

The protein we will be working with is the KALP model peptide, denoted KALP15, which has a sequence of: Ac-­GKK(LA)4LKKA-­NH2. The protocol described here is based on a system built by Kandasamy and Larson in a study ofhydrophobic mismatch. The original reference can be found here.

The peptide was prepared in-­house using the xLeap module of AmberTools, using ideal backbone geometry of an α-­helix(φ = -­60°, ψ = -­40°). The .pdb file was oriented along the z-­axis using editconf -­princ, followed by a rotation about the yaxis. Note that in GROMACS-­3.3.x, the -­princ option oriented the long axis of the structure (in this case, the helix axis)along the z-­axis by default, but this option has changed as of GROMACS-­4.0.4, which orients the long axis along the x-­axis. If you want to skip the construction of this peptide, the properly oriented structure can be found here.

Execute pdb2gmx by issuing the following command:

pdb2gmx -f KALP-15_princ.pdb -o KALP-15_processed.gro -ignh -ter -water spc

When prompted, choose the GROMOS96 53A6 parameter set. Choose "None" for the termini;; since we have addedacetyl and amide capping groups to the N-­ and C-­termini, respectively, we do not want pdb2gmx to build the normalamine and carboxyl groups. Instead, we want pdb2gmx to add connectivity to our capping groups. The -­ignh flag tellspdb2gmx to ignore the H atoms in the input. By default, xLeap gave us an all-­atom structure (since the AMBER forcefields use explicit hydrogen representation). Due to AMBER naming conventions, these H atoms may not have the samenomenclature as those of the GROMOS96 force field. If we tell pdb2gmx to ignore all input H atoms, it will add back only

those that it needs.

Now we will need to make some alterations to the topology.

Step Two: Modify the Topology

The lipid bilayer we will be simulating is DPPC (dipalmitoyl phosphatidylcholine), so we need parameters for it as well.

But if pdb2gmx is designed to handle only proteins, nucleic acids, and a finite amount of cofactors, where do we get

parameters for this molecule, and how do we apply them to our system?

There is no universal force field for simulating all proteins, nucleic acids, lipids, carbohydrates, and arbitrary small

molecules. Since we are simulating a system that contains both protein and lipids, how do we solve the force field

problem? Under GROMACS, the most widely-­used parameters for the lipid component of membrane-­protein simulations

are commonly called "Berger lipids," derived by Berger, Edholm, and Jähnig (ref). These parameters can be combined

with a GROMOS representation of the protein.

The so-­called "Berger lipids" are somewhat of a hybrid between GROMOS atomtypes and OPLS partial charges. Since

the long alkane chains are poorly represented by GROMOS bonded parameters, a Ryckaert-­Bellemans dihedral potential

is used, and a scaling factor of 0.125 is applied to Lennard-­Jones 1-­4 interactions. These lipid parameters are distributed

by D. Peter Tieleman, through his website. While you are there, download the following files:

dppc128.pdb -­ the structure of a 128-­lipid DPPC bilayer

dppc.itp -­ the moleculetype definition for DPPC

lipid.itp -­ Berger lipid parameters

So what exactly is lipid.itp, and how do you use it? Think of this analogy: gromos53a6.ff/forcefield.itp is to your protein

what lipid.itp is to the lipids. Essentially, lipid.itp contains all the atom types, nonbonded parameters, and bonded

parameters for a large class of lipids, much like how forcefield.itp, ffnnonbonded.itp, and ffbonded.itp function in relation to

a protein. That said, we cannot simply #include "lipid.itp" within our topology, since it is at the same level

(precedence) as forcefield.itp.

To use the parameters in lipid.itp, we will have to make some changes to our pre-­packaged gromos53a6.ff/forcefield.itp.

Make a new directory in your working directory called "gromos53a6_lipid.ff" and copy the following files from

gromos53a6.ff into it:

aminoacids.rtpaminoacids.hdbaminoacids.c.tdbaminoacids.n.tdbaminoacids.r2baminoacids.vsdff_dum.itpffnonbonded.itpffbonded.itpforcefield.itp ions.itpspc.itpwatermodels.dat

Next, create a forcefield.doc file that contains a description of the force field parameters in it. Mine contains somethinglike:

GROMOS96 53A6 force field, extended to include Berger lipid parameters

Next, copy and paste the entries in the [ atomtypes ], [ nonbond_params ], and [ pairtypes ] sections from lipid.itpinto the appropriate headings within ffnonbonded.itp. You will find that the lipid.itp [ atomtypes ] section lacks atomicnumbers (the at.num column), so add these in. The newly-­modified lines should be:

LO 8 15.9994 0.000 A 2.36400e-03 1.59000e-06 ;carbonyl O, OPLS LOM 8 15.9994 0.000 A 2.36400e-03 1.59000e-06 ;carboxyl O, OPLS LNL 7 14.0067 0.000 A 3.35300e-03 3.95100e-06 ;Nitrogen, OPLS LC 6 12.0110 0.000 A 4.88800e-03 1.35900e-05 ;Carbonyl C, OPLS LH1 6 13.0190 0.000 A 4.03100e-03 1.21400e-05 ;CH1, OPLS LH2 6 14.0270 0.000 A 7.00200e-03 2.48300e-05 ;CH2, OPLS

LH2 6 14.0270 0.000 A 7.00200e-03 2.48300e-05 ;CH2, OPLS LP 15 30.9738 0.000 A 9.16000e-03 2.50700e-05 ;phosphor, OPLS LOS 8 15.9994 0.000 A 2.56300e-03 1.86800e-06 ;ester oxygen, OPLS LP2 6 14.0270 0.000 A 5.87400e-03 2.26500e-05 ;RB CH2, Bergers LJ LP3 6 15.0350 0.000 A 8.77700e-03 3.38500e-05 ;RB CH3, Bergers LJ LC3 6 15.0350 0.000 A 9.35700e-03 3.60900e-05 ;CH3, OPLS LC2 6 14.0270 0.000 A 5.94700e-03 1.79000e-05 ;CH2, OPLS

In the [ nonbond_params ] section, you will find the line ";; parameters for lipid-GROMOS interactions." Delete thisline and all of the subsequent lines in this section. These nonbonded combinations are specific to the deprecatedffgmx force field. Removing these lines allows the interactions between the protein and the lipids to be generated by thestandard combination rules of GROMOS96 53A6. Non-­bonded interactions involving atom type HW are also present;;since these are all zero you can delete these lines as well, or otherwise rename HW as H to be consistent with theGROMOS96 53A6 naming convention. If you do not rename these lines or remove them, grompp will later fail with afatal error.

Append the contents of the [ dihedraltypes ] to the corresponding section of ffbonded.itp. Do not be concerned thatthese lines look a bit different. They are Ryckaert-­Bellemans dihedrals, which differ in form from the standard periodicdihedrals used in the default GROMOS96 53A6 force field. Finally, change the #include statement in your topol.top from:

#include "gromos53a6.ff/forcefield.itp"

to:

#include "gromos53a6_lipid.ff/forcefield.itp"

Lastly, we need to include the specific parameters for our DPPC molecules. The process for doing so is quite simple. Justadd the line #include "dppc.itp" in your topol.top, somewhere after the position restraints section for the protein, whichdefines the end of the protein [ moleculetype ] definition. Doing so is analogous to adding any other small molecule orsolvent into the topology. In this section and throughout this tutorial, text in green will denote lines that you should add,while other text (in black) are lines that should already be present in the topology prior to the modification indicated.

; Include Position restraint file#ifdef POSRES#include "posre.itp"#endif

; Include DPPC chain topology#include "dppc.itp"

; Include water topology#include "gromos53a6_lipid.ff/spc.itp"

It is also possible to use the OPLS-­AA force field to represent your protein. You will have to make some modifications tolipid.itp so that it is consistent with OPLS conventions. For information on how to do this, read the following links:

http://lists.gromacs.org/pipermail/gmx-­users/2006-­May/021416.htmlhttp://lists.gromacs.org/pipermail/gmx-­users/2006-­August/023587.htmlhttp://lists.gromacs.org/pipermail/gmx-­users/2006-­September/023761.html

For a bit more theory on force field combination rules and theory, consult this document. Thanks to Chris Neale forproviding this link.

Regardless of which setup you choose, you must demonstrate that your model is reasonable. The particular parametercombinations described here have been shown to work in-­house and according to reports by other users. It is up to you toconvince your audience (i.e., reviewers) that you know what you are doing and that your model is valid.

If you have correctly followed all of the steps above, you will have a fully-­functional force field that can be used to processother membrane proteins with pdb2gmx. Doing so removes the need to manually hack topol.top after the fact. Placing thenew gromos53a6_lipid.ff directory in $GMXLIB will allow you to use this force field system-­wide.

Step Three: Defining the Unit Cell & Adding Solvent

Defining a unit cell for a membrane protein is considerably more complicated than for a protein in water. There are

several key steps in building the unit cell:

1. Orient the protein and membrane in the same coordinate frame

2. Pack the lipids around the protein

3. Solvate with water

1. Orient the protein and membrane

We have already aligned the KALP peptide using editconf. The bilayer lies in the x-­y plane, with the normal along the z-­axis. Convert the dppc128.pdb to .gro format with editconf and remove the initial periodicity. The latter step is easily

accomplished through the use of trjconv:

(1) Generate a .tpr file for a DPPC-­only system using grompp. You can use any valid .mdp file and a topology

corresponding to pure DPPC. An example .mdp file can be found here and such a topology can be found here. Note how

simple the topology is. It includes dppc.itp and spc.itp to read parameters for DPPC and water;; it's that simple! Run

grompp:

grompp -f minim.mdp -c dppc128.gro -p topol_dppc.top -o em.tpr

You may receive a fatal error like this one, but in this case it is safe to use -maxwarn 1 with the above command. Thereason that doing so is acceptable is explained here. Please note that this step is the only one in which topol_dppc.topwill be used. It serves no other purpose and you should not use it in any remaining step in this tutorial.

It is not necessary to run a complete energy minimization procedure on the bilayer, although you can if you want. The .tpr

file contains information about bonding and periodicity, so it can, in a sense, be used to reconstruct "broken" molecules.

(2) Use trjconv to remove periodicity:

trjconv -s em.tpr -f dppc128.gro -o dppc128_whole.gro -pbc mol -ur compact

Now, take a look at the last line of this .gro file;; it corresponds to the x/y/z box vectors of the DPPC unit cell. We need to

orient the KALP peptide within this same coordinate frame, and place the center of mass of the peptide at the center of

this box:

editconf -f KALP_processed.gro -o KALP_newbox.gro -c -box 6.41840 6.44350 6.59650

The center of our system now lies at (3.20920, 3.22175, 3.29825), half of each box vector. This is a GROMACS

convention. Note that other systems you wish to simulate may not be symmetrical with respect to the membrane, and thus

the above command must be modified to something like the following:

editconf -f protein.gro -o protein_newbox.gro -box (membrane box vectors) -center x y z

In the above command, x y z represents the center of mass such that the protein is properly placed. Placement should bebased on experimental knowledge of membrane positioning, or intuition based on the chemical composition of your

particular protein.

2. Pack the lipids around the protein

The easiest method I have found so far for packing lipids around an embedded protein is the InflateGRO methodology

(ref), available here. First, concatenate the protein and bilayer structure files:

cat KALP_newbox.gro dppc128_whole.gro > system.gro

Remove unnecessary lines (the box vectors from the KALP structure, the header information from the DPPC structure)

and update the second line of the coordinate file (total number of atoms) accordingly.

The authors of the InflateGRO script recommend using a very strong position-­restraining force on protein heavy atoms to

ensure that the position of the protein does not change during EM. Add a new #ifdef statement to your topology, one that

will call a special set of position restraints, such that your topology now contains a section like:

; Include Position restraint file

#ifdef POSRES

#include "posre.itp"

#endif

; Strong position restraints for InflateGRO

#ifdef STRONG_POSRES

#include "strong_posre.itp"

#endif

; Include DPPC chain topology

#include "dppc.itp"

; Include water topology

#include "gromos53a6_lipid.ff/spc.itp"

Now, generate this new position restraint file using genrestr:

genrestr -f KALP_newbox.gro -o strong_posre.itp -fc 100000 100000 100000

In the .mdp file used for the minimizations, add a line "define = -­DSTRONG_POSRES" to make use of these new positionrestraints. Then, simply follow the InflateGRO instructions (contained in the script itself), a procedure that is easilyscripted. Scale the lipid positions by a factor of 4:

perl inflategro.pl system.gro 4 DPPC 14 system_inflated.gro 5 area.dat

Note how many lipids were deleted and update the [ molecules ] directive of your topology accordingly. Run energyminimization. Then, scale down the lipids by a factor of 0.95 (assuming you have used default names, the result of theminimization is called "confout.gro"):

perl inflategro.pl confout.gro 0.95 DPPC 0 system_shrink1.gro 5 area_shrink1.dat

Follow this up by another round of EM. During the "shrinking" steps, be sure to change the cutoff value to 0, or else youwill continue to delete lipids! After 26 iterations of scaling down by 0.95, I reached an area per lipid of ~71 Å2, above theexperimental value of ~62 Å2. Since the script tends to overestimate the area per lipid, this value is good enough tocontinue to equilibration.

3. Solvate with water

Solvating a protein is a trivial task with genbox. Solvating a membrane protein system is not so simple, since genbox hasa tendency to fill gaps in the lipid acyl chains with random water molecules. The quickest way I have found to solvatemembrane systems is to make a local copy of vdwradii.dat and change the value of C from 0.15 to 0.375. Doing so willcause genbox to assign carbon atoms an artificially large van der Waals radius, thus making addition of water within thelipids less likely. After solvating, check your structure to be sure no water molecules are present in the hydrophobic coreof the bilayer. If there are a few stray molecules, you can either delete them manually, continue to adjust the van derWaals radius of carbon, or use one of the scripts found at the GROMACS site.

Be aware that using a large radius for carbon may also create artificial voids around proteins that protrude outside themembrane (since they also contain carbon) as well as the lipid headgroups (if they contain carbon, i.e. PC, PE, etc).These voids may require a bit of finesse during equilibration. Delete the local copy of vdwradii.dat before continuing.

Step Four: Adding Ions

Now that we have solvated our system, it is time to add neutralizing counterions. At this point, the process for continuingwith building our system is nearly identical to that of the lysozyme tutorial. The .mdp file used can be found here

grompp -f ions.mdp -c system_solv.gro -p topol.top -o ions.tpr

Since the KALP15 peptide contains 4 lysine residues, the peptide bears a net charge of +4e at physiological pH. Usegenion to add 4 CL-­ ions to neutralize this charge:

genion -s ions.tpr -o system_solv_ions.gro -p topol.top -pname NA -nname CL -nn 4

Step Five: Energy Minimization

This step is just like in any other simulation. Assemble the binary input using grompp using this input parameter file:

grompp -f minim.mdp -c system_solv_ions.gro -p topol.top -o em.tpr

Invoke mdrun:

mdrun -v -deffnm em

As with any other simulation, verify that the values of Epot and Fmax are reasonable before continuing. Membrane proteinsystems can be tricky, because there are a number of potential problems. If your system is not converging, consider thefollowing factors:

1. Intra-­headgroup hydrogen bonding, like in PE or PG headgroups. Sometimes simulations collapse because theheadgroups fold in on themselves within voids in the solvent. There are several potential solutions to this problem(and others you may encounter):

Use position restraints or freeze groups during equilibration until the solvent is optimized around the lipidheadgroups.Reduce the charges on the H atoms (all the way to zero, if necessary) Restore the charges before continuing!Add [ exclusions ] within the topology between H and phosphate O atoms Remove the exclusions beforecontinuing!

2. Acyl chain overlap can occur during packing. Run InflateGRO carefully, and do not attempt to over-­pack your lipids.3. Protein-­lipid overlap. Did you choose an appropriate cut-­off value in the initial InflateGRO step?4. Water-­headgroup and ion-­headgroup overlap. Sometimes genbox and genion are not smart, especially regarding

random placement of ions. A CL-­ next to a phosphate can send the ion (or lipid) careening across the simulationbox!

Now that our system is at an energy minimum, we can begin real dynamics.

Step Six: Equilibration

Equilibration will be conducted much like in the case of a solvated protein. Generally a short NVT equilibration phase isfollowed by a longer NPT phase. The reason for this procedure is that we are now dealing with a heterogenous system,with both water and DPPC acting as solvent. Such heterogeneity requires a longer equilibration process. Water has to re-­orient around the lipid headgroups and any exposed parts of the protein, and the lipids have to orient themselves around

the protein as well. Such processes take some time, and lipid equilibration may take several ns of simulation time.

For membrane protein simulations, we will need to create special index groups consisting of solvent + ions and protein +

lipids(explained below). To do this, use make_ndx:

make_ndx -f em.gro -o index.ndx

At the make_ndx prompt, enter "16 | 14" to merge the SOL and CL groups. The new groups should be called "SOL_CL"

by default.

Merge the Protein and DPPC groups by entering "1 | 13" at the make_ndx prompt. This group will be used for center-­of-­

mass motion removal (more on this shortly).

We will once again start with NVT (with the script found here), calling grompp and mdrun just as we did at the EM step:

grompp -f nvt.mdp -c em.gro -p topol.top -n index.ndx -o nvt.tpr

mdrun -deffnm nvt

Most of the parameters we are using are comparable to those in the lysozyme tutorial, with a few changes:

rlist, rcoulomb, rvdw = 1.2: We are using a 1.2-­nm short-­range cutoff for the neighborlist, electrostatics, and van der

Waals interactions. This has been done for computational efficiency reasons. Artifacts from truncation are

accommodated by the use of PME (for long-­range electrostatics) and dispersion correction (for vdW terms). In any

case, it is always an exercise for the user to demonstrate validity of any setup.

ref_t, gen_temp = 323: We must use a temperature that is above the phase transition temperature of the lipid. For

DPPC, 323 K is commonly used.

tc-­grps = Protein DPPC SOL_CL: Each group is coupled separately for increased accuracy. With an aqueous

protein, we specify "Protein Non-­Protein," with Non-­Protein containing solvent and ions. For a membrane protein,

Non-­Protein would contain the lipids as well, so we must explicitly couple the lipids and aqueous solvent

separately. Do not couple the ions separately from the solvent;; there are insufficient degrees of freedom in an ion-­only group to justify a separate temperature coupling group.

A new section pertaining to center-­of-­mass (COM) motion removal. Since interfacial systems (i.e., membrane-­water

systems) have a tendency to move laterally, the motion of the bilayer COM and solvent COM must be reset

separately. Otherwise, the phases may drift in opposite directions, such that the overall COM for the system is

unchanged, but artificial motion is still present. Note that our comm-­grps include Protein_DPPC;; since the protein is

embedded in the membrane, it is essentially part of the membrane. Removing its COM motion separately may lead

to spurious collisions. It is for this reason that we do not remove COM motion in separate groups for proteins in

water;; diffusion occurs in 3 dimensions in these systems. In a bilayer, motion is largely restricted to 2-­dimensional

motion.

Again, use g_energy to confirm that the temperature of the system has stabilized at 323 K before continuing. The choice

of temperature should be based on the physical properties of the lipid, most notably the phase transition temperature.

Some useful data that has been mined from the literature regarding area per lipid, phase transition temperatures, and/or

parameter derivation for various lipids is presented here (see below). Please read the references and understand their

implications. This list is not comprehensive;; the references point to examples of literature wherein these particular lipids

were used either for simulation or experimental work. The user should investigate further citations within these works, or

subsequent papers that have cited these. The list should also not be viewed as comprehensive, as many other lipids

have been successfully simulated. Presented here are some of the more common ones.

Lipid Name Area Per Lipid (Å2) Phase Transition (K) Reference

DPPC 62.9 -­ 64 315 J. Nagle (1993) Biophys. J. 64: 1476

DMPC 60.6 297 Wohlert and Edholm (2006) J. Chem. Phys.125: 204703

POPG 53 269 Dickey and Faller (2008) Biophys. J. 95: 2636

POPA 51-­52 301 Dickey and Faller (2008) Biophys. J. 95: 2636

POPC 65.8 271 Tieleman, et al. (1998) Biochem. 37: 17554

POPE 56 298 Tieleman, et al. (1998) Biochem. 37: 17554

DMTAP 71 310 Gurtovenko, et al. (2004) Biophys. J. 86: 3461

POPS 55 300 Mukhopadhyay, et al. (2004) Biophys. J. 86:1601

Having trouble with your system? Is it crashing during equilibration? Please see the Advanced Troubleshooting page.

Step Seven: Equilibration, Part 2

Now that the temperature is stable, we must equilibrate with respect to pressure. The NPT phase for a membrane proteinsystem is generally somewhat longer than for a simple aqueous protein, again due to the heterogeneity of the system.Here, we will conduct a 1-­ns NPT equilibration. The .mdp file can be found here.

There are a few changes in this .mdp file worth noting:

tcoupl = Nose-­Hoover: The Nosé-­Hoover thermostat is widely used in membrane simulations because it produces acorrect kinetic ensemble and allows for fluctuations that produce more natural dynamics. The Nosé-­Hooverthermostat is not appropriate for NVT equilibration, since it allows for such wide fluctuations. Begin with Berendsenor V-­rescale, and switch to Nosé-­Hoover at the beginning of NPT or production MD.pcoupltype = semiisotropic: Uniform pressure scaling (isotropic) is not appropriate for membranes. A bilayer shouldbe allowed to deform in the x-­y plane independently of the z-­axis. One can also use anisotropic pressure couplingfor membranes, but be aware that substantial skewing of the box vectors can occur over very long simulationtimeframes.There are now two values specified for both compressibility and ref_p, corresponding to values for the x-­y and zdimensions, respectively.

Now, proceed with grompp and mdrun, as usual. Since the simulation will be 1 ns in length, it is best to run it in parallelon a cluster. Note that GROMACS 4.5 introduces threading for parallelization, meaning that on a multi-­core workstation,an external MPI library is not required. For network-­connected clusters, MPI is still needed to node-­node communication.

grompp -f npt.mdp -c nvt.gro -t nvt.cpt -p topol.top -n index.ndx -o npt.tpr

On a multi-­core workstation, you can issue the following command, where X corresponds to the number of physical coreson the machine you wish to use:

mdrun -nt X -deffnm npt

On a cluster, you may need mpirun, so issue something like the following, where X corresponds to the number ofprocessors to be used:

mpirun -np X mdrun_mpi -deffnm npt

Analyze the pressure progression, again using g_energy. It is also advisable to verify that the box vectors have stabilized,

ensuring a stable lateral area of the membrane (Box-­X and Box-­Y).

Step Eight: Production MD

Upon completion of the two equilibration phases, the system is now well-­equilibrated at the desired temperature and

pressure. We are now ready to release the position restraints and run production MD for data collection. The process is

much like we have seen before. We will run a 1-­ns MD simulation, the .mdp file for which can be found here.

grompp -f md.mdp -c npt.gro -t npt.cpt -p topol.top -n index.ndx -o md_0_1.tpr

Again, execute mdrun in parallel:

Near the end of the grompp output, you should see a line like:

Estimate for the relative computational load of the PME mesh part: 0.26

We have managed to define parameters that adequately balance the PP:PME ratio, such that we should use a 3:1

PP:PME node ratio.

mdrun -nt X -deffnm md_0_1

To continue your simulation beyond 1 ns, making use of the checkpointing feature of GROMACS, refer to the GROMACS

site.

Step Nine: Analysis

There are several types of analyses that are particularly useful for membrane protein systems. A brief synopsis will be

given here. Several parameters that may be of interest:

1. Deuterium order parameters of the acyl chains

2. Density of the membrane environment

3. Area per lipid headgroup

4. Bilayer thickness (vertical dimension)

5. Lateral diffusion of the lipids

Other analyses should be considered, such as secondary structure of the peptide, RMSD, P-­N vector orientation, helix tilt,

etc. Most of these analyses will require the use of specialized index groups, generated by make_ndx.

1. Deuterium Order Parameters

For deuterium order parameter analysis, you will need an index group that contains only the carbons along the lipid acyl

chains. Each chain must be considered separately!

make_ndx -f md_0_1.tpr -o sn1.ndx

> a C34 > a C36 > a C37 > a C38 ... > a C50 > del 0-21 > q

What we have just done is create an index group for the sn-­1 chain of DPPC by matching all the atoms in one chain of thelipid with specific atoms names of carbons in the acyl chain. We then deleted all the unnecessary groups (del 0-­21). This

process should then be repeated for the sn-­2 chain (carbons C17, C19-­C31 to give "sn2.ndx").

To measure deuterium order parameters with the normal to the bilayer along the z-­axis, use the GROMACS tool g_order:

g_order -s md_0_1.tpr -f md_0_1.xtc -n sn1.ndx -d z -od deuter_sn1.xvg

Deuterium order parameters can be helpful in verifying whether or not your membrane entered a gel phase during the

simulation.

2. Density of the Membrane

One generally sees analysis of membrane density broken down into several different groups -­ lipid headgroups, acyl

chains (sometimes broken down even further to glycerol, methylene, and terminal methyl groups), protein, and solvent.

The latter two groups are standard, and do not require any special manipulation. An index group for the lipid headgroups

and acyl chains of DPPC can be created by entering the following:

make_ndx -f md_0_1.tpr -o density_groups.ndx

> 12 & a C1 | a C2 | a C3 | a N4 | ... | a O11> name 22 Headgroups> 12 & a C12 | a C13 | a O14 | ... | a C50> name 23 Tails> q

Now analyze each of these groups separately (note that Protein and SOL are already included in the index file) using

g_density:

g_density -s md_0_1.tpr -f md_0_1.xtc -n density_groups.ndx -o headgroups.xvg -d Z

Repeat the process for the other groups you wish to analyze.

3. & 4. Area per Lipid Headgroup and Bilayer Thickness

There is no GROMACS tool capable of calculating area per lipid headgroup in the presence of a membrane protein. For a

pure membrane, this quantity is simply (Box-­X * Box-­Y)/(# of lipids). In the case of an embedded protein, such as KALP15,

how much space does the protein occupy? We have developed a program that addresses this problem, GridMAT-­MD. It

measures area per lipid headgroup, as well as bilayer thickness as a projection across the 2-­D bilayer plane (ref).

Analyzing area per lipid headgroup is a valuable parameter when verifying that your membrane did not inappropriately

enter a gel phase during the simulation.

5. Lateral Diffusion of Lipids

GROMACS provides a tools called g_msd to measure diffusion coefficients. One of its derivative functions is to measure

lateral diffusion. To execute g_msd, you will need to choose one reference atom per lipid, typically P8 of the DPPC

headgroup. Make an index group for these atoms:

make_ndx -f md_0_1.tpr -o p8.ndx

> a P8 > q

Now, execute g_msd:

g_msd -s md_0_1.tpr -f md_0_1.xtc -n p8.ndx -lateral z

Summary

You have now hopefully been successful in building and simulating a simple membrane protein system. Note that 1 ns ofsimulation is exceptionally short for any system, especially a membrane protein. Lipid equilibration can take upwards of10-­20 ns. The timeframe used here is for instructional purposes only, and the data you generate likely have no physicalmeaning, since the timeframe is too short. The .mdp files provided here serve as examples only, and should not beconsidered broadly applicable to all systems. Review the literature and the GROMACS manual for adjustments to thesefiles for efficiency and accuracy purposes.

If you have suggestions for improving this tutorial, if you notice a mistake, or if anything else is unclear, please feel free toemail me. Please note: this is not an invitation to email me for GROMACS problems. I do not advertise myself as a privatetutor or personal help service. That's what the gmx-­users list is for. I may help you there, but only in the context ofproviding service to the community as a whole, not just the end user.

Happy simulating!