LiPyphilic

https://lipyphilic.readthedocs.io/en/latest
Admin
A Python toolkit for the analysis of lipid membrane simulations built on MDAnalysis with tools for...
Tokens:56,898
Snippets:478
Trust Score:9.6
Update:2 months ago
Show doc for...
Tokens:
Raw
### Install Rust

Source: https://lipyphilic.readthedocs.io/en/latest/contributing.html

Use the official rustup script to install Rust and configure the environment.

```bash
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source $HOME/.cargo/env
```

--------------------------------

### Initialize MembThickness Analysis

Source: https://lipyphilic.readthedocs.io/en/latest/_modules/lipyphilic/analysis/memb_thickness.html

Setup the MDAnalysis universe and assign leaflets before initializing the MembThickness object.

```python
import MDAnalysis as mda
from lipyphilic.analysis.memb_thickness import MembThickness

u = mda.Universe(tpr, trajectory)
```

```python
leaflets = AssignLeaflets(
  universe=u,
  lipid_sel="name GL1 GL2 ROH" # assuming we are using the MARTINI forcefield
)
leaflets.run()
```

```python
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"
)
```

--------------------------------

### Initialize Registration Analysis

Source: https://lipyphilic.readthedocs.io/en/latest/reference/analysis/registration.html

Setup the MDAnalysis Universe and assign leaflets before initializing the Registration object.

```python
import MDAnalysis as mda
from lipyphilic.analysis.registration import Registration

u = mda.Universe(tpr, trajectory)
```

```python
leaflets = AssignLeaflets(
  universe=u,
  lipid_sel="name GL1 GL2 ROH" # assuming we are using the MARTINI forcefield
)
leaflets.run()
```

```python
registration = Registration(
  upper_sel="resname CHOL and name ROH",
  lower_sel="resname CHOL and name ROH",
  leaflets=leaflets.filter_leaflets("resname CHOL and name ROH")
)
```

--------------------------------

### Initialize and Run SCC Analysis

Source: https://lipyphilic.readthedocs.io/en/latest/_modules/lipyphilic/analysis/order_parameter.html

Setup an MDAnalysis Universe and calculate the order parameter for lipid tails.

```python
import MDAnalysis as mda
from lipyphilic.analysis.order_parameter import SCC

u = mda.Universe(tpr, trajectory)
```

```python
scc_sn1 = SCC(
  universe=u,
  tail_sel="name ??A"  # selects C1A, C2A, D2A, C3A, and C4A
)
```

```python
scc_sn1.run(
  start=None,
  stop=None,
  step=None,
  verbose=True
)
```

--------------------------------

### ZThickness.run(start, stop, step, verbose)

Source: https://lipyphilic.readthedocs.io/en/latest/reference/analysis/z_thickness.html

Executes the thickness calculation over the specified trajectory frames.

```APIDOC
## ZThickness.run(start=None, stop=None, step=None, verbose=True)

### Description
Runs the thickness calculation on the provided trajectory.

### Parameters
- **start** (int/None) - Optional - Start frame.
- **stop** (int/None) - Optional - Stop frame.
- **step** (int/None) - Optional - Step size.
- **verbose** (bool) - Optional - Whether to display a progress bar.
```

--------------------------------

### Install Lipyphilic with Pip

Source: https://lipyphilic.readthedocs.io/en/latest/_sources/installation.rst.txt

Install the lipyphilic package from the Python Package Index using pip. This is a standard method for installing Python packages.

```bash
python -m pip install lipyphilic
```

--------------------------------

### Install Lipyphilic with Mamba

Source: https://lipyphilic.readthedocs.io/en/latest/_sources/installation.rst.txt

Use this command to create a new conda environment named 'lipyphilic' and install the package from the conda-forge channel. This method installs lipyphilic along with all its dependencies.

```bash
mamba create -n lipyphilic -c mamba-forge python=3.11 lipyphilic
mamba activate lipyphilic
```

--------------------------------

### Install LiPyphilic via Mamba

Source: https://lipyphilic.readthedocs.io/en/latest/index.html

Use this command to install the package and its dependencies from the conda-forge channel.

```bash
mamba install -c conda-forge lipyphilic
```

--------------------------------

### Install In-Development Version of Lipyphilic with Pip

Source: https://lipyphilic.readthedocs.io/en/latest/_sources/installation.rst.txt

Install the latest in-development version of lipyphilic directly from its GitHub repository using pip. This is useful for testing the newest features or bug fixes.

```bash
python -m pip install https://github.com/p-j-smith/lipyphilic/archive/main.zip
```

--------------------------------

### Build Documentation

Source: https://lipyphilic.readthedocs.io/en/latest/contributing.html

Verify that the documentation builds correctly.

```bash
tox -e docs
```

--------------------------------

### Create Development Environment

Source: https://lipyphilic.readthedocs.io/en/latest/contributing.html

Set up an isolated Python environment using uv.

```bash
uv venv --python=3.11
source venv/bin/activate
```

--------------------------------

### SCC.__init__

Source: https://lipyphilic.readthedocs.io/en/latest/_modules/lipyphilic/analysis/order_parameter.html

Initializes the SCC analysis object with a universe and tail selection.

```APIDOC
## SCC(universe, tail_sel, normals=None)

### Description
Set up parameters for calculating the SCC (coarse-grained acyl tail order parameter).

### Parameters
- **universe** (Universe) - Required - MDAnalysis Universe object
- **tail_sel** (str) - Required - Selection string for atoms in either the sn1 or sn2 tail of lipids in the membrane
- **normals** (numpy.ndarray) - Optional - Local membrane normals, a 3D array of shape (n_residues, n_frames, 3)
```

