Lipid-converter, a framework for lipid manipulations in molecular dynamics simulations

Abstract

Construction of lipid membrane and membrane protein systems for molecular dynamics simulations can be a challenging process. In addition, there are few available tools to extend existing studies by repeating simulations using other force fields and lipid compositions. To facilitate this, we introduce lipidconverter, a modular Python framework for exchanging force fields and lipid composition in coordinate files obtained from simulations. Force fields and lipids are specified by simple text files, making it easy to introduce support for additional force fields and lipids. The converter produces simulation input files that can be used for structural relaxation of the new membranes.

Introduction

Molecular dynamics simulations of membrane systems and membrane proteins are becoming increasingly important, both as our ability to embrace larger systems on longer timescales increase, but also as more and more structures of membrane proteins become available from X-ray crystallography and NMR studies. Some examples highlighting the advances made over recent years include simulations of the Gramicidin A channel1, potassium channels² and different transporters (as reviewed in ³). The accuracy of any simulation depends on the underlying model physics represented by the force field and parameterization of the molecular species in question under that force field. Such parameterizations are typically laborious and tend to be undertaken for individual molecules and force fields, although more general approaches have been developed^4-6. Also, the construction of lipid membrane systems for simulations can often be time-consuming and specific to the simulation software or system employed. While there are simple, easy-to-use tools for construction of membrane systems in some systems, we desire a systematic framework to allow a broad range of users to adapt membrane systems to their parameter set of choice.

Results and Discussion

The aim of lipid-converter is to provide the research community with a tool that makes it simple to swap force fields and lipid compositions within a coordinate file. It is written in Python and requires no external libraries other than NumPy for numeric operations, gflags for command-line parsing, and the optional library NetworkX for automatic leaflet identification. It has two modes of operation, transformation and conversion. When transforming between force fields, lipid-converter currently supports lipids from the following the following parameter sets: Berger⁷, Gromos 43A1-S3⁸, Gromos 53A6⁹, Gromos 53A7¹⁰, CHARMM36¹¹, OPLS-UA¹², and LIPID11¹³ (for details, see Table 1). Since the Stockholm Lipids¹⁴, compatible with the Amber force fields, uses the same nomenclature as CHARMM, this is thus also supported by extension. The combinations that are supported are obviously limited by the available parameterizations of different lipids and force fields. All transformations and conversions are specified in simple data files, and are performed by lipidconverter by simply matching atom names in the input and output files.

Table 1.

Table of currently supported combinations of force field transformations. Note that the Stockholm Lipids (Slipids) uses the same atom nomenclature as Charmm36.

Input forcefield	Output forcefield	Lipids in input file
Berger	Charmm36	POPC,POPE,POPG,POPS,DMPC,DOPC,DPP
Gromos43A1-S3	Charmm36	POPC,DMPC,DOPC,DPPC,DLPC
Gromos53A6	Charmm36	POPC,POPG,DMPC,DPPC
Gromos54A7	Charmm36	POPC,POPS,DMPC,DOPC,DPPC
Berger	Gromos43A1-S3	POPC,DMPC,DOPC,DPPC
Amber/Lipidll	Charmm36	POPC,POPE,POPS,POPG,DPPC,DOPC
Charmm36	Amber/Lipid11	POPC,POPE,POPS,POPG,DPPC,DOPC

Transforming heavy atoms between different force fields is a relatively straightforward procedure and requires only reordering and renaming atoms. When necessary, lipid-converter also constructs explicit hydrogens automatically. Converting between lipid types, however, may involve adding or removing atoms. Here lipid-converter tries as much as possible to preserve the geometry of the original lipids. Lipids in a bilayer environment are often somewhat entangled, and any addition or deletion of atoms might introduce clashes or voids in the system. Conversions between lipids are defined based on the differences and similarities between pairs of lipids. A simple example to illustrate this is the conversion from POPC to POPE in the CHARMM36 force field. This involves renaming of the C13, C14 and C15 head-group carbons into HN1, HN2 and HN3, while also removing the methyl hydrogens. Additional combinations have been implemented similarly, as shown in Table 2, and are easily extensible by the user. This allows the user to take an existing bilayer that may have been modified—perhaps by inserting proteins—and now study the influence on a different lipid composition in a straightforward manner without the need to construct a new membrane system from scratch.

Table 2.

Table of currently supported combinations of lipid type conversions. Similary as for transformations, support for Charmm36 also means support for Slipids.

Forcefield	Input lipid	Output lipid
Charmm36	POPC	POPE,POPG,POPS,DOPC,DMPC,DPPC
	POPE	POPC,POPG,POPS,DOPC,DMPC,DPPC
	POPG	POPC,POPE,POPS,DOPC,DMPC,DPPC
	POPS	POPQPOPE
Gromos43Al-S3	POPC	POPE,DOPC,DMPC,DPPC,DLPC
	POPE	POPC,DOPC,DMPC,DPPC,DLPC
	DMPC	POPC,POPE,DOPC,DPPC,DLPC
	DOPC	POPC,POPE,DMPC,DPPC,DLPC
	DPPC	POPC,POPE,DMPC,DOPC,DLPC
	DLPC	POPC,POPE,DMPC,DPPC,DOPC

