Lipid Permeation Free Energy

Lipid Permeation Free Energy calculates how hard it is for a molecule to pass through a lipid bilayer, the fatty double layer that forms a cell membrane, reported as free energies in kcal/mol. This matters for drug discovery because a molecule often has to cross such membranes to reach its target inside a cell.

The tool produces a free energy profile: it measures the free energy of the molecule at many positions along the path from outside the membrane, through the fatty interior, to the other side. From that profile it reports two key numbers. The barrier is the highest point the molecule must climb over, and a higher barrier means slower, harder crossing. The internal value is the depth of the well inside the membrane, which tells you how much the molecule likes to sit in the fatty core.

Under the hood it uses umbrella sampling, a method that holds the molecule at a series of fixed depths across the membrane and measures the free energy at each one, then stitches them together into the full profile.

When to use it

Use it when you want to understand or compare how easily molecules cross a cell membrane on their own, without a transporter, which is the passive permeability that affects oral absorption and getting into cells. Pick the lipid_type that best matches the membrane you care about.

Inputs

Provide exactly one of smiles or helm.

Input	Required	What it is
`smiles`	one of `smiles` or `helm`	SMILES string of the molecule that crosses the membrane.
`helm`	one of `smiles` or `helm`	HELM2 notation for a peptide that crosses the membrane.
`conformer_method`	no, default `etkdg`	3D shape generator used only for HELM input. `etkdg` is fast, `xtb` is slower but better. Ignored for SMILES input.
`lipid_type`	yes	Type of lipid bilayer. Currently supports `DPPC`, `DMPC`, `DOPC`, `DLPE`, `DLPC`, `POPE`, and `POPC`.
`equil_length`	no, default `0.08` ns	Equilibration length per replica.
`prod_length`	no, default `0.4` ns	Production length per replica.
`platform`	no, default `CUDA`	Compute platform, one of `CUDA`, `OpenCL`, `CPU`, or `Reference`.
`keep_dirs`	no, default `true`	Preserves the full simulation outputs so you can download them.

Longer simulation lengths give more reliable numbers, but cost more runtime and credits.

How to run it

Submit your own molecule and membrane type from Azulene Studio, the Python SDK, or the CLI. New here? The Get started page walks through installing, logging in, and running a ready made example first.

In Azulene Studio

Open Lipid Permeation Free Energy from the tools list, then on the Inputs and Parameters step enter the molecule as a SMILES string (or a peptide as HELM), choose the lipid type, adjust the simulation lengths if you want, then Review and Submit.

From the Python SDK

from opal import jobs

result = jobs.submit(
    job_type="lipid_permeation",
    input_data={
        "smiles": "O",
        "lipid_type": "POPC",
    },
)

From the CLI

Pass the inputs as a JSON string.

opal jobs submit --job-type lipid_permeation \
  --input-data '{"smiles": "O", "lipid_type": "POPC"}'

Reading the result

The two main outputs are dg_barrier, the height of the free energy barrier the molecule must cross (its uncertainty is dg_barrier_uncertainty), and dg_internal, the depth of the well inside the membrane (its uncertainty is dg_internal_uncertainty). Both are in the unit given by dg_unit (kcal/mol). In Azulene Studio these show as two hero numbers labelled “ΔG barrier” and “ΔG internal”. The input molecule is echoed back in smiles.

The full free energy profile is in z_positions (the depths sampled, in nanometers) paired with dg_values (the free energy at each depth), and dg_values_uncertainty for the matching uncertainties. Azulene Studio plots this profile as a curve. A higher dg_barrier means the molecule crosses the membrane more slowly. Sampling quality is summarized in mixing_statistics, which holds the transition matrix and eigenvalues used to check that the simulation mixed well. If keep_dirs is on, the full simulation outputs can be downloaded.

Notes

Keep the simulation lengths short for a quick first run. For reliable numbers, use longer production lengths. This tool runs on a GPU, and runtime grows with the simulation lengths. Large or very flexible molecules, including long linear peptides, may not converge well, since they cross membranes slowly on the timescales a simulation can reach; in those cases treat the barrier as a lower bound.