Membrane thickness — lipyphilic.lib.memb_thickness
¶
- Author
Paul Smith
- Year
2021
- Copyright
GNU Public License v2
This module provides methods for calculating the membrane thickness over time.
The membrane thickness is defined as the mean distance in \(z\) between lipids in the upper and lower leaflets. A discrete intrinsic surface is constructed for each leaflet based on user-defined lipid headgroup atoms, and the mean distance in \(z\) between the two surfaces defines the membrane thickness.
Input¶
- Required:
universe : an MDAnalysis Universe object
leaflets : a NumPy array containing the leaflet membership of each lipid at each frame
lipid_sel : atom selection for lipids in the upper leaflet to used in the thickness calculation
Options: - n_bins : a discrete intrinsic surface of each leaflet is created with n_bins * n_bins patches
Output¶
thickness : the mean membrane thickness at each frame
Thickness data are returned in a numpy.ndarray
, containing the mean membrane thickness at each
frame.
Example usage of MembThickness
¶
An MDAnalysis Universe must first be created before using MembThickness
:
import MDAnalysis as mda
from lipyphilic.lib.memb_thickness import MembThickness
u = mda.Universe(tpr, trajectory)
Then we need to know which leaflet each lipid is in at each frame. This may be done using
lipyphilic.lib.assign_leaflets.AssignLeaflets
:
leaflets = AssignLeaflets(
universe=u,
lipid_sel="name GL1 GL2 ROH" # assuming we are using the MARTINI forcefield
)
leaflets.run()
The leaflets data are stored in the leaflets.leaflets
attribute. We can now create our
MembThickness object by passing the results of lipyphilic.lib.assign_leaflets.AssignLeaflets
MembThickness
along with an atom selection for the lipids:
memb_thickness = MembThickness(
universe=u,
leaflets=leaflets.filter_leaflets("resname DOPC and DPPC"), # exclude cholesterol from thickness calculation
lipid_sel="resname DPPC DOPC and name PO4"
)
To calculate the membrane thickness, based on interleaflet PO4 to PO4 distances, we need to use the
run()
method. We select which frames of the trajectory to analyse (None will use every
frame) and choose to display a progress bar (verbose=True):
memb_thickness.run(
start=None,
stop=None,
step=None,
verbose=True
)
The results are then available in the memb_thickness.memb_thickness
attribute as a
numpy.ndarray
.
Changing the resolution of the 2D grid¶
By default, the lipid positions of each leaflet are binned into a two-dimensional histogram using 1 bins in each dimension. This is equivalent to calculating the mean height of all headgroup atoms in the bilayer, without discretising the surface.
It is also possible to specify the bins to use for binning the data:
memb_thickness = MembThickness(
universe=u,
leaflets=leaflets.filter_leaflets("resname DOPC and DPPC"), # exclude cholesterol from thickness calculation
lipid_sel="resname DPPC DOPC and name PO4",
n_bins=10
)
This will use 10 bins in each dimension for creating the two-dimensional histogram.
Interpolate missing values in a grid with many bins¶
This is useful only if you would like a very high resolution grid. Having a higher
resolution grid may be useful if you would like to later calculate, for example, the
correlation between local membrane thicknesses and the local membrane area per lipid.
The area per lipid can be projected onto the membrane plane using the class
ProjectionPlot
, and the height of the bilayer as a function of \(xy\) can be
obtained from MembThickness
by setting the return_surface
keyword to True.
A grid with a small bin size (large n_bins
) will lead to bins with no atom, and thus no
height value. In this instance, the interpolate
keyword should be set to True.
However, interpolation substantially decreases performance and should be left as False unless
it is strictly necessary.
The class and its methods¶
- class lipyphilic.lib.memb_thickness.MembThickness(universe, lipid_sel, leaflets, n_bins=1, interpolate=False, return_surface=False)[source]¶
Calculate the bilayer thickness.
Set up parameters for calculating membrane thickness.
- Parameters
universe (Universe) – MDAnalysis Universe object
leaflets (numpy.ndarray (n_lipids,)) – An array of leaflet membership in which: -1 corresponds to the lower leaflet; 1 corresponds to the upper leaflet; and 0 corresponds to the midplane. If the array is 1D and of shape (n_lipids), each lipid is taken to remain in the same leaflet over the trajectory. If the array is 2D and of shape (n_lipids, n_frames), the leaflet to which each lipid is assisgned at each frame will be taken into account when calculating the area per lipid.
lipid_sel (str, optional) – Selection string for lipid atoms to be used in the thickness calculation. The default is None, in which case all atoms of the lipids will be used.
n_bins (int, optional) – Number of bins in x and y to use to create a grid of membrane patches. The intrinsic surface of a leaflet is constructed via the height in z of each patch. The default is 1, which is equivalent to computing a single global leaflet height.
interpolate (bool, optional) – If True, interpolate the two intrinsic surfaces to fill missing values. This substantially decreases performance but allows for the construction of higher-resolution grids. The default is False.
return_surface (bool, optional) – If True, the height of the bilayer at grid point at each frame is returned as numpy ndarray. The default is False.
Tip
Leaflet membership can be determined using
lipyphilic.lib.assign_leaflets.AssignLeaflets
.