--------------------------------

### MembThickness.__init__

Source: https://lipyphilic.readthedocs.io/en/latest/_modules/lipyphilic/analysis/memb_thickness.html

Initializes the MembThickness analysis object with the required universe, leaflet assignments, and configuration parameters.

```APIDOC
## MembThickness.__init__(universe, lipid_sel, leaflets, n_bins=1, interpolate=False, return_surface=False)

### Description
Initializes the analysis parameters for calculating membrane thickness. This class requires an orthorhombic simulation box.

### Parameters
- **universe** (Universe) - Required - MDAnalysis Universe object.
- **lipid_sel** (str) - Optional - Selection string for lipid atoms. Defaults to 'all'.
- **leaflets** (numpy.ndarray) - Required - Array of leaflet membership (-1 lower, 1 upper, 0 midplane). Shape (n_lipids,) or (n_lipids, n_frames).
- **n_bins** (int) - Optional - Number of bins in x and y to create a grid of membrane patches. Defaults to 1.
- **interpolate** (bool) - Optional - If True, interpolate surfaces to fill missing values. Defaults to False.
- **return_surface** (bool) - Optional - If True, returns the height of the bilayer at each grid point. Defaults to False.
```

--------------------------------

### FlipFlop.__init__

Source: https://lipyphilic.readthedocs.io/en/latest/_modules/lipyphilic/analysis/flip_flop.html

Initializes the FlipFlop analysis object with the simulation universe, lipid selection, and leaflet membership data.

```APIDOC
## FlipFlop(universe, lipid_sel, leaflets, frame_cutoff=1)

### Description
Initializes the analysis to find flip-flop events. Requires an MDAnalysis Universe, a selection string for the lipids, and a 2D array representing leaflet membership over time.

### Parameters
- **universe** (MDAnalysis.Universe) - Required - The MDAnalysis Universe object.
- **lipid_sel** (str) - Required - Selection string for atoms to use in detecting flip-flop.
- **leaflets** (numpy.ndarray) - Required - A 2D array of shape (n_lipids, n_frames) containing leaflet membership (-1: lower, 1: upper, 0: midplane).
- **frame_cutoff** (int) - Optional - Minimum consecutive frames a molecule must reside in a new leaflet to be counted as a successful flip-flop. Default is 1.
```

--------------------------------

### Initialize ZThickness Analysis

Source: https://lipyphilic.readthedocs.io/en/latest/_modules/lipyphilic/analysis/z_thickness.html

Create an MDAnalysis Universe and initialize the ZThickness object with a specific atom selection.

```python
import MDAnalysis as mda
from lipyphilic.analysis.z_thickness import ZThickness

u = mda.Universe(tpr, trajectory)

z_thickness_sn1 = ZThickness(
  universe=u,
  lipid_sel="(name ??1 ??A) or (resname CHOL and not name ROH)"
)
```

--------------------------------

### Projecting SCC values

Source: https://lipyphilic.readthedocs.io/en/latest/_modules/lipyphilic/analysis/order_parameter.html

Example of configuring the SCC projection with specific lipid selections and leaflet filtering.

```python
scc_projection = scc.project_SCC(
    lipid_sel="name ??A ??B",
    start=-100,
    stop=None,
    step=None,
    filter_by=leaflets.filter_by("name ??A ??B") == -1
  )
```

--------------------------------

### Prepare MembThickness analysis

Source: https://lipyphilic.readthedocs.io/en/latest/_modules/lipyphilic/analysis/memb_thickness.html

Internal method to initialize output arrays before the analysis loop.

```python
def _prepare(self):
        if (self.leaflets.ndim == 2) and (self.leaflets.shape[1] != self.n_frames):
            _msg = "The frames to analyse must be identical to those used in assigning lipids to leaflets."
            raise ValueError(_msg)

        # Output array
        self.results.memb_thickness = np.full(self.n_frames, fill_value=np.nan)

        if self._return_surface:
            self.results.memb_thickness_grid = np.full(
                (self.n_frames, self.n_bins, self.n_bins),
                fill_value=np.nan,
            )
```

--------------------------------

### Initialize MembThickness class

Source: https://lipyphilic.readthedocs.io/en/latest/_modules/lipyphilic/analysis/memb_thickness.html

Constructor for setting up membrane thickness calculation parameters, including leaflet assignment and grid binning.

```python
def __init__(self, universe, lipid_sel, leaflets, n_bins=1, interpolate=False, return_surface=False):
        """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 2D grid will be stored in self.memb_thickness_grid. The
            default is False.

        Tip
        ---

        Leaflet membership can be determined using :class:`lipyphilic.leaflets.assign_leaflets.AssignLeaflets`.

        """
        super().__init__(universe.trajectory)

        self.u = universe
        self.leaflets = np.array(leaflets)

        self.lipid_sel = lipid_sel if lipid_sel is not None else "all"
        self.membrane = self.u.select_atoms(self.lipid_sel, updating=False)

        if not np.allclose(self.u.dimensions[3:], 90.0):
            _msg = "MembThickness requires an orthorhombic box - triclinic systems are not supported."
            raise ValueError(_msg)

        if np.array(leaflets).ndim not in [1, 2]:
            _msg = (
                "'leaflets' must either be a 1D array containing non-changing "
                "leaflet ids of each lipid, or a 2D array of shape (n_residues, n_frames)"
                " containing the leaflet id of each lipid at each frame.",
            )
            raise ValueError(_msg)

        if len(leaflets) != self.membrane.n_residues:
            _msg = (
                "The shape of 'leaflets' must be (n_residues,), but 'lipid_sel' "
                f"generates an AtomGroup with {self.membrane.n_residues} residues"
                f" and 'leaflets' has shape {leaflets.shape}.",
            )
            raise ValueError(_msg)

        self.n_bins = n_bins
        self._interpolate_surfaces = interpolate
        self._return_surface = return_surface
        self.results.memb_thickness = None
        self.results.memb_thickness_grid = None
```

--------------------------------

### Initialize ZThickness

Source: https://lipyphilic.readthedocs.io/en/latest/reference/analysis/z_thickness.html

Create an MDAnalysis Universe and initialize the ZThickness object.

```python
import MDAnalysis as mda
from lipyphilic.analysis.z_thickness import ZThickness

u = mda.Universe(tpr, trajectory)
```

--------------------------------

### Run FlipFlop Analysis

Source: https://lipyphilic.readthedocs.io/en/latest/_modules/lipyphilic/analysis/flip_flop.html

Instantiate the FlipFlop class and execute the analysis over the trajectory.

```python
flip_flop = FlipFlop(
  universe=u,
  lipid_sel="name ROH",
  leaflets=leaflets.filter_leaflets("name ROH")  # pass only the relevant leaflet data
)

flip_flop.run(
  start=None,
  stop=None,
  step=None
)
```

--------------------------------

### ZPositions.__init__

Source: https://lipyphilic.readthedocs.io/en/latest/_modules/lipyphilic/analysis/z_positions.html

Initializes the ZPositions analysis object with the MDAnalysis universe and selection criteria.

```APIDOC
## ZPositions(universe, lipid_sel, height_sel, n_bins=1, return_midpoint=False)

### Description
Initializes the ZPositions analysis class to calculate the distance in z of lipids to the bilayer center.

### Parameters
- **universe** (MDAnalysis.Universe) - Required - The MDAnalysis Universe object.
- **lipid_sel** (str) - Required - Atom selection for all lipids in the bilayer used to calculate the membrane midpoint.
- **height_sel** (str) - Required - Atom selection for the molecules for which the z position will be calculated.
- **n_bins** (int) - Optional - Number of bins to split the membrane into (n_bins * n_bins) for local membrane midpoint calculation.
- **return_midpoint** (bool) - Optional - Whether to return the calculated midpoint.
```

--------------------------------

### Initialize MDAnalysis Universe for MSD

Source: https://lipyphilic.readthedocs.io/en/latest/reference/analysis/lateral_diffusion.html

Load the trajectory and import the MSD class to prepare for analysis.

```python
import MDAnalysis as mda
from lipyphilic.analysis.lateral_diffusion import MSD

u = mda.Universe(tpr, trajectory)
```

--------------------------------

### Initialize ZAngles Analysis

Source: https://lipyphilic.readthedocs.io/en/latest/_modules/lipyphilic/analysis/z_angles.html

Create an MDAnalysis Universe and initialize the ZAngles class with specific atom selections.

```python
import MDAnalysis as mda
from lipyphilic.analysis.z_angles import ZAngles

u = mda.Universe(tpr, trajectory)

z_angles = ZAngles(
  universe=u,
  atom_A_sel="name ROH",
  atom_B_sel="name R5"
)
```

--------------------------------

### Initialize Registration with lipid order data

Source: https://lipyphilic.readthedocs.io/en/latest/_modules/lipyphilic/analysis/registration.html

Configure the Registration class using a 2D array of lipid order data to identify liquid-ordered phases.

```python
registration = Registration(
  upper_sel="name PO4 ROH",
  lower_sel="name PO4 ROH",
  leaflets=leaflets.leaflets,
  filter_by=lipid_order_data == 1
)
```

--------------------------------

### Run Tests with Coverage

Source: https://lipyphilic.readthedocs.io/en/latest/contributing.html

Execute the test suite and generate coverage reports.

```bash
uv run pytest --cov
```

--------------------------------

### Initialize Neighbours Analysis

Source: https://lipyphilic.readthedocs.io/en/latest/_modules/lipyphilic/analysis/neighbours.html

Create an MDAnalysis Universe and initialize the Neighbours object with a specific lipid selection and distance cutoff.

```python
import MDAnalysis as mda
from lipyphilic.analysis.neighbours import Neighbours

u = mda.Universe(tpr, trajectory)

neighbours = Neighbours(
  universe=u,
  lipid_sel="name GL1 GL2 ROH",  # assuming we're using the MARTINI forcefield
  cutoff=12.0
)
```

--------------------------------

### Run Registration Analysis

Source: https://lipyphilic.readthedocs.io/en/latest/_modules/lipyphilic/analysis/registration.html

Execute the registration calculation over the trajectory.

```python
registration.run(
  start=None,
  stop=None,
  step=None,
  verbose=True
)
```

--------------------------------

### Initialize Neighbour Analysis

Source: https://lipyphilic.readthedocs.io/en/latest/_modules/lipyphilic/analysis/neighbours.html

Constructor for the neighbour analysis class, setting up the MDAnalysis universe and lipid selection.

```python
        super().__init__(universe.trajectory)

        self.u = universe
        self.membrane = self.u.select_atoms(lipid_sel, updating=False)

        # to allow for non-sequential resindices
        self._sorted_membrane_resindices = (
            scipy.stats.rankdata(
                self.membrane.resindices,
                method="dense",
            )
            - 1
        )

        if cutoff <= 0:
            _msg = "'cutoff' must be greater than 0"
            raise ValueError(_msg)

        self.cutoff = cutoff

        self.results.neighbours = None
```

--------------------------------

### MembThickness(universe, leaflets, lipid_sel, n_bins=1, interpolate=False, return_surface=False)

Source: https://lipyphilic.readthedocs.io/en/latest/_modules/lipyphilic/analysis/memb_thickness.html

Initializes the MembThickness analysis object.

```APIDOC
## MembThickness Constructor

### Description
Initializes the MembThickness object to calculate membrane thickness.

### Parameters
- **universe** (MDAnalysis.Universe) - Required - The MDAnalysis Universe object.
- **leaflets** (numpy.ndarray) - Required - Leaflet membership of each lipid at each frame.
- **lipid_sel** (str) - Required - Atom selection for lipids to be used in the thickness calculation.
- **n_bins** (int) - Optional - Number of bins in each dimension for the 2D grid (default: 1).
- **interpolate** (bool) - Optional - Whether to interpolate missing values in the grid (default: False).
- **return_surface** (bool) - Optional - Whether to return the surface height as a function of xy (default: False).
```

--------------------------------

### ZPositions Initialization

Source: https://lipyphilic.readthedocs.io/en/latest/_modules/lipyphilic/analysis/z_positions.html

Initializes the ZPositions analysis object with an MDAnalysis Universe and selection criteria.

```python
super().__init__(universe.trajectory)

self.u = universe
self.membrane = self.u.select_atoms(lipid_sel, updating=False)
self._height_atoms = self.u.select_atoms(height_sel, updating=False)

if not np.allclose(self.u.dimensions[3:], 90.0):
    _msg = "ZPositions requires an orthorhombic box - triclinic systems are not supported."
    raise ValueError(_msg)

# lipid species for which the height in z will be calculated
self._height_species = np.unique(self._height_atoms.resnames)
# number of each lipid species
num_lipids = {
    lipid: sum(self._height_atoms.residues.resnames == lipid) for lipid in self._height_species
}
# number of atoms (seeds) used in the Voronoi tessellation per molecule for each species
self._n_atoms_per_lipid = {
    lipid: sum(self._height_atoms.resnames == lipid) // num_lipids[lipid]
    for lipid in self._height_species
}

self.n_bins = n_bins
self.results.z_positions = None
self.results.memb_midpoint = None
self._return_midpoint = return_midpoint
```

--------------------------------

### Configure MSD Analysis

Source: https://lipyphilic.readthedocs.io/en/latest/reference/analysis/lateral_diffusion.html

Instantiate the MSD object by specifying the universe and the lipid selection.

```python
msd = MSD(
  universe=u,
  lipid_sel="resname DPPC DOPC CHOL"
)
```

--------------------------------

### Initialize FlipFlop Analysis

Source: https://lipyphilic.readthedocs.io/en/latest/reference/analysis/flip_flop.html

Creates the FlipFlop object using the universe and filtered leaflet data.

```python
flip_flop = FlipFlop(
  universe=u,
  lipid_sel="name ROH",
  leaflets=leaflets.filter_leaflets("name ROH")  # pass only the relevant leaflet data
)
```

--------------------------------

### ZPositions Preparation

Source: https://lipyphilic.readthedocs.io/en/latest/_modules/lipyphilic/analysis/z_positions.html

Prepares the output arrays for storing z-positions and optional membrane midpoints.

```python
def _prepare(self):
    # Output array
    self.results.z_positions = np.full(
        (self._height_atoms.n_residues, self.n_frames),
        fill_value=np.nan,
    )

    if self._return_midpoint:
        self.results.memb_midpoint = np.full(
            (self.n_frames, self.n_bins, self.n_bins),
            fill_value=np.nan)
```

--------------------------------

### Initialize MDAnalysis Universe

Source: https://lipyphilic.readthedocs.io/en/latest/_modules/lipyphilic/analysis/flip_flop.html

Create an MDAnalysis Universe object required for subsequent analysis.

```python
import MDAnalysis as mda
from lipyphilic.leaflets.assign_leaflets import AssignLeaflets
from lipyphilic.analysis.flip_flop import FlipFlop

u = mda.Universe(tpr, trajectory)
```

--------------------------------

### Initialize MSD Analysis

Source: https://lipyphilic.readthedocs.io/en/latest/_modules/lipyphilic/analysis/lateral_diffusion.html

Load the MDAnalysis universe and initialize the MSD class for specific lipid selections.

```python
import MDAnalysis as mda
from lipyphilic.analysis.lateral_diffusion import MSD

u = mda.Universe(tpr, trajectory)
```

```python
msd = MSD(
  universe=u,
  lipid_sel="resname DPPC DOPC CHOL"
)
```

--------------------------------

### Initialize MembThickness

Source: https://lipyphilic.readthedocs.io/en/latest/reference/analysis/memb_thickness.html

Create the MembThickness object using the assigned leaflets and lipid selection.

```python
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"
)
```

--------------------------------

### Create Development Branch

Source: https://lipyphilic.readthedocs.io/en/latest/contributing.html

Create a new branch for implementing changes.

```bash
git checkout -b name-of-your-bugfix-or-feature
```

--------------------------------

### FlipFlop Class Initialization

Source: https://lipyphilic.readthedocs.io/en/latest/_modules/lipyphilic/analysis/flip_flop.html

Initializes the FlipFlop analysis object with the MDAnalysis universe, lipid selection, and leaflet assignment data.

```APIDOC
## Class: FlipFlop

### Constructor
`FlipFlop(universe, lipid_sel, leaflets, frame_cutoff=None)`

### Parameters
- **universe** (MDAnalysis.Universe) - Required - The MDAnalysis Universe object.
- **lipid_sel** (str) - Required - Atom selection string for molecules to track.
- **leaflets** (numpy.ndarray) - Required - Leaflet membership data (-1: lower, 0: midplane, 1: upper).
- **frame_cutoff** (int) - Optional - Minimum number of frames a molecule must reside in the new leaflet to be considered a successful flip-flop.
```

--------------------------------

### Initialize plot axes and calculate values

Source: https://lipyphilic.readthedocs.io/en/latest/_modules/lipyphilic/plotting/plotting.html

Sets up the matplotlib figure and axes, and calculates the density values to be plotted, optionally subtracting a difference object.

```python
# Determine where to plot the figure
if ax is None:
    self.fig, self.ax = plt.subplots(1, figsize=(3, 3))
else:
    self.fig = plt.gcf()
    self.ax = ax
plt.sca(self.ax)

values = (
    self.joint_mesh_values.T - difference.joint_mesh_values.T
    if difference is not None
    else self.joint_mesh_values.T
)
```

--------------------------------

### Prepare Output Array

Source: https://lipyphilic.readthedocs.io/en/latest/_modules/lipyphilic/analysis/area_per_lipid.html

Initializes the results array for storing area per lipid values across frames.

```python
# Output array
        self.results.areas = np.full(
            (self.membrane.n_residues, self.n_frames),
            fill_value=np.nan,
            dtype=float,
        )
```

--------------------------------

### run(start=None, stop=None, step=None, verbose=True)

Source: https://lipyphilic.readthedocs.io/en/latest/_modules/lipyphilic/analysis/memb_thickness.html

Calculates the membrane thickness for the specified trajectory frames.

```APIDOC
## run()

### Description
Executes the membrane thickness calculation over the trajectory.

### Parameters
- **start** (int) - Optional - Start frame index.
- **stop** (int) - Optional - Stop frame index.
- **step** (int) - Optional - Step size for frame iteration.
- **verbose** (bool) - Optional - Whether to display a progress bar.
```

--------------------------------

### Registration.run()

Source: https://lipyphilic.readthedocs.io/en/latest/_modules/lipyphilic/analysis/registration.html

Executes the registration calculation over the specified trajectory frames.

```APIDOC
## Registration.run(start=None, stop=None, step=None, verbose=True)

### Description
Calculates the interleaflet correlation for the selected frames.

### Parameters
- **start** (int, optional) - Start frame index.
- **stop** (int, optional) - Stop frame index.
- **step** (int, optional) - Step size for frame iteration.
- **verbose** (bool, optional) - Whether to display a progress bar.
```

--------------------------------

### run(start=None, stop=None, step=None)

Source: https://lipyphilic.readthedocs.io/en/latest/_modules/lipyphilic/analysis/flip_flop.html

Performs the flip-flop calculation over a specified range of frames in the trajectory.

```APIDOC
## run(start=None, stop=None, step=None)

### Description
Performs the flip-flop calculation on the trajectory. This method iterates through residues and leaflets to analyze flip-flop events.

### Parameters
- **start** (int, optional) - Start frame of analysis.
- **stop** (int, optional) - Stop frame of analysis.
- **step** (int, optional) - Number of frames to skip between each analysed frame.

### Returns
- **self** (object) - Returns the instance of the analysis object.
```

--------------------------------

### Configure Registration Object

Source: https://lipyphilic.readthedocs.io/en/latest/_modules/lipyphilic/analysis/registration.html

Instantiate the Registration object with atom selections and leaflet assignments.

```python
registration = Registration(
  upper_sel="resname CHOL and name ROH",
  lower_sel="resname CHOL and name ROH",
  leaflets=leaflets.filter_leaflets("resname CHOL and name ROH")
)
```

--------------------------------

### Clone Repository

Source: https://lipyphilic.readthedocs.io/en/latest/contributing.html

Clone the forked repository to a local machine.

```bash
git clone git@github.com:YOURGITHUBNAME/lipyphilic.git
cd lipyphilic
```

--------------------------------

### Registration(universe, upper_sel, lower_sel, leaflets, filter_by=None, n_bins=None, gaussian_sd=15)

Source: https://lipyphilic.readthedocs.io/en/latest/_modules/lipyphilic/analysis/registration.html

Initializes the Registration analysis object to calculate interleaflet registration.

```APIDOC
## Registration

### Description
Initializes the Registration analysis object to calculate interleaflet registration in a bilayer.

### Parameters
- **universe** (MDAnalysis.core.universe.Universe) - The MDAnalysis universe object.
- **upper_sel** (str) - Selection string for the upper leaflet.
- **lower_sel** (str) - Selection string for the lower leaflet.
- **leaflets** (object) - Leaflet information object.
- **filter_by** (numpy.ndarray, optional) - Boolean array of shape (n_residues, n_frames) to filter lipids by phase.
- **n_bins** (int, optional) - Number of bins for the 2D histogram. Defaults to system size in Angstroms.
- **gaussian_sd** (float, optional) - Standard deviation of the circular Gaussian density. Defaults to 15.
```

--------------------------------

### Run Tests in Parallel

Source: https://lipyphilic.readthedocs.io/en/latest/contributing.html

Execute all test environments in parallel using tox.

```bash
tox -p auto
```

--------------------------------

### Initialize and populate Z-thickness object

Source: https://lipyphilic.readthedocs.io/en/latest/_modules/lipyphilic/analysis/z_thickness.html

Updates a thickness object with frame, time, and trajectory data from a source object.

```python
        new_thickness.start, new_thickness.stop, new_thickness.step = (
            sn1_thickness.start,
            sn1_thickness.stop,
            sn1_thickness.step,
        )
        new_thickness.frames = np.arange(new_thickness.start, new_thickness.stop, new_thickness.step)
        new_thickness.n_frames = new_thickness.frames.size
        new_thickness.times = sn1_thickness.times
        new_thickness._trajectory = sn1_thickness._trajectory
        new_thickness.results.z_thickness = z_thickness

        return new_thickness
```

--------------------------------

### AssignLeaflets.__init__

Source: https://lipyphilic.readthedocs.io/en/latest/_modules/lipyphilic/leaflets/assign_leaflets.html

Initializes the AssignLeaflets object with the MDAnalysis universe and membrane selection parameters.

```APIDOC
## AssignLeaflets(universe, lipid_sel, midplane_sel=None, midplane_cutoff=None, n_bins=1)

### Description
Set up parameters for assigning lipids to a leaflet.

### Parameters
- **universe** (Universe) - Required - MDAnalysis Universe object
- **lipid_sel** (str) - Required - Selection string for the lipids in a membrane. The selection should cover all residues in the membrane, including cholesterol.
- **midplane_sel** (str) - Optional - Selection string for residues that may be midplane. Any residues not in this selection will be assigned to a leaflet regardless of its proximity to the midplane.
- **midplane_cutoff** (float) - Optional - Minimum distance in z an atom must be from the midplane to be assigned to a leaflet rather than the midplane. Must be non-negative.
- **n_bins** (int) - Optional - Number of bins in x and y to use to create a grid of membrane patches.
```

--------------------------------

### Initialize Registration for ternary mixtures

Source: https://lipyphilic.readthedocs.io/en/latest/_modules/lipyphilic/analysis/registration.html

Specify custom selections for specific lipid types in a ternary mixture to filter for liquid-ordered phases.

```python
registration = Registration(
  upper_sel="(resname CHOL and name ROH) or (resname DPPC and name PO4)",
  lower_sel="(resname CHOL and name ROH) or (resname DPPC and name PO4)",
  leaflets=leaflets.filter_leaflets("resname CHOL DPPC"),
  filter_by=lipid_order_data == 1
)
```

--------------------------------

### Run ZThickness Analysis

Source: https://lipyphilic.readthedocs.io/en/latest/_modules/lipyphilic/analysis/z_thickness.html

Execute the analysis over the trajectory frames with optional progress reporting.

```python
z_thickness_sn1.run(
  start=None,
  stop=None,
  step=None,
  verbose=True
)
```

--------------------------------

### Initialize Lipid Species and Seed Counts

Source: https://lipyphilic.readthedocs.io/en/latest/_modules/lipyphilic/analysis/area_per_lipid.html

Determines unique lipid species and the number of atoms used as seeds for Voronoi tessellation per molecule.

```python
# lipid species in the membrane
        self._lipid_species = np.unique(self.membrane.resnames)
        # number of each lipid species in the membrane
        num_lipids = {lipid: sum(self.membrane.residues.resnames == lipid) for lipid in self._lipid_species}
        # number of atoms (seeds) used in the Voronoi tessellation per molecule for each species
        self._num_seeds = {
            lipid: sum(self.membrane.resnames == lipid) // num_lipids[lipid] for lipid in self._lipid_species
        }
```

--------------------------------

### Commit and Push Changes

Source: https://lipyphilic.readthedocs.io/en/latest/contributing.html

Stage, commit, and push local changes to the remote repository.

```bash
git add .
git commit -m "Your detailed description of your changes."
git push origin name-of-your-bugfix-or-feature
```

--------------------------------

### FlipFlop.run

Source: https://lipyphilic.readthedocs.io/en/latest/_modules/lipyphilic/analysis/flip_flop.html

Executes the flip-flop analysis over the specified trajectory frames.

```APIDOC
## Method: run

### Description
Analyzes the trajectory to identify flip-flop events.

### Parameters
- **start** (int) - Optional - Start frame index.
- **stop** (int) - Optional - Stop frame index.
- **step** (int) - Optional - Step size for frame iteration.

### Attributes
- **flip_flops** (numpy.ndarray) - Results array containing [resindex, end_frame, start_frame, moves_to].
- **flip_flop_success** (numpy.ndarray) - Boolean array indicating success or failure of each event.
```

--------------------------------

### ZPositions.run

Source: https://lipyphilic.readthedocs.io/en/latest/_modules/lipyphilic/analysis/z_positions.html

Executes the analysis over the specified trajectory frames.

```APIDOC
## ZPositions.run(start=None, stop=None, step=None, verbose=True)

### Description
Runs the analysis on the trajectory frames.

### Parameters
- **start** (int) - Optional - Start frame index.
- **stop** (int) - Optional - Stop frame index.
- **step** (int) - Optional - Step size for frame iteration.
- **verbose** (bool) - Optional - Whether to display a progress bar.
```

--------------------------------

### ZPositions(universe, lipid_sel, height_sel, n_bins=None)

Source: https://lipyphilic.readthedocs.io/en/latest/reference/analysis/z_pos.html

Initializes the ZPositions analysis object to calculate the z-position of selected molecules.

```APIDOC
## ZPositions Constructor

### Description
Initializes the ZPositions analysis object. This class calculates the height of molecules in a bilayer relative to the membrane midpoint.

### Parameters
- **universe** (MDAnalysis.Universe) - Required - The MDAnalysis Universe object.
- **lipid_sel** (str) - Required - Atom selection for all lipids in the bilayer used to calculate the membrane midpoint.
- **height_sel** (str) - Required - Atom selection for the molecules for which the z position will be calculated.
- **n_bins** (int) - Optional - If provided, splits the membrane into n_bins * n_bins patches to calculate local membrane midpoints.
```

--------------------------------

### Calculate and project order parameters

Source: https://lipyphilic.readthedocs.io/en/latest/_modules/lipyphilic/analysis/order_parameter.html

This snippet handles lipid filtering, center-of-mass calculation, and the generation of a projection plot for order parameter values.

```python
        elif filter_by.shape == self.results.SCC.shape[:1]:
            filter_by = filter_by[keep_lipids]

        else:
            mid_frame_index = np.min(np.where(self.frames == mid_frame))
            filter_by = filter_by[keep_lipids][:, mid_frame_index]

        # get x and y positions, and make sure the COM is in the unit cell, otherwise is will not be included in the plot
        self.u.trajectory[mid_frame]
        residues = lipids.groupby("resindices")
        lipid_com = np.array([residues[res].center_of_mass(unwrap=unwrap) for res in residues])
        for dim in range(3):
            lipid_com[:, dim][lipid_com[:, dim] > self.u.dimensions[dim]] -= self.u.dimensions[dim]
            lipid_com[:, dim][lipid_com[:, dim] < 0.0] += self.u.dimensions[dim]
        lipids_xpos, lipids_ypos, _ = lipid_com.T

        # now we can filter lipids and their values if necessary
        lipids_xpos = lipids_xpos[filter_by]
        lipids_ypos = lipids_ypos[filter_by]
        values = np.mean(scc, axis=1)[filter_by]

        # And finally we can create our ProjectionPlot
        scc_projection = ProjectionPlot(lipids_xpos, lipids_ypos, values)

        # create grid of values
        if bins is None:
            x_dim = self.u.dimensions[0]
            x_bins = np.linspace(0.0, np.ceil(x_dim), int(np.ceil(x_dim)) + 1)

            y_dim = self.u.dimensions[1]
            y_bins = np.linspace(0.0, np.ceil(y_dim), int(np.ceil(y_dim)) + 1)

            bins = (x_bins, y_bins)

        scc_projection.project_values(bins=bins)
        scc_projection.interpolate()
        scc_projection.plot_projection(
            ax=ax,
            cmap=cmap,
            vmin=vmin,
            vmax=vmax,
            cbar=cbar,
            cbar_kws=cbar_kws,
            imshow_kws=imshow_kws,
        )

        return scc_projection
```

--------------------------------

### lipyphilic.analysis.memb_thickness.MembThickness

Source: https://lipyphilic.readthedocs.io/en/latest/reference/analysis/memb_thickness.html

Constructor for the MembThickness analysis class.

```APIDOC
## class lipyphilic.analysis.memb_thickness.MembThickness(universe, lipid_sel, leaflets, n_bins=1, interpolate=False, return_surface=False)

### Description
Set up parameters for calculating membrane thickness.

### Parameters
- **universe** (Universe) - Required - MDAnalysis Universe object
- **leaflets** (numpy.ndarray) - Required - An array of leaflet membership (-1: lower, 1: upper, 0: midplane). Can be 1D (n_lipids) or 2D (n_lipids, n_frames).
- **lipid_sel** (str) - Optional - Selection string for lipid atoms to be used in the thickness calculation. Default is None.
- **n_bins** (int) - Optional - Number of bins in x and y to use to create a grid of membrane patches. Default is 1.
- **interpolate** (bool) - Optional - If True, interpolate the two intrinsic surfaces to fill missing values. 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. Default is False.
```

--------------------------------

### Initialize AssignLeaflets Class

Source: https://lipyphilic.readthedocs.io/en/latest/_modules/lipyphilic/leaflets/assign_leaflets.html

Constructor for the AssignLeaflets class, defining parameters for membrane patch grid and midplane assignment.

```python
class AssignLeaflets(AssignLeafletsBase):
    """Assign lipids in a bilayer to the upper leaflet, lower leaflet, or midplane."""

    def __init__(self, universe, lipid_sel, midplane_sel=None, midplane_cutoff=None, n_bins=1):
        """Set up parameters for assigning lipids to a leaflet.

        Parameters
        ----------
        universe : Universe
            MDAnalysis Universe object
        lipid_sel : str
            Selection string for the lipids in a membrane. The selection
            should cover **all** residues in the membrane, including cholesterol.
        midplane_sel :  str, optional
            Selection string for residues that may be midplane. Any residues not
            in this selection will be assigned to a leaflet regardless of its
            proximity to the midplane.
            The default is `None`, in which case all lipids will be assigned to
            either the upper or lower leaflet.
        midplane_cutoff : float, optional
            Minimum distance in *z* an atom must be from the midplane to be assigned
            to a leaflet rather than the midplane. The default is `0`, in which case
            all lipids will be assigned to either the upper or lower leaflet. Must
            be non-negative.
        n_bins : int, optional
            Number of bins in *x* and *y* to use to create a grid of membrane patches.
            Local membrane midpoints are computed for each patch, and lipids assigned
            a leaflet based on the distance to their local membrane midpoint. The
            default is `1`, which is equivalent to computing a single global
            midpoint.

        Note
        ----
        """
```

--------------------------------

### Plotting density and PMF distributions

Source: https://lipyphilic.readthedocs.io/en/latest/_modules/lipyphilic/plotting/plotting.html

Internal logic for configuring imshow, contours, and colorbars for plotting distributions. Requires matplotlib and seaborn environments.

```python
        cbar_kws = {} if cbar_kws is None else cbar_kws
        imshow_kws = {} if imshow_kws is None else imshow_kws
        contour_kws = {} if contour_kws is None else contour_kws
        clabel_kws = {} if clabel_kws is None else clabel_kws

        # we cannot pass vmin/vmax to imshow if norm is also passed
        if "norm" in imshow_kws:
            vmin = min(imshow_kws["norm"].boundaries)
            vmax = max(imshow_kws["norm"].boundaries)

        # we need vmin and vmax to be set to sensible values
        # to ensure the colorbar labels looks reasonable
        # And to clip the values
        if vmin is None and self.temperature is not None:
            vmin = min(0.0, np.floor(np.nanmin(values)))
        elif vmin is None:
            vmin = np.nanmin(values)
        if vmax is None and self.temperature is not None:
            vmax = max(0.0, np.ceil(np.nanmax(values)))
        elif vmax is None:
            vmax = np.nanmax(values)

        # make sure the colourbar is centered at zero if we're looking doing a difference plot
        if difference is not None and "norm" not in imshow_kws:
            vmax = max(vmax, abs(vmin))
            vmin = -vmax

        if "norm" not in imshow_kws:
            imshow_kws["vmin"] = vmin
            imshow_kws["vmax"] = vmax

        values = values.clip(vmin, vmax)

        # Add contours if necessary
        if "colors" not in contour_kws:
            contour_kws["colors"] = "xkcd:dark grey"
        self._contours = contours = plt.contour(
            self.ob1_mesh_bins,
            self.ob2_mesh_bins,
            values,
            levels=n_contours,
            **contour_kws,
        )

        # And contour labels
        if contour_labels is not None:
            levels = np.array(contours.levels)
            self._clabels = plt.clabel(contours, levels=levels[contour_labels], **clabel_kws)

        # Get the extent of the distributions
        # This is necessary for imshow
        dx = np.diff(self.ob1_mesh_bins[0][:2])[0]
        dy = np.diff(self.ob2_mesh_bins[:, 0][:2])[0]
        extent = [
            self.ob1_mesh_bins[0][0] - dx / 2,
            self.ob1_mesh_bins[0][-1] + dx / 2 + 1,
            self.ob2_mesh_bins[0][0] - dy / 2,
            self.ob2_mesh_bins[-1][0] + dy / 2,
        ]

        # Detmine which cmap to use
        if cmap is None and difference is None:
            cmap = sns.cubehelix_palette(start=0.5, rot=-0.75, as_cmap=True, reverse=True)
        elif cmap is None:
            cmap = sns.color_palette(palette="RdBu_r", n_colors=200, as_cmap=True)

        # Finally we can plot the density/PMF
        self._imshow = plt.imshow(
            values,
            origin="lower",  # this is necessary to make sure the y-axis is not inverted
            extent=extent,
            cmap=cmap,
            **imshow_kws,
        )

        # And add a colourbar if necessary
        if cbar:
            if "label" not in cbar_kws:
                if self.temperature is not None and difference is not None:
                    cbar_kws[
                        "label"
                    ] = r"$\Delta\, \rm PMF$"  # pragma: no cover # testing for this label works locally but fails with tox/Travis

                elif self.temperature is not None:
                    cbar_kws[
                        "label"
                    ] = "PMF"  # pragma: no cover # testing for this label works locally but fails with tox/Travis
                else:
                    cbar_kws["label"] = "Probability density"

            if "pad" not in cbar_kws:
                cbar_kws["pad"] = 0.025

            self.cbar = self.fig.colorbar(self._imshow, **cbar_kws)

            ticks = self.cbar.get_ticks()
            labels = ticks.round(2).astype(str)
            labels[-1] += "<"
            if difference is not None:
                labels[0] = "<" + labels[0]
            self.cbar.set_ticks(ticks)  # must be called before we can set the labels
            self.cbar.set_ticklabels(labels)

        self.ax.set_title(title, loc="left", weight="bold")
        self.ax.set_xlabel(xlabel)
        self.ax.set_ylabel(ylabel)
        self.ax.set_aspect("auto")  # otherwise imshow assumes the axes have the same units
        self.ax.tick_params(axis="both", which="major", direction="inout", right=True, top=True)
```

--------------------------------

### ZThickness(universe, lipid_sel)

Source: https://lipyphilic.readthedocs.io/en/latest/reference/analysis/z_thickness.html

Initializes the ZThickness object to calculate the thickness in z of lipids in a bilayer.

```APIDOC
## class lipyphilic.analysis.z_thickness.ZThickness(universe, lipid_sel)

### Description
Initializes the analysis object for calculating lipid thickness.

### Parameters
- **universe** (MDAnalysis.Universe) - Required - The MDAnalysis Universe object.
- **lipid_sel** (str) - Required - Selection string for atoms to use in calculating lipid thicknesses.
```

--------------------------------

### FlipFlop(universe, lipid_sel, leaflets, frame_cutoff=None)

Source: https://lipyphilic.readthedocs.io/en/latest/reference/analysis/flip_flop.html

Initializes the FlipFlop analysis object to track lipid movement between leaflets.

```APIDOC
## FlipFlop(universe, lipid_sel, leaflets, frame_cutoff=None)

### Description
Initializes the FlipFlop analysis object. It requires an MDAnalysis Universe, a selection string for the lipids to track, and the leaflet membership data.

### Parameters
- **universe** (MDAnalysis.Universe) - Required - The MDAnalysis Universe object.
- **lipid_sel** (str) - Required - Atom selection string for the lipids to track.
- **leaflets** (numpy.ndarray) - Required - Leaflet membership data for each lipid at each frame.
- **frame_cutoff** (int) - Optional - Minimum number of frames a molecule must reside in the new leaflet for the event to be considered successful.
```

--------------------------------

### Run z-position analysis

Source: https://lipyphilic.readthedocs.io/en/latest/_modules/lipyphilic/analysis/z_positions.html

Execute the analysis over the trajectory with optional progress bar.

```python
z_positions.run(
  start=None,
  stop=None,
  step=None,
  verbose=True
)
```
Tokens:
Raw