The usage of lipid-converter on the command line is very simple and straight forward. The user specifies an input coordinate file-either a PDB file or a Gromacs¹⁵ coordinate file-and the source and target force fields. The transformation is very quick; for a large vesicle system containing roughly 1700 POPC and POPE lipids, transformation from Berger parameters to CHARMM36 takes around 3 minutes, with most time spent constructing hydrogen atom positions. The web server is structured similarly but imposes an upper limit on the size of the system that can be processed due to server memory restrictions. When a conversion from one lipid species to another is requested, the user can decide to replace only every n^th original lipid. This facilitates conversion of systems that originally consisted of only a single lipid species to a more complex simulation (see examples of usage below).

To illustrate the usage of lipid-converter, we used the Charmm-gui¹⁶ website to construct a membrane patch with 256 POPC lipids and 9374 water molecules. We converted this system to five other force fields and ran 250 ns simulations of each. Structural relaxation was tracked via the average lateral area per lipid head group. Different force fields will give slightly different results, but starting from the CHARMM36 formatted bilayer, all simulations reproduce within a 10% error the experimental area (0.683 nm²) per head group of POPC (Fig. 1). Of perhaps equal importance, average areas per head group measured over the interval 150 to 200 ns for each simulation are all within 1.5% of the value reported in the primary publication for each target force field. This demonstrates that lipidconverter is able to produce starting files that, together with appropriate run parameters, can match structural parameters for the canonical version of the target force field.

Figure 1. Lateral area per headgroup for POPC with different force fields staring from CHARMM36.

Different force fields result in different area values, but they all fall within the range of values that have been suggested from experiments (0.54-0.683 nm²)^22,23 as well as close to the values reported in the primary publication(s) for each force field (dashed lines). Simulations for each force field have been continued to at least 250 ns and continue to show average areas per head group of within 1.5% of the values reported in the primary

Lipid-converter can also be used to generate membrane systems with an asymmetric lipid distribution. To assign lipids to leaflets in an automated manner, it uses the algorithm outlined by Michaud-Agrawal et al17. As noted by those authors, for a flat bilayer it is very simple to compare the z-coordinate of each lipid to the center of geometry and so be able to assign lipids to separate lipids. A strong point of the present algorithm is that it can also label leaflets in curved systems such as vesicles in an automated fashion.

An overview of supported force field transformations and lipid type conversions is presented in Tables 1 and 2. Due to the simple format of the data files for transformations and conversions, adding support for additional operations is trivial. As a final note, lipid-converter processes lipid molecules only; if the input file also contains protein and solvent molecules, those will be stripped out (to reduce memory footprint during processing) and must be added back in postprocessing.

Examples of usage

The command line client for lipid-converter is available after installation as a python-script called lipid-converter.py. The package documentation contains detailed usage information, but we summarize some common use cases here as well:

1. Transformation of a CHARMM46 input bilayer to AMBER/lipid11

   $ lipid-converter.py -f input_file.pdb (.gro) -o output.pdb (.gro) -mode transform -ffin charmm36 -ffout lipid11 -canonical

2. Conversion of a bilayer with Berger POPE to POPC, but converting only every second POPE to POPC

   $ lipid-converter.py -f input_file.pdb (.gro) -o output.pdb (.gro) -mode convert -ffin berger -lin POPE - lout POPC -canonical -n 2

3. Making an asymmetric bilayer, starting from an all-POPC bilayer, changing every second POPC in the upper leaflet to POPE, and every third POPC in the lower leaflet to POPG

   $ lipid_converter.py -f step5_popc_only.gro -o foo.gro - mode convert -ffin charmm36 -lin POPC:POPC -lout POPE:POPG -asymmetry -n 2:3 -canonical

Methods

All simulations were started from a lipid bilayer consisting of 256 POPC lipids and 9374 water molecules obtained from the CHARMM-GUI¹⁶ website. Using lipid-converter, this coordinate file was transformed into Gromos43A1-S3⁸, Gromos 53A6⁹, Gromos 54A7¹⁰, Berger⁷ and OPLS-UA¹² nomenclature, respectively. For each target parameter set, this POPC membrane system was simulated for at least 250 ns using Gromacs 4.5¹⁵. Long-range electrostatics were calculated using the Particle mesh Ewald-method¹⁸. Simulations with Gromos53A6, Gromos54A7 and Berger used a real-space cutoff of 1.2 nm while Gromos43A1-S3 and OPLS simulations used a 1.0 nm cutoff for electrostatic interactions. Lennard-Jones interactions where evaluated using a straight 1.2 nm cutoff for Gromos53A6, Gromos54A7 and Berger and a 1.0 nm cutoff for OPLS. Gromos43A1-S3 used a twin-range Lennard-Jones cutoff of 1.0/1.6 nm. All bonds were constrained using the LINCS19 algorithm. All systems were first energy minimized after conversion for 500 steps using Steepest descents, and simulations were then run using a 2 fs time step at a temperature of 300K maintained by the V-rescale thermostat²⁰ and a pressure of 1 bar with the Parrinello-Rahman barostat²¹. Other settings, including appropriate water models, were chosen so to as closely as possible replicate the original methodologies found in the respective publications.

Conclusions

We have created lipid-converter, an open source and easily extendable Python framework for manipulation of lipids in molecular dynamics simulations. By design, it is very simple to introduce other kinds of lipids and force fields into the framework. This functionality is especially important for performing studies to compare and contrast the effect of different lipids and force fields in molecular dynamics simulations. Of course, since both choice of force field and lipid composition affect membrane structural parameters; careful re-equilibration is always necessary. An online version of this tool is available at http://lipidconverter.appspot.com; the code is also available for download from the Python Package Index. The code is licensed under LGPL2.