From 4227a6c9cbcc48e294f3d53a8a1baa85841f57d9 Mon Sep 17 00:00:00 2001 From: hannahbaumann Date: Tue, 7 Jul 2026 13:51:17 +0200 Subject: [PATCH 1/2] Add BoreschRestraintAnalysis class --- examples/boresch_analysis.ipynb | 397 ++++++++++++++++++++++++++++++ src/openfe_analysis/restraints.py | 92 +++++++ 2 files changed, 489 insertions(+) create mode 100644 examples/boresch_analysis.ipynb create mode 100644 src/openfe_analysis/restraints.py diff --git a/examples/boresch_analysis.ipynb b/examples/boresch_analysis.ipynb new file mode 100644 index 0000000..2b02a81 --- /dev/null +++ b/examples/boresch_analysis.ipynb @@ -0,0 +1,397 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "5dbf77d2-c20f-4dbe-8dc2-a17870b62a65", + "metadata": {}, + "source": [ + "# Analyzing the Boresch restraint geometry in the SepTop protocol\n", + "\n", + "A Boresch-style restraint restrains a ligand to its bound pose while its nonbonded interactions are switched off during a SepTop transformation. \n", + "Once a ligand is fully decoupled, the restraint is the only interaction holding it in place, since no protein-ligand nonbonded contacts remain to do so. \n", + "A restraint that is too loose, or anchored to a poor choice of atoms, may allow the ligand to drift or sample a pose other than the one intended, manifesting downstream as noisy per-repeat free energy estimates or slow convergence. Plotting the restraint's geometry against its equilibrium reference values provides a quick diagnostic for this failure mode.\n", + "\n", + "`openfe_analysis.boresch.BoreschRestraintAnalysis` computes a Boresch restraint's bond, two angles, and three dihedrals over a trajectory, for an MDAnalysis.AtomGroup of exactly 6 atoms ordered [H0, H1, H2, G0, G1, G2] (host atoms then guest atoms).\n", + "\n", + "In this tutorial we run the BoreschRestraintAnalysis across every lambda window, and plot the first and last against the reference values, as a visual check for whether the restraint remained well-behaved during the simulation." + ] + }, + { + "cell_type": "markdown", + "id": "e477b435", + "metadata": {}, + "source": [ + "## 1. Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "04735de3", + "metadata": {}, + "outputs": [], + "source": [ + "import json\n", + "import pathlib\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import MDAnalysis as mda\n", + "import netCDF4 as nc\n", + "import numpy as np\n", + "import pooch\n", + "from gufe.tokenization import JSON_HANDLER\n", + "from openfe_analysis import FEReader\n", + "from openfe_analysis.restraints import BoreschRestraintAnalysis\n", + "from openfe_analysis.utils.universe_utils import create_universe_single_state\n", + "from openff.units import Quantity, unit" + ] + }, + { + "cell_type": "markdown", + "id": "8ab98d94", + "metadata": {}, + "source": [ + "## 2. Download tutorial data" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "3576addc", + "metadata": {}, + "outputs": [], + "source": [ + "septop_files = pooch.retrieve(\n", + " url=\"https://zenodo.org/records/21164997/files/septop_boresch_analysis.tar.gz\",\n", + " known_hash=\"md5:00473a051af5188fb74dfe8eeb1d4db4\",\n", + " processor=pooch.Untar(extract_dir=\"septop_boresch_analysis\"),\n", + ")\n", + "\n", + "septop_paths = {pathlib.Path(f).suffix: pathlib.Path(f) for f in septop_files}\n", + "results_json = septop_paths[\".json\"]\n", + "trajectory_nc = septop_paths[\".nc\"]\n", + "subsampled_pdb = septop_paths[\".pdb\"]" + ] + }, + { + "cell_type": "markdown", + "id": "ae22568c", + "metadata": {}, + "source": [ + "## 3. Load the results JSON" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "11766ce1", + "metadata": {}, + "outputs": [], + "source": [ + "with open(results_json, \"r\") as f:\n", + " results = json.load(f, cls=JSON_HANDLER.decoder)" + ] + }, + { + "cell_type": "markdown", + "id": "776e7a8a", + "metadata": {}, + "source": [ + "## 4. Find the complex-leg Analysis unit outputs\n", + "\n", + "The complex-leg **Analysis** unit's outputs include everything we need:\n", + "`restraint_geometry_A/B` (atom indices and equilibrium reference values),\n", + "and `selection_indices` (how full-system atom indices map onto the\n", + "subsampled trajectory in `subsampled_pdb`/`trajectory_nc`). \n", + "\n", + "This example dataset contains a single repeat, so we take the first\n", + "complex-leg Analysis unit found. For multi-repeat data, match on\n", + "`outputs[\"repeat_id\"]` against the specific repeat whose trajectory you're\n", + "loading as SepTop can pick a different Boresch restraint per repeat." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "69a9c42b", + "metadata": {}, + "outputs": [], + "source": [ + "complex_analysis_outputs = None\n", + "\n", + "for key, unit_result in results[\"unit_results\"].items():\n", + " if not key.startswith(\"ProtocolUnitResult\"):\n", + " continue\n", + " if \"Analysis\" not in unit_result.get(\"name\", \"\"):\n", + " continue\n", + " outputs = unit_result[\"outputs\"]\n", + " if outputs.get(\"simtype\") != \"complex\":\n", + " continue\n", + " complex_analysis_outputs = outputs\n", + " break" + ] + }, + { + "cell_type": "markdown", + "id": "3fb109a2", + "metadata": {}, + "source": [ + "## 5. Helper: translate full-system atom indices\n", + "\n", + "`host_atoms`/`guest_atoms` in the restraint geometry are full-system\n", + "indices, but the trajectory only contains the subsampled atoms\n", + "(`selection_indices`). `BoreschRestraintAnalysis` doesn't know anything\n", + "about this translation, it just takes an `AtomGroup`, so we do it here,\n", + "before selecting the atomgroup to hand it." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "e0b76c55", + "metadata": {}, + "outputs": [], + "source": [ + "def translate_to_subsampled_indices(full_system_indices, selection_indices):\n", + " \"\"\"\n", + " Translate a list of full-system atom indices into their positions\n", + " within `selection_indices`, preserving the original order.\n", + " \"\"\"\n", + " selection_indices_list = selection_indices.tolist()\n", + " return [selection_indices_list.index(idx) for idx in full_system_indices]" + ] + }, + { + "cell_type": "markdown", + "id": "d2f889be", + "metadata": {}, + "source": [ + "## 6. Helper: reconstruct a Quantity from the stored restraint geometry\n", + "\n", + "Restraint geometry fields (`r_aA0`, `theta_A0`, ...) are gufe `Quantity`\n", + "fields, serialized as `{\"val\": , \"unit\": \"\"}`. We reconstruct a `openff.units.Quantity` and\n", + "convert explicitly to match `BoreschRestraintAnalysis`'s output units\n", + "(Angstrom for the bond, radians for angles/dihedrals)." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "acc22f86", + "metadata": {}, + "outputs": [], + "source": [ + "def quantity_from_geom(geom: dict, key: str) -> Quantity:\n", + " field = geom[key]\n", + " return Quantity(field[\"val\"], field[\"unit\"])" + ] + }, + { + "cell_type": "markdown", + "id": "05af9e4c", + "metadata": {}, + "source": [ + "## 7. Run `BoreschRestraintAnalysis` across every lambda window\n", + "\n", + "For each ligand (A and B), this translates the restraint's\n", + "`host_atoms`/`guest_atoms` into subsampled indices, then runs\n", + "`BoreschRestraintAnalysis` at every lambda window, storing the full per-state time series. " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "9074f914", + "metadata": {}, + "outputs": [], + "source": [ + "selection_indices = np.asarray(complex_analysis_outputs[\"selection_indices\"])\n", + "analysis_results = {} \n", + "\n", + "with nc.Dataset(trajectory_nc) as ds:\n", + " n_lambda = ds.dimensions[\"state\"].size\n", + "\n", + " if hasattr(ds, \"PositionInterval\"):\n", + " n_frames = len(range(0, ds.dimensions[\"iteration\"].size, ds.PositionInterval))\n", + " else:\n", + " n_frames = ds.dimensions[\"iteration\"].size\n", + "\n", + " skip = max(n_frames // 500, 1)\n", + "\n", + " u_top = mda.Universe(subsampled_pdb)\n", + "\n", + " for ligand in (\"A\", \"B\"):\n", + " geom_key = f\"restraint_geometry_{ligand}\"\n", + " geom = complex_analysis_outputs[geom_key]\n", + " host_atoms_full = geom[\"host_atoms\"]\n", + " guest_atoms_full = geom[\"guest_atoms\"]\n", + "\n", + " host_atoms = translate_to_subsampled_indices(host_atoms_full, selection_indices)\n", + " guest_atoms = translate_to_subsampled_indices(guest_atoms_full, selection_indices)\n", + " restraint_atom_indices = host_atoms + guest_atoms\n", + "\n", + " reference_values = [\n", + " quantity_from_geom(geom, \"r_aA0\").m_as(unit.angstrom),\n", + " quantity_from_geom(geom, \"theta_A0\").m_as(unit.radians),\n", + " quantity_from_geom(geom, \"theta_B0\").m_as(unit.radians),\n", + " quantity_from_geom(geom, \"phi_A0\").m_as(unit.radians),\n", + " quantity_from_geom(geom, \"phi_B0\").m_as(unit.radians),\n", + " quantity_from_geom(geom, \"phi_C0\").m_as(unit.radians),\n", + " ]\n", + "\n", + " output: dict[str, list] = {\n", + " \"bond\": [],\n", + " \"angle1\": [],\n", + " \"angle2\": [],\n", + " \"dihedral1\": [],\n", + " \"dihedral2\": [],\n", + " \"dihedral3\": [],\n", + " }\n", + "\n", + " for state_idx in range(n_lambda):\n", + " universe = create_universe_single_state(u_top._topology, ds, state_idx)\n", + " restraint_ag = universe.atoms[restraint_atom_indices]\n", + " restraint_analysis = BoreschRestraintAnalysis(restraint_ag).run(step=skip)\n", + "\n", + " output[\"bond\"].append(restraint_analysis.results.bond)\n", + " output[\"angle1\"].append(restraint_analysis.results.angle1)\n", + " output[\"angle2\"].append(restraint_analysis.results.angle2)\n", + " output[\"dihedral1\"].append(restraint_analysis.results.dihedral1)\n", + " output[\"dihedral2\"].append(restraint_analysis.results.dihedral2)\n", + " output[\"dihedral3\"].append(restraint_analysis.results.dihedral3)\n", + "\n", + " analysis_results[ligand] = {\"reference_values\": reference_values, **output}" + ] + }, + { + "cell_type": "markdown", + "id": "267ce971", + "metadata": {}, + "source": [ + "## 8. Plot the results\n", + "\n", + "By default this plots the first and last lambda windows which are usually the\n", + "most informative pair to check, since it confirms the restraint behaves\n", + "consistently at both ends of the alchemical pathway. Pass `windows=[...]` to plot a\n", + "different subset." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "ead81457", + "metadata": {}, + "outputs": [], + "source": [ + "def plot_boresch_restraint(analysis_results_for_ligand, ligand_label, windows=None):\n", + " \"\"\"\n", + " Plot BoreschRestraintAnalysis results for selected lambda windows\n", + " against their reference values.\n", + "\n", + " Parameters\n", + " ----------\n", + " analysis_results_for_ligand : dict\n", + " One ligand's entry from `analysis_results`: a dict with keys\n", + " \"reference_values\", \"bond\", \"angle1\", \"angle2\", \"dihedral1\",\n", + " \"dihedral2\", \"dihedral3\" -- each (other than \"reference_values\")\n", + " a list indexed by lambda state.\n", + " ligand_label : str\n", + " Used in the figure title.\n", + " windows : list[int], optional\n", + " Which lambda state indices to plot. Defaults to the first and last\n", + " state.\n", + " \"\"\"\n", + " titles = [\"bond\", \"angle1\", \"angle2\", \"dihedral1\", \"dihedral2\", \"dihedral3\"]\n", + " reference_values = analysis_results_for_ligand[\"reference_values\"]\n", + " n_lambda = len(analysis_results_for_ligand[\"bond\"])\n", + "\n", + " if windows is None:\n", + " windows = [0, n_lambda - 1] if n_lambda > 1 else [0]\n", + "\n", + " fig = plt.figure(figsize=(8, 4))\n", + " for window in windows:\n", + " for i, attr in enumerate(titles):\n", + " values = analysis_results_for_ligand[attr][window]\n", + " plt.subplot(2, 3, i + 1)\n", + " plt.plot(values, label=f\"lambda_{window}\")\n", + " plt.plot([reference_values[i]] * len(values), \"--\", c=\"black\")\n", + " plt.title(attr)\n", + " if i == 0:\n", + " plt.legend(fontsize=7)\n", + "\n", + " fig.suptitle(f\"Boresch restraint -- {ligand_label}\", fontsize=10)\n", + " fig.tight_layout()\n", + " return fig" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "d89bfd1a-49d5-4c77-92c3-bb599eac48df", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for ligand, data in analysis_results.items():\n", + " fig = plot_boresch_restraint(data, ligand_label=f\"complex leg, ligand {ligand}\")\n", + " plt.show()\n", + " plt.close(fig)" + ] + }, + { + "cell_type": "markdown", + "id": "c423132c", + "metadata": {}, + "source": [ + "## What to look for\n", + "\n", + "For a well-behaved restraint, each quantity (bond, angle1, angle2,\n", + "dihedral1, dihedral2, dihedral3) should fluctuate around its dashed\n", + "reference line, for both the first and last lambda window. If a quantity\n", + "sits at a consistent offset from the reference line rather than fluctuating\n", + "around it, that's worth investigating." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.14" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/openfe_analysis/restraints.py b/src/openfe_analysis/restraints.py new file mode 100644 index 0000000..cfb0cf7 --- /dev/null +++ b/src/openfe_analysis/restraints.py @@ -0,0 +1,92 @@ +import MDAnalysis as mda +import numpy as np +from MDAnalysis.analysis.base import AnalysisBase + + +class BoreschRestraintAnalysis(AnalysisBase): + """ + Boresch restraint geometry (bond, 2 angles, 3 dihedrals) time series. + + Parameters + ---------- + atomgroup : mda.AtomGroup + Exactly 6 atoms, ordered [H0, H1, H2, G0, G1, G2] (host atoms then + guest atoms), matching the atom ordering used by + ``openfe.protocols.restraint_utils.geometry.boresch``. + + Raises + ------ + ValueError + If ``atomgroup`` does not contain exactly 6 atoms. + + Notes + ----- + Bond length is reported in Angstrom; angles and dihedrals are reported + in radians, matching the units returned by MDAnalysis's + ``calc_bonds``/``calc_angles``/``calc_dihedrals``. Reported quantities + are, in order: the H0-G0 bond, the H1-H0-G0 and H0-G0-G1 angles, and the + H2-H1-H0-G0, H1-H0-G0-G1, and H0-G0-G1-G2 dihedrals. + """ + + _analysis_algorithm_is_parallelizable = False + + def __init__(self, atomgroup: mda.AtomGroup, **kwargs): + super().__init__(atomgroup.universe.trajectory, **kwargs) + if len(atomgroup) != 6: + raise ValueError( + f"atomgroup must contain exactly 6 atoms (3 host + 3 guest), got {len(atomgroup)}." + ) + self._ag = atomgroup + + def _prepare(self) -> None: + self.results.bond = np.zeros(self.n_frames, dtype=np.float64) + self.results.angle1 = np.zeros(self.n_frames, dtype=np.float64) + self.results.angle2 = np.zeros(self.n_frames, dtype=np.float64) + self.results.dihedral1 = np.zeros(self.n_frames, dtype=np.float64) + self.results.dihedral2 = np.zeros(self.n_frames, dtype=np.float64) + self.results.dihedral3 = np.zeros(self.n_frames, dtype=np.float64) + + def _single_frame(self) -> None: + atoms = self._ag.atoms + box = self._ag.dimensions + + self.results.bond[self._frame_index] = mda.lib.distances.calc_bonds( + atoms[0].position, + atoms[3].position, + box=box, + ) + + self.results.angle1[self._frame_index] = mda.lib.distances.calc_angles( + atoms[1].position, + atoms[0].position, + atoms[3].position, + box=box, + ) + self.results.angle2[self._frame_index] = mda.lib.distances.calc_angles( + atoms[0].position, + atoms[3].position, + atoms[4].position, + box=box, + ) + + self.results.dihedral1[self._frame_index] = mda.lib.distances.calc_dihedrals( + atoms[2].position, + atoms[1].position, + atoms[0].position, + atoms[3].position, + box=box, + ) + self.results.dihedral2[self._frame_index] = mda.lib.distances.calc_dihedrals( + atoms[1].position, + atoms[0].position, + atoms[3].position, + atoms[4].position, + box=box, + ) + self.results.dihedral3[self._frame_index] = mda.lib.distances.calc_dihedrals( + atoms[0].position, + atoms[3].position, + atoms[4].position, + atoms[5].position, + box=box, + ) From 4c56f0925eb66c49e73ad7fb7d412416bd805b2e Mon Sep 17 00:00:00 2001 From: hannahbaumann Date: Tue, 7 Jul 2026 14:01:37 +0200 Subject: [PATCH 2/2] add tests --- src/openfe_analysis/tests/test_restraints.py | 75 ++++++++++++++++++++ 1 file changed, 75 insertions(+) create mode 100644 src/openfe_analysis/tests/test_restraints.py diff --git a/src/openfe_analysis/tests/test_restraints.py b/src/openfe_analysis/tests/test_restraints.py new file mode 100644 index 0000000..a1dbeb6 --- /dev/null +++ b/src/openfe_analysis/tests/test_restraints.py @@ -0,0 +1,75 @@ +import MDAnalysis as mda +import pytest +from MDAnalysis.lib.distances import calc_angles, calc_bonds, calc_dihedrals +from MDAnalysisTests.datafiles import DCD, PSF +from numpy.testing import assert_allclose + +from openfe_analysis.restraints import BoreschRestraintAnalysis + + +@pytest.fixture +def mda_universe(): + return mda.Universe(PSF, DCD) + + +class TestBoreschRestraintAnalysis: + def test_matches_direct_mda_calls(self, mda_universe): + atoms = mda_universe.atoms[[10, 20, 30, 40, 50, 60]] + result = BoreschRestraintAnalysis(atoms).run(step=25) + + expected = { + "bond": [], + "angle1": [], + "angle2": [], + "dihedral1": [], + "dihedral2": [], + "dihedral3": [], + } + for _ in mda_universe.trajectory[::25]: + box = atoms.dimensions + expected["bond"].append(calc_bonds(atoms[0].position, atoms[3].position, box=box)) + expected["angle1"].append( + calc_angles(atoms[1].position, atoms[0].position, atoms[3].position, box=box) + ) + expected["angle2"].append( + calc_angles(atoms[0].position, atoms[3].position, atoms[4].position, box=box) + ) + expected["dihedral1"].append( + calc_dihedrals( + atoms[2].position, + atoms[1].position, + atoms[0].position, + atoms[3].position, + box=box, + ) + ) + expected["dihedral2"].append( + calc_dihedrals( + atoms[1].position, + atoms[0].position, + atoms[3].position, + atoms[4].position, + box=box, + ) + ) + expected["dihedral3"].append( + calc_dihedrals( + atoms[0].position, + atoms[3].position, + atoms[4].position, + atoms[5].position, + box=box, + ) + ) + + assert_allclose(result.results.bond, expected["bond"]) + assert_allclose(result.results.angle1, expected["angle1"]) + assert_allclose(result.results.angle2, expected["angle2"]) + assert_allclose(result.results.dihedral1, expected["dihedral1"]) + assert_allclose(result.results.dihedral2, expected["dihedral2"]) + assert_allclose(result.results.dihedral3, expected["dihedral3"]) + + @pytest.mark.parametrize("n_atoms", [5, 7]) + def test_raises_on_wrong_atom_count(self, mda_universe, n_atoms): + with pytest.raises(ValueError, match="exactly 6 atoms"): + BoreschRestraintAnalysis(mda_universe.atoms[:n_atoms])