Building a shape-based coarse-grained membrane

A building block of the SBCG lipid model consists of two beads - a ``head" bead and a ``tail" bead - connected by a harmonic bond. This is the simplest representation that preserves the elongated shape of a real lipid molecule as well as the separation of hydrophobic and hydrophilic parts. Even so, if we were to represent a single all-atom lipid, which contains less than 150 atoms, in this way, the resulting beads would be too light to accommodate the long timesteps desired in a SBCG simulation. We therefore have to view SBCG lipid ``molecules'' in a more abstract sense, allowing that one SBCG ``molecule'' represents a small patch of all-atom lipids, rather than one real all-atom lipid molecule.

At this level of coarse-graining, the differences between lipids of different types (e.g. POPE vs. POPC or DOPC) become almost negligible. However, SBCG lipids can be matched to all-atom simulations by considering qualities such as the bilayer thickness and area per lipid. Since the lipid bilayer thickness is approximated to be 50 Å, each bead therefore has a diameter of 12.5 Å. One SBCG lipid occupies then a cross-sectional area of approximately 156 Å$^2$. In this tutorial, we will be working mainly with DOPC, which occupies 72.5 Å$^2$ per lipid. One SBCG DOPC lipid must then represent approximately 2.2 all-atom DOPC lipids. The mass of the 2.2 lipids is divided equally among the ``head" and the ``tail" beads, meaning that the ``head" bead actually represents both the head groups of the lipids and some portion of the tails, and the ``tail" bead represents the remainder of the lipid tails. Since one DOPC lipid contains 138 atoms, 2.2 lipids corresponds to $\sim$300 atoms, or $\sim$150 atoms per SBCG bead, consistent with the level of coarse graining used for the BAR domain proteins. In many circumstances, one will want to include charged as well as neutral lipids. We therefore will also define negatively charged SBCG lipids to represent DOPS to use in a mixed DOPC/DOPS membrane. Since DOPC is the main lipid, and we have already determined that one SBCG lipid represents 2.2 all-atom lipids, this convention is kept for DOPS. Since DOPS is slightly heavier, the extra mass is added to the DOPS ``head" bead so that the ``tail" beads of the two lipids can remain identical. The DOPS ``head" bead is given a charge of -2.2 to account for the fact that it incorporates 2.2 all-atom DOPS lipids. All these characteristics are reflected in the provided topology file for SBCG lipids, 3_cg_membrane/lipid-ion.top.

The bond parameters and nonbonded parameters for the SBCG lipids were chosen to consistently reproduce the bilayer thickness and area per lipid values in all-atom simulations, as described in detail in Arkhipov et al., Biophys. J., 95:2806, 2008. Since we do not run simulations in this section, a parameter file is not necessary at this point. We will need the parameter file later, when we run a CG simulation of a combined lipid-protein system.

Figure: Shape-based coarse-grained lipid bilayer. Each SBCG lipid is comprised of a ``head" bead (blue) and a ``tail" bead (gray) connected by a bond. The diameter of one bead is 12.5 Å, and the thickness of the bilayer is 50 Å.

Generate a patch of coarse-grained membrane.

In this section, we will create a patch of SBCG DOPC lipids. The script 3_cg_membrane/generate_patch.tcl is provided for this task. The usage of this script is
generate_patch Nx Ny dx dy hname tname rname outPDB
where Nx and Ny are the number of lipids in the x and y directions, dx and dy are the lipid spacings in the x and y directions (which will be 12.5 for our case), hname is the name of the head bead (PCH), tname is the name of the tail bead (DOT), rname is the residue name of the lipid (DOPC), and outPDB is the desired name of the output PDB file.

1. To build a patch of DOPC lipids with this script, navigate to the folder 3_cg_membrane and type the following in the VMD Tk Console:
$>$ source generate_patch.tcl
$>$ generate_patch 37 9 12.5 12.5 PCH DOT DOPC dopc.pdb
This will create a 37 $\times$ 9 DOPC patch to be used later in this tutorial.

2. To create a corresponding psf file, use the provided psfgen script 3_cg_membrane/build-dopc.tcl by typing the following into the Tk Console:
$>$ source build-dopc.tcl

3. One may alternatively use the AutoPSF plugin in VMD to create a psf file. To do this, navigate to Extensions $\rightarrow$ Modeling $\rightarrow$ Automatic PSF Builder. In Step 1, check that dopc.pdb is set as the input molecule, and set the desired output file name. Under ``topology files'' delete the default all-atom topology and then add the SBCG topology file lipid-ion.top by clicking ``Add'' and selecting lipid-ion.top. In Step 2, Select ``Everything'' and click ``Guess and split chains using current selections''. In Step 3, click ``Create Chains" to create the psf file.

4. Load the resulting pdb and psf files into VMD. You should see a 37 $\times$ 9 array of SBCG lipids.

Add charged lipids to the membrane patch.

We will now create a combined DOPC/DOPS membrane by changing some of the DOPC lipids to DOPS. The provided script 3_cg_membrane/mutate-to-dops.tcl selects 30% of the lipids at random and changes them to DOPS.

1. To use this script, type the following into the Tk Console:
$>$ source mutate-to-dops.tcl

2. Now create a psf file either by using the provided psfgen script 3_cg_membrane/build-mixture.tcl by typing
$>$ source build-mixture.tcl
or by using the AutoPSF plugin.

3. Load the resulting pdb and psf files into VMD - you should see that about 30% of the lipids are now DOPS lipids. For example, you can color lipids by resname to distinguish between DOPC and DOPS.

You will need this mixed DOPC/DOPS membrane patch for the simulations in following sections.