Micelle Maker: An Online Tool for Generating Equilibrated Micelles as Direct Input for Molecular Dynamics Simulations.

Micelles play an important role in both experimental and computational studies of the effect of lipid interactions on biological systems. The spherical geometry and the dynamical behavior of micelles makes generating micelle structures for use in molecular simulations challenging. An easy tool for generating simulation-ready micelle models, covering a broad range of lipids, is highly desirable. Here, we present a new Web server, Micelle Maker, which can provide equilibrated micelle models as a direct input for subsequent molecular dynamics simulations from a broad range of lipids (currently 25 lipid types, including 24 glycolipids). The Web server, which is available at http://www.micellemaker.net, uses error checking routines to prevent clashes during the initial placement of the lipids and uses AMBER's GLYCAM library for generating minimized or equilibrated micelle models, but the resulting structures can be used as starting points for simulations with any force field or simulation package. Extensive validation simulations with an overall simulation time of 12 μs using eight micelle models where assembly information is available show that all of the micelles remain very stable over the whole simulation time. Finally, we discuss the advantages of Micelle Maker relative to other approaches in the field.

Introduction

Micelles are biologically relevant lipid complexes, typically consisting of a polar head group and a lipid tail. In polar solvents, the lipid tails assemble to create a hydrophobic core, with the polar head groups building a hydrophilic water shell. Micelles play an important role in studying membrane-bound macromolecules, where they are used as alternatives to lipid bilayers, thus retaining the structural stability and biological function of these macromolecules.[1] However, the highly dynamic nature and spherical geometry of the complexes makes preparing micelles for molecular dynamics (MD) simulations challenging. We have observed that the initial micelle models often contain clashes resulting from automatic lipid assembly, and, furthermore, equilibration can be difficult due to severe density changes during the heating phase when lipids in the input model assemble, thus creating a need for a comprehensive easy-to-use tool to model simulation-ready micelles.

Our new Web server, Micelle Maker, is an online tool that builds micelles from a broad range of lipids (25 lipid types currently supported), as well as minimizing and equilibrating them as the direct input for subsequent MD simulations. The Web service provides a user-friendly interface with minimal input requirements (Figure ), making it easy for the user to build a micelle of choice. This is automatically created and placed into a water box including salt and counter ions, followed by (optional) user-defined postprocessing, that is, minimization or equilibration of the micelle. The output consists of the initial model of the micelle in a water box provided in Protein Data Bank (PDB) format, and the corresponding topology and coordinate files. If minimization or equilibration is chosen, the output additionally contains all of the log files generated by Micelle Maker, the minimized/equilibrated micelle systems in PDB format, and the corresponding topology and coordinate files, and in the case of equilibration, a restart file that can be used as the direct input for MD simulations. Finally, the prepared micelle is graphically presented in the Web browser using the NGL viewer and can be actively assessed by the user.

Figure 1

Overview of (A) Micelle Maker workflow and (B, C) sample sodium dodecyl sulfate (SDS) micelles generated by Micelle Maker in ball-and-stick and surface representations, respectively.

The Web server is linked to the AMBER MD package,[2] the usage of which is covered by our existing AMBER 16 license (personal communication with the AMBER developers); therefore, no additional licensing is required for the users of our Web service. Submitted users’ data are kept private and are not viewable by anyone other than the user or those given permission by the user. All of the data are deleted after 10 days.

Application

Micelle Maker provides a user-friendly interface, with minimal input requirements, leaving it up to the user to build a micelle according to the preferred specifications. The input only requires selection of a lipid type, the number of lipids, a salt type (NaCl or KCl), the associated salt concentration, and the rewriting of a security code to prevent misuse of the Web server. Each lipid molecule structure is visualized next to the input mask when selected. After job submission, a link to the results page is provided to view the results in the Web browser. An e-mail address may be optionally provided to obtain a link to the final results. A collection of experimentally determined micelle characteristics is provided on a separate Web page to support the user in selecting the appropriate parameters to build realistic micelle structures (see also Tables S1 and S2, Supporting Information).

A typical Micelle Maker job takes between 2 and 60 min of real time, depending on the input parameters and the postprocessing routine selected. Naturally, the generation of larger micelles takes more time compared with small micelles, and a full equilibration takes much more time than minimization, or only creating an initial micelle model. For simplicity, the prepared micelle system is graphically presented in the Web browser using the NGL viewer[3] and can be actively assessed by the user. In this representation, the lipid molecules are shown as sticks, and the user is given the option to selectively show explicit representations of lipids, water molecules, ions, and hydrogen atoms, as well as a van der Waals surface representation of the micelle, and to select between a black or white background theme. Finally, the viewport can be extended to show a full-screen representation of the micelle system.

Comparison to Other Approaches

To the best of our knowledge, the only peer-reviewed Web server that provides a micelle-building functionality is Micelle Builder,[4] which is implemented in the CHARMM-GUI[5] (http://www.charmm-gui.org). Even though both CHARMM-GUI and Micelle Maker were built with the intention to generate micelle models, both approaches significantly differ in their underlying methodologies as well as their output information and cannot be considered to be similar methods. Specifically, CHARMM-GUI currently supports 21 lipids, including SDS, several phosphocholines, and six glycolipids in α/β configurations. For comparison, Micelle Maker supports 25 lipids and 12 glycolipids in α/β configurations, in addition to SDS. Whereas CHARMM-GUI uses the CHARMM force field for lipid parameterization, Micelle Maker uses AMBER’s GLYCAM library, the parameters for which were reported to be in good agreement with experimental studies.[6] Following from this, as can be seen in Table S1, we obtain a good agreement between, where experimentally available, Rh and Rs values, which describe the hydrodynamic radius and the effective micellar radius of the micelles, respectively.

Furthermore, CHARMM-GUI does not contain any error-checking routines such that the sugar head groups from glycolipids could clash, which results in ring conjunctions that cannot be repaired even by structure minimization. Micelle Maker prevents such clashes by having an error-checking routine implemented, as discussed in the Micelle Generation section. Related to this, Micelle Maker was mainly developed using glycolipids and successfully validated using micelles based on seven glycolipids and SDS (three independent 500 ns simulations), whereas CHARMM-GUI micelles were successfully validated based on three phosphochinolines and SDS (single 100 ns simulations). As already mentioned, due to the structural dynamics of micelles, the equilibration of micelle models can be challenging. Here, we see an additional benefit of Micelle Maker, which not only provides steric-clash-free micelle models but also ready equilibrated systems that can be used as direct input for subsequent MD simulations. The advantage of CHARMM-GUI is that it contains some more functionalities like building mixed micelles, or the setup of protein–micelle systems; however, the latter can also be done easily using PyMol (a free version is available as a Linux package) with much more modeling possibilities. At present, Micelle Maker only builds homogeneous detergent micelles, although this might be extended in the future. Finally, the CHARMM force field can be transferred to other software packages, whereas GLYCAM, so far, can only be used in combination with AMBER. However, Micelle Maker presents the first automated method to create micelles based on GLYCAM as direct input to the AMBER software. In summary, both approaches not only differ in the supported lipid types and preferences but also the underlying force fields; whereas CHARMM-GUI provides more options, Micelle Maker mainly focuses on the quality and usability of the provided output structures, avoiding a modeler’s frustration with error-prone models and equilibration issues.

We note here as an aside two more tools of value when generating micelles. The first is an extension to the MemBuilder server (MemBuilder II, http://bioinf.modares.ac.ir/software/mb2/), which was originally developed to build lipid bilayers[7] but has now also been extended to build micelles and liposomes. The micelle generator of MemBuilder II, however, only supports four different lipid types and allows for minimization and not equilibration of the resulting micelle structures. Another valuable tool is Packmol,[8] which is a command line tool to generate initial configurations for MD simulations using a packing optimization algorithm.[9] Packmol allows for the rapid construction of good starting configurations for micelles, with minimal scripting required. In addition, Packmol includes routines to check steric clashes, as well as the possibility to use custom lipids for the micelle models. Therefore, and at the suggestion of a reviewer, we will be exploring introducing Packmol as a backend to future versions of Micelle Maker to expand the scope of micelles that Micelle Maker can generate.

Conclusions

Micelle Maker (http://www.micellemaker.net) is an easy-to-use online tool for generating equilibrated micelles as direct input for MD simulations with the AMBER MD package, using its GLYCAM library. Currently, Micelle Maker supports 25 lipid types. These are mainly glycolipids, as well as SDS, and micelles formed from these lipids have been shown to be stable in long-timescale validation simulations. Micelle Maker provides the broadest range of glycolipids for any micelle-generating software to date, is the only tool based on the AMBER force field using GLYCAM, and is unique in its ability to provide equilibrated systems as direct input to MD simulations. As such, we believe it provides a valuable addition to the toolbox of the molecular modeling and informatics communities.

Methods

Overview

The Micelle Maker workflow and sample micelles are shown in Figure . The Web server is mainly intended to be used with the AMBER simulation package and currently supports 25 lipid types, including 12 glycolipids, each in α- and β-stereoconfigurations of the sugar head group, based on the parameters from Abel et al.,[6] using AMBER’s GLYCAM library.

The micelle is generated by spreading points equally over a sphere and placing lipids on the vectors defined by these points and the sphere origin, based on the user’s input parameters. During this process, each lipid molecule undergoes a random translation and orientation and is checked for clashes with the surrounding lipid molecules (see the next section). The input mask provides default values for the salt concentration and the lipid distance, which are 0.15 mol L–1 and 4 Å, respectively. Our in-house validation studies (Table S1, Supporting Information) have shown that a 4 Å lipid distance is optimal for generating stable and realistic micelle models, taking into account also the radius of gyration (ROG, Figure ) and the solvent accessible surface area (SASA, Figure ) of the resulting micelles. The number of lipids that can be used is limited to a range between 20 and 150, thus covering the experimentally determined aggregation states of the lipids provided. After job submission, the micelle of choice is automatically created and placed into a water box including salt and counter ions, followed by (optional) user-defined postprocessing, which can be either minimization or equilibration of the micelle.

Figure 2

Plots of the radius of gyration (ROG) of different micelles over 500 ns of molecular dynamics simulation time. Numbers denote the number of lipid molecules of a micelle. All of the values are shown here as averages over three independent MD simulations (solid line), with the standard deviations over each frame of the three trajectories shown as the shaded background to each average value. For definitions of the lipid abbreviations used, see Table .

Figure 3

Plots of the solvent accessible surface area (SASA) of different micelles over 500 ns of molecular dynamics simulation time. Numbers denote the number of lipid molecules of a micelle. All of the values are shown here as averages over three independent MD simulations (solid line), with the standard deviations over each frame of the three trajectories shown as the shaded background to each average value. For definitions of the lipid abbreviations used, see Table .

Table 1

Full List of Lipid Types Currently Supported by Micelle Maker and the Corresponding Acronyms Used throughout This Worka

lipid type	acronym
heptyl-α(β)-d-glucopyranoside	α(β)-HG
heptyl-α(β)-d-maltopyranoside	α(β)-HM
octyl-α(β)-d-glucopyranoside	α(β)-OG
octyl-α(β)-d-maltopyranoside	α(β)-OM
nonyl-α(β)-d-glucopyranoside	α(β)-NG
nonyl-α(β)-d-maltopyranoside	α(β)-NM
decyl-α(β)-d-glucopyranoside	α(β)-DG
decyl-α(β)-d-maltopyranoside	α(β)-DM
undecyl-α(β)-d-glucopyranoside	α(β)-UDG
undecyl-α(β)-d-maltopyranoside	α(β)-UDM
dodecyl-α(β)-d-glucopyranoside	α(β)-DDG
dodecyl-α(β)-d-maltopyranoside	α(β)-DDM
sodium dodecyl sulfate	SDS

For more details about the physicochemical properties of these lipids, see Tables S1 and S2.

Micelle Generation

The initial micelle geometry is generated using a representation of evenly distributed points on a sphere, using the spiral point algorithm developed by Rakhmanov, Saff, and Zhou,[10,11] with the “golden sphere” modification.[12,13] The sphere size is determined by a user-defined interlipid distance, that is, the distance between the points on the sphere and the number of lipids (points). Information about the chemical structure of the different lipids is stored in a database as part of the program, and this information is then used to generate lipid molecules, which are then aligned onto vectors defined by the sphere’s origin, and the points spread over the sphere’s surface, using their hydrophobic tails. The micelle-generation process includes three steps of randomization: (1) The sphere is randomly rotated to always provide a different localization of points in Cartesian space. (2) Each lipid molecule undergoes a random rotation before being aligned onto a vector. (3) Each lipid undergoes a random translation on its vector, within a 2 Å distance. Steric clashes between the lipids are avoided by use of an error-checking routine, which calculates the root-mean-square deviation (rmsd) between each of the lipids and its surrounding atoms and introduces a new lipid placement if an atom is found within a rmsd of 2.5 Å from the lipid. These steps lead to a unique micelle that is free of steric clashes, thus providing a good starting point as an input structure for subsequent simulation purposes; once the micelle has been generated, it can be used for any kind of simulation the user is interested in.

Lipid Types Available in Micelle Maker

Micelle Maker currently supports 25 lipid types, including 12 glycolipids each in α- and β-stereoconfigurations of the sugar head group (Table ). The lipids are modeled based on the parameters from Abel et al.,[6] using AMBER’s GLYCAM library.[2] Most importantly, Micelle Maker supports two key lipids frequently used in experimental studies, namely, sodium dodecyl sulfate (SDS) and n-dodecyl-α/β-d-maltopyranoside (DDM).[14−17] Further information about the lipid types available can be found in Tables S1 and S2. The micelles created using these force field parameters were reported to be in good agreement with the experimental studies.[6] The Micelle Maker Web page provides a collection of experimentally determined micelle characteristics to support the user in selecting appropriate input parameters to build realistic micelle structures, and, for convenience, these are also presented in Tables S2, Supporting Information. These characteristics include the aggregation number, critical micelle concentration, and the solvent composition. We note that the experimental data are only provided for lipid types for which, to the best of our knowledge, reference literature exists.

Minimization and Equilibration of the Micelles

All of the MD simulations used in the micelle preparation are performed using the AMBER 16 simulation package,[2] covered by the AMBER license (personal communication with the AMBER developers). This involves initial user-optional minimization and equilibration of the micelle in an explicit solvent. All of the model systems are generated with the LEaP module of AMBER 16. The initial model is placed in an octahedral water box, formed of TIP3P water molecules,[18] extending to at least 11 Å from the solute in each direction. The systems are neutralized as relevant using either Na+, K+, or Cl– counter ions, and this can then be extended to a user-defined ionic strength using either NaCl or KCl.

If the user chooses to only minimize the micelle, the solvated micelles are subjected to a three-step minimization procedure to remove steric clashes between the water molecules and the solute, as well as between the solute molecules themselves. This minimization procedure is comprised of (1) 10 000 steps of steepest descent followed by 10 000 steps of conjugate gradient minimization, (2) subsequent 5000 steps of steepest descent and 2000 steps of conjugate gradient minimization using 25 kcal mol–1 Å–2 harmonic positional restraints on all of the solute atoms, and, finally, (3) 5000 steps of steepest descent and 2000 steps of conjugate gradient minimization with weaker 5 kcal mol–1 Å–2 harmonic positional restraints on all of the solute atoms.

If the user chooses to equilibrate the system, an initial minimization using 5000 steps of steepest descent and 2000 steps of conjugate gradiant minimization with a weaker 24 kcal mol–1 Å–2 positional restraint on all of the solute atoms, followed by 17 subsequent equilibration steps: (1) A 50 ps NVT simulation to increase the thermostatic target temperature using the Berendsen thermostat and pressure control algorithms,[19] with 0.5 ps time constants for both the bath coupling and the pressure relaxation. (2–4) Three 50 ps NPT simulations at a constant isotropic pressure of 1 atm to adjust the density of the system to 1 g cm–3. (5–16) Twelve 100 ps NVT simulations during which time the 24 kcal mol–1 Å–2 positional restraints are progressively decreased to 0 in 2 kcal mol–1 Å–2 increments. Finally, (17) a 1 ns NVT simulation without any restraints on the system. All of the 17 steps together result in a total equilibration time of 1.5 ns, during which time the target thermostat temperature is increased from 100 to 300 K and kept constant at 300 K using Berendsen’s weak coupling algorithm.[20] All of the bonds involving hydrogen atoms are constrained using the SHAKE algorithm,[21] and short-range, nonbonded interactions are calculated subject to an 8 Å cutoff radius. The corresponding long-range interactions are described using the particle mesh Ewald method.[22] All of the simulations are performed using a 2 fs time step throughout.

Molecular Dynamics Simulations of the Micelle Models

Our micelle models were validated based on eight different micelles (Table S1, Supporting Information, see also Figures –4) created by Micelle Maker, where experimentally determined information about the number of lipids per micelle is available (see Table S2). To validate our micelle models, we performed substantially longer production simulations using three independent equilibrations to obtain three independent starting points for each micelle simulation. All of the validation simulations were performed using a 2 fs time step, saving snapshots every 20 ps, and with the same simulation setup as described in the previous section. All of the production simulations were performed using NVT conditions, and subsequent analysis of the MD trajectories was performed using CPPTRAJ.[23] All of the validation data shown in this paper are obtained as averages over the last 500 ns of three independent equilibration runs for each system (i.e., a total of 1.5 μs simulation time per system). The radius of gyration (ROG) and solvent accessible surface area (SASA) plots, shown in Figures and 3, demonstrate that all of the systems remained stable over this simulation time. In addition, we note that micelles are not completely spherical, but rather form ellipsoids, the shape of which can be investigated by calculating the eccentricity (defined as 1 – (Imin/Iavg),[24] where I is the principle moment of inertia of the micelle). As can be seen from Figure , the highest eccentricity values were obtained for the glycoside micelles, namely nonyl-β-d-glucopyranoside (β-NG) and octyl-β-d-glucopyranoside (β-OG), respectively. These are also the only micelles that were reported to form a prolate shape.[25] However, a more recent study has suggested an oblate shape,[26] whereas another study reports a shape that fluctuates between prolate and oblate.[27] Our molecular dynamics of the maltoside micelles, namely β-OM, β-DM, and β-NG, are in line with the reports that these micelles form an oblate shape.[26] The lowest eccentricity value was obtained for α-DDM, which is in line with the observations from Abel et al. that glycolipids based on α-monomers form more spherical micelles when compared with their β-monomeric counterparts.[6] Finally, our eccentricity values for SDS also suggest an ellipsoidal shape for this micelle.

Figure 4

Plots of the eccentricity of different micelles over 500 ns of molecular dynamics simulation time (calculated as described in the caption to Table S1). Numbers denote the number of lipid molecules of a micelle. All of the values are shown here as averages over three independent MD simulations (solid line), with the standard deviations over each frame of the three trajectories shown as the shaded background to each average value. For definitions of the lipid abbreviations used, see Table .

Micelle Maker Implementation

Micelle Maker has been implemented in Python (version 3.4.5) (Python Software Foundation), similarly to the subroutines to create the input files for AMBER[2] using the LEaP module from AMBERTools.[2] Up to six serial and two GPU-accelerated jobs can be run in parallel based on our current Web server resources. Run times depend on the configuration of the micelle model, with the lipid type and the number of lipids being the crucial factors determining the run time. These vary between 2 and 20 min for the creation of an initial model system and 30 and 60 min for preliminary equilibration of the system. Thus, due to these short (real-time) run times, the number of jobs that can be run in parallel are considered to be sufficient enough to provide the results in a satisfying time frame. Based on future interest in the Web service, the Web server hardware can be extended to fulfill user need.