diff --git a/docs/tutorials/boresch_analysis.ipynb b/docs/tutorials/boresch_analysis.ipynb new file mode 120000 index 0000000..a49175f --- /dev/null +++ b/docs/tutorials/boresch_analysis.ipynb @@ -0,0 +1 @@ +../../examples/boresch_analysis.ipynb \ No newline at end of file diff --git a/docs/tutorials/index.rst b/docs/tutorials/index.rst index 6b34afa..381cd1e 100644 --- a/docs/tutorials/index.rst +++ b/docs/tutorials/index.rst @@ -10,3 +10,4 @@ Trajectory Analysis :maxdepth: 1 structural_analysis + boresch_analysis diff --git a/examples/boresch_analysis.ipynb b/examples/boresch_analysis.ipynb new file mode 100644 index 0000000..2e21644 --- /dev/null +++ b/examples/boresch_analysis.ipynb @@ -0,0 +1,446 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "5dbf77d2-c20f-4dbe-8dc2-a17870b62a65", + "metadata": {}, + "source": [ + "# Analyzing the Boresch restraint geometry\n", + "\n", + "A Boresch-style restraint restrains a ligand to its bound pose while its nonbonded interactions are switched off during a binding free energy calculation and is used in both ABFE and SepTop approaches (see\n", + "[Boresch et al., 2003](https://doi.org/10.1021/jp0217839) for the\n", + "original formulation of this restraint scheme). \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", + "The `BoreschRestraintAnalysis` in **openfe_analysis** computes a Boresch restraint's bond, two angles, and three dihedrals over a trajectory, for an `MDAnalysis.AtomGroup` of 6 atoms ordered `[H0, H1, H2, G0, G1, G2]` (host atoms then guest atoms).\n", + "\n", + "This notebook shows how to perform the restraint analysis for the SepTop protocol. Given a SepTop results JSON and its trajectory/topology files, we locate the restraint's atom indices and equilibrium reference values, run `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. \n", + "The same pattern applies to ABFE results, both protocols serialize restraint geometry as the same `BoreschRestraintGeometry` object with the difference that SepTop has two sets of Boresch-style restraints, one for each ligand, while ABFE has a single `BoreschRestraintGeometry` object." + ] + }, + { + "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/21872497/files/septop_boresch_analysis.tar.gz\",\n", + " known_hash=\"md5:e692f6b1cb6b43ba2986394cc887f327\",\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 output of the SepTop Analysis Unit of the complex-leg includes 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\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`). Here, we have a small function to help find the atom indices of the Boresch atoms in the subsampled system." + ] + }, + { + "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 a dictionary: `{\"val\": , \"unit\": \"\"}`. Here, we have a small helper function that reconstructs the `openff.units.Quantity`." + ] + }, + { + "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": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/hannahbaumann/.local/share/mamba/envs/openfe/lib/python3.13/site-packages/parmed/utils/netcdf.py:46: DeprecationWarning: `np.compat`, which was used during the Python 2 to 3 transition, is deprecated since 1.26.0, and will be removed\n", + " from numpy.compat import asbytes, asstr\n" + ] + } + ], + "source": [ + "selection_indices = np.asarray(complex_analysis_outputs[\"selection_indices\"])\n", + "analysis_results = {} \n", + "\n", + "TARGET_UNITS = [unit.angstrom, unit.radians, unit.radians, unit.radians, unit.radians, unit.radians]\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(TARGET_UNITS[0]),\n", + " quantity_from_geom(geom, \"theta_A0\").m_as(TARGET_UNITS[1]),\n", + " quantity_from_geom(geom, \"theta_B0\").m_as(TARGET_UNITS[2]),\n", + " quantity_from_geom(geom, \"phi_A0\").m_as(TARGET_UNITS[3]),\n", + " quantity_from_geom(geom, \"phi_B0\").m_as(TARGET_UNITS[4]),\n", + " quantity_from_geom(geom, \"phi_C0\").m_as(TARGET_UNITS[5]),\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", + "We plot 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": "28a108aa-9ebd-4a02-a59f-ae200175d73d", + "metadata": {}, + "outputs": [], + "source": [ + "STATE_COLORS = {\n", + " \"interacting, unrestrained\": \"#8a2283\",\n", + " \"non-interacting, restrained\": \"#00bdaa\",\n", + "}\n", + "\n", + "def label_lambda_window(ligand, window, n_lambda):\n", + " \"\"\"\n", + " Helper function to label lambda window.\n", + " \"\"\"\n", + " if n_lambda <= 1 or window not in (0, n_lambda - 1):\n", + " return f\"lambda_{window}\"\n", + " is_first_window = window == 0\n", + " if ligand == \"A\":\n", + " return \"interacting, unrestrained\" if is_first_window else \"non-interacting, restrained\"\n", + " if ligand == \"B\":\n", + " return \"non-interacting, restrained\" if is_first_window else \"interacting, unrestrained\"\n", + " return f\"lambda_{window}\"" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "ead81457", + "metadata": {}, + "outputs": [], + "source": [ + "def plot_boresch_restraint(analysis_results_for_ligand, ligand_label, ligand, 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", + " ligand : str\n", + " \"A\" or \"B\" \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", + " y_labels = [f\"[{u:~P}]\" for u in TARGET_UNITS]\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", + " first_ax = None\n", + " for window in windows:\n", + " label = label_lambda_window(ligand, window, n_lambda)\n", + " color = STATE_COLORS.get(label)\n", + " for i, attr in enumerate(titles):\n", + " values = analysis_results_for_ligand[attr][window]\n", + " ax = plt.subplot(2, 3, i + 1)\n", + " ax.plot(values, label=label, color=color)\n", + " ax.plot([reference_values[i]] * len(values), \"--\", c=\"black\")\n", + " ax.set_title(attr)\n", + " ax.set_ylabel(y_labels[i], fontsize=8)\n", + " if first_ax is None:\n", + " first_ax = ax\n", + "\n", + " handles, labels = first_ax.get_legend_handles_labels()\n", + " fig.suptitle(f\"Boresch restraint {ligand_label}\", fontsize=10, y=1.08)\n", + " fig.legend(\n", + " handles, labels,\n", + " loc=\"upper center\", bbox_to_anchor=(0.5, 0.99),\n", + " ncol=len(handles), fontsize=10, frameon=False,\n", + " )\n", + " fig.tight_layout()\n", + " return fig" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "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}\", 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.11" + } + }, + "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, + ) 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])