{ "cells": [ { "cell_type": "markdown", "id": "67a90f15", "metadata": {}, "source": [ "# Tutorial 05 — Minimization, Constraints, and Kinematics\n", "\n", "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/uw-ipd/tmol/blob/master/docs/tutorial/05_minimization_constraints_kinematics.ipynb)\n", "\n", "This tutorial minimizes a small structure, limits which degrees of freedom may move, and adds coordinate or distance constraints.\n", "\n", "## Learning objectives\n", "\n", "- Run Cartesian minimization with an atom-coordinate mask.\n", "- Run kinematic minimization with a `MoveMap` and `FoldForest`.\n", "- Add a constraint and inspect its effect on score and geometry.\n", "\n", "## Before you begin\n", "\n", "- **Prerequisites:** [03 — Scoring and analysis](03_scoring_and_analysis.ipynb), including score terms and coordinate gradients.\n", "- **Curriculum:** This is the continuous-sampling branch after 03. Complete the parallel [04 — Packing](04_packing_and_mutation_scan.ipynb) branch before [06 — FastRelax](06_fast_relax.ipynb) combines both.\n", "- **Related:** [Optimization workflow](../user_guide/optimization.md) · [Kinematics API](../api/kinematics.rst)\n", "\n", "The short runs are smoke tests, not convergence studies. They run on CPU; larger systems benefit from CUDA." ] }, { "cell_type": "markdown", "id": "43f7d222", "metadata": {}, "source": [ "## Setup\n", "\n", "The examples use a checked-in eight-residue 1UBQ slice on the selected CPU or CUDA device. A fixed constraint weight and ten minimizer iterations keep the Cartesian and kinematic runs suitable for documentation smoke tests; later sections explain why finite output is not evidence of convergence." ] }, { "cell_type": "code", "execution_count": 1, "id": "31075352", "metadata": {}, "outputs": [], "source": [ "try:\n", " import google.colab # noqa: F401\n", "except ImportError:\n", " IN_COLAB = False\n", "else:\n", " IN_COLAB = True\n", "\n", "if IN_COLAB:\n", " from urllib.request import urlopen\n", "\n", " exec(\n", " urlopen(\n", " \"https://raw.githubusercontent.com/uw-ipd/tmol/\"\n", " \"master/docs/tutorial/colab_setup.py\"\n", " ).read(),\n", " globals(),\n", " )\n", " setup_colab([\"tmol/tests/data/cif/1UBQ.cif\"])" ] }, { "cell_type": "code", "execution_count": 2, "id": "85863de1", "metadata": {}, "outputs": [], "source": [ "from contextlib import redirect_stderr, redirect_stdout\n", "from io import StringIO\n", "from pathlib import Path\n", "import warnings\n", "\n", "import attrs\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import pandas as pd\n", "import torch\n", "from IPython.display import display\n", "from biotite.structure.io import load_structure\n", "\n", "import tmol\n", "from tmol.io import pose_stack_from_biotite\n", "from tmol.kinematics import CartesianMoveMap, EdgeType, FoldForest, MoveMap\n", "from tmol.ops import res_mask_to_coord_mask\n", "from tmol.optimization import run_cart_min, run_kin_min\n", "from tmol.pose import ConstraintSet, PoseStackBuilder\n", "from tmol.score import ScoreType, beta2016_score_function\n", "from tmol.score.constraint import (\n", " ConstraintEnergyTerm,\n", " create_mainchain_coordinate_constraints,\n", ")\n", "\n", "SEED = 20260807\n", "np.random.seed(SEED)\n", "torch.manual_seed(SEED)\n", "warnings.filterwarnings(\n", " \"ignore\", message=r\"Sparse invariant checks are implicitly disabled.*\"\n", ")\n", "device = (\n", " torch.device(\"cuda\", torch.cuda.current_device())\n", " if torch.cuda.is_available()\n", " else torch.device(\"cpu\")\n", ")\n", "\n", "\n", "def show_table(frame):\n", " \"\"\"Use a sortable docs table when available, otherwise display pandas.\"\"\"\n", " try:\n", " from itables import show\n", " except ImportError:\n", " return display(frame)\n", " return show(frame)\n", "\n", "\n", "def score_components(pose_stack, score_function):\n", " scorer = score_function.render_whole_pose_scoring_module(pose_stack)\n", " weighted_terms = scorer(\n", " pose_stack.coords, sum_terms=False, apply_weights=True\n", " )[:, 0]\n", " score_types = score_function.all_score_types()\n", " constraint_index = next(\n", " index\n", " for index, score_type in enumerate(score_types)\n", " if score_type == ScoreType.constraint\n", " )\n", " constraint_score = weighted_terms[constraint_index]\n", " non_constraint_score = weighted_terms.sum() - constraint_score\n", " return {\n", " \"non_constraint_score_units\": float(non_constraint_score.detach().cpu()),\n", " \"constraint_score_units\": float(constraint_score.detach().cpu()),\n", " \"reported_total_score_units\": float(weighted_terms.sum().detach().cpu()),\n", " }\n", "\n", "\n", "def common_atom_mask(reference, mobile, atom_mask=None):\n", " finite = torch.isfinite(reference.coords).all(dim=-1)\n", " finite &= torch.isfinite(mobile.coords).all(dim=-1)\n", " return finite if atom_mask is None else finite & atom_mask\n", "\n", "\n", "def rms_displacement(reference, mobile, atom_mask=None):\n", " \"\"\"Raw RMS displacement in the input frame; no superposition is applied.\"\"\"\n", " mask = common_atom_mask(reference, mobile, atom_mask)\n", " delta = mobile.coords[mask] - reference.coords[mask]\n", " return float(torch.sqrt(torch.mean(torch.sum(delta * delta, dim=-1))).cpu())\n", "\n", "\n", "def kabsch_aligned_rmsd(reference, mobile, atom_mask=None):\n", " \"\"\"RMSD after least-squares rigid-body superposition of mobile onto reference.\"\"\"\n", " mask = common_atom_mask(reference, mobile, atom_mask)\n", " reference_xyz = reference.coords[mask]\n", " mobile_xyz = mobile.coords[mask]\n", " reference_centered = reference_xyz - reference_xyz.mean(dim=0)\n", " mobile_centered = mobile_xyz - mobile_xyz.mean(dim=0)\n", "\n", " covariance = mobile_centered.T @ reference_centered\n", " u, _, vh = torch.linalg.svd(covariance)\n", " handedness = torch.sign(torch.det(u @ vh))\n", " correction = torch.eye(3, device=mobile_xyz.device, dtype=mobile_xyz.dtype)\n", " correction[-1, -1] = handedness\n", " rotation = u @ correction @ vh\n", " aligned_mobile = mobile_centered @ rotation\n", " delta = aligned_mobile - reference_centered\n", " return float(torch.sqrt(torch.mean(torch.sum(delta * delta, dim=-1))).cpu())\n", "\n", "\n", "def declared_mainchain_atom_mask(pose_stack):\n", " \"\"\"Select atoms named in each residue type's TMol polymer declaration.\"\"\"\n", " mask = torch.zeros_like(pose_stack.real_atoms)\n", " atom_names = []\n", " seen_atom_names = set()\n", " for pose_index in range(pose_stack.n_poses):\n", " for block_index in range(pose_stack.max_n_blocks):\n", " block_type_index = int(\n", " pose_stack.block_type_ind64[pose_index, block_index].item()\n", " )\n", " if block_type_index < 0:\n", " continue\n", " block_type = pose_stack.packed_block_types.active_block_types[\n", " block_type_index\n", " ]\n", " polymer = block_type.properties.polymer\n", " if polymer is None:\n", " continue\n", " atom_offset = int(\n", " pose_stack.block_coord_offset64[pose_index, block_index].item()\n", " )\n", " for atom_name in polymer.mainchain_atoms:\n", " atom_index = atom_offset + block_type.atom_to_idx[atom_name]\n", " if bool(pose_stack.real_atoms[pose_index, atom_index]):\n", " mask[pose_index, atom_index] = True\n", " if atom_name not in seen_atom_names:\n", " atom_names.append(atom_name)\n", " seen_atom_names.add(atom_name)\n", " return mask, tuple(atom_names)" ] }, { "cell_type": "markdown", "id": "5feb6333", "metadata": {}, "source": [ "## Build a small pose and compare FoldForests\n", "\n", "`FoldForest.reasonable_fold_forest()` derives polymer and jump edges from backbone connectivity. Each edge is `(type, start block, end block, jump index)`, and the edge array is batched over poses.\n", "\n", "The same contiguous chain is also written explicitly with `FoldForest.from_edges()`. Finally, a per-residue-root or “dandelion” forest attaches every real block to the virtual root. That representation matches neural-network models that predict one frame per residue while retaining internal side-chain geometry; it changes the movable DOFs and is not a generic replacement for a polymer forest." ] }, { "cell_type": "code", "execution_count": 3, "id": "3370fde4", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "input: 1UBQ.cif\n", "automatic FoldForest edge tensor shape: (1, 2, 4)\n" ] }, { "data": { "text/html": [ "\n", "\n", " \n", " \n", " \n", " \n", " \n", "\n", "
\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
forestposeedgetypestartendjump_index
automatic polymer00root_jump-10-1
automatic polymer01polymer07-1
explicit polymer00root_jump-10-1
explicit polymer01polymer07-1
per-residue root / dandelion00root_jump-10-1
per-residue root / dandelion01root_jump-11-1
per-residue root / dandelion02root_jump-12-1
per-residue root / dandelion03root_jump-13-1
per-residue root / dandelion04root_jump-14-1
per-residue root / dandelion05root_jump-15-1
(2 more rows not shown)
\n", "\n", "\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "repo_root = Path.cwd()\n", "if not (repo_root / \"tmol/tests/data/cif/1UBQ.cif\").exists():\n", " repo_root = Path(tmol.__file__).resolve().parents[1]\n", "cif_path = repo_root / \"tmol\" / \"tests\" / \"data\" / \"cif\" / \"1UBQ.cif\"\n", "atom_array = load_structure(str(cif_path), model=1, include_bonds=True)\n", "protein_slice = atom_array[(atom_array.chain_id == \"A\") & (atom_array.res_id <= 8)]\n", "pose_diagnostics = StringIO()\n", "try:\n", " with redirect_stdout(pose_diagnostics), redirect_stderr(pose_diagnostics):\n", " start = pose_stack_from_biotite(protein_slice, device, no_optH=True)\n", "except Exception:\n", " print(pose_diagnostics.getvalue())\n", " raise\n", "\n", "score_function = beta2016_score_function(device)\n", "score_function.set_weight(ScoreType.constraint, 1.0)\n", "fold_forest = FoldForest.reasonable_fold_forest(start)\n", "\n", "explicit_edges = np.full((1, 2, 4), -1, dtype=np.int64)\n", "explicit_edges[0, 0] = [int(EdgeType.root_jump), -1, 0, -1]\n", "explicit_edges[0, 1] = [\n", " int(EdgeType.polymer),\n", " 0,\n", " start.max_n_blocks - 1,\n", " -1,\n", "]\n", "explicit_fold_forest = FoldForest.from_edges(explicit_edges)\n", "\n", "# One root edge per real block: useful for per-residue NN frames.\n", "dandelion_edges = np.full(\n", " (start.n_poses, start.max_n_blocks, 4), -1, dtype=np.int64\n", ")\n", "dandelion_edges[:, :, 0] = int(EdgeType.root_jump)\n", "dandelion_edges[:, :, 1] = -1\n", "dandelion_edges[:, :, 2] = np.arange(start.max_n_blocks)[None, :]\n", "per_residue_root_forest = FoldForest.from_edges(dandelion_edges)\n", "assert int(per_residue_root_forest.n_edges[0]) == start.max_n_blocks\n", "\n", "edge_names = {int(edge): edge.name for edge in EdgeType}\n", "edge_rows = []\n", "for forest_name, forest in (\n", " (\"automatic polymer\", fold_forest),\n", " (\"explicit polymer\", explicit_fold_forest),\n", " (\"per-residue root / dandelion\", per_residue_root_forest),\n", "):\n", " for pose_i in range(start.n_poses):\n", " for edge_i in range(int(forest.n_edges[pose_i])):\n", " edge_type, begin, end, jump_index = forest.edges[pose_i, edge_i]\n", " edge_rows.append(\n", " {\n", " \"forest\": forest_name,\n", " \"pose\": pose_i,\n", " \"edge\": edge_i,\n", " \"type\": edge_names[int(edge_type)],\n", " \"start\": int(begin),\n", " \"end\": int(end),\n", " \"jump_index\": int(jump_index),\n", " }\n", " )\n", "\n", "print(\"input:\", cif_path.name)\n", "print(\"automatic FoldForest edge tensor shape:\", fold_forest.edges.shape)\n", "show_table(pd.DataFrame(edge_rows))" ] }, { "cell_type": "markdown", "id": "a421c604", "metadata": {}, "source": [ "**Expected observations.** The automatic and explicit polymer forests each contain a `root_jump` whose start is `-1`, followed by a polymer edge covering the contiguous 1UBQ slice. The dandelion forest instead has one `root_jump` per real block and no polymer edge. A `jump_index` of `-1` is expected for root-jump and polymer edges; only ordinary jumps receive contiguous non-negative jump indices. Missing, duplicated, or overlapping coverage indicates a malformed forest and should be investigated before minimization.\n", "\n", "TMol's `FoldForest` differs from Rosetta's `FoldTree` in one important invariant: every TMol forest has an explicit virtual root at the origin. `reasonable_fold_forest()` follows backbone up/down connections, turns same-chain gaps into jumps, and roots separate chains independently. Its current automatic builder intentionally ignores non-polymer connections such as disulfides." ] }, { "cell_type": "markdown", "id": "a4e44f5c", "metadata": {}, "source": [ "## Executable constrained and unconstrained workflow\n", "\n", "`run_cart_min` accepts `(pose_stack, sfxn, coord_mask=None, optimizer_cls=..., optimizer_kwargs=None, verbose=False)`. `run_kin_min` accepts `(pose_stack, sfxn, ff, mm, optimizer_cls=..., optimizer_kwargs=None, verbose=False, kin_dtype=...)`.\n", "\n", "### One meaningful low-level distance restraint\n", "\n", "A `ConstraintSet` identifies atoms by `(pose, block, atom-within-block)`. The code adds one harmonic distance restraint between the first and last Cα atoms of this eight-residue fragment, targeted to their input distance with σ = 0.5 Å. It then uses `add_constraints_to_all_poses()` to replicate that same block-local definition across a two-pose batch. The restraint is linear in system size and tied to an explicit structural hypothesis.\n", "\n", "### Declared-main-chain coordinate restraints\n", "\n", "`create_mainchain_coordinate_constraints()` follows each residue type's `mainchain_atoms` declaration. For the standard amino acids in this fixture those atoms are **N, CA, and C**; O is not declared as main chain and is not constrained. The helper uses harmonic-coordinate σ = 0.5 Å and retains existing constraints. This residue-type-driven definition is preferable to assuming that every block contains a protein Cα atom.\n", "\n", "The score-function constraint weight is 1.0 for this TMol demonstration. Rosetta constraint weights are protocol-specific, so score magnitudes should not be compared without matching constraint definitions, functional forms, and weights.\n", "\n", "### Cartesian and kinematic degrees of freedom\n", "\n", "The Cartesian runs move every finite atom coordinate independently. Without coordinate restraints, a single isolated molecule has global translation and rotation directions that do not change its internal score: six rigid-body null modes. Raw displacement can therefore include arbitrary frame drift, whereas Kabsch-aligned RMSD removes the best global translation and rotation before measuring internal change.\n", "\n", "The kinematic runs below explicitly fix ordinary jumps and the virtual-root jump, so the chain cannot translate or rotate as a rigid body. `move_all_named_torsions=True` enables both named main-chain and side-chain torsions; with the default ideal kinematics it does not independently optimize bond lengths and angles. By contrast, Cartesian minimization can distort local geometry, but beta2016 actively penalizes it through the nonzero cartbonded score terms `cart_lengths`, `cart_angles`, `cart_torsions`, `cart_impropers`, and `cart_hxltorsions` (each weighted 0.5). Thus Cartesian and kinematic runs are different coordinate models, not interchangeable optimizers over identical degrees of freedom." ] }, { "cell_type": "code", "execution_count": 4, "id": "7bfd3b27", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "distance restraint: block 0 CA ↔ block 7 CA; target=23.155 Å; sigma=0.5 Å\n", "distance constraints in one pose / replicated batch: 1 / 2\n", "declared-main-chain coordinate restraints: 24\n", "coordinate-restraint atom names: N, CA, C\n", "coordinate-restraint count: 24\n", "coordinate-restraint sigma: 0.5 Å\n", "coordinate-restraint score weight: 1.0\n", "O is not TMol-declared main chain here and is not constrained.\n", "Weight 1.0 is intentional; constraint weights are protocol-specific.\n", "smoke-test optimizer max_iter: 10 (convergence not assessed)\n" ] } ], "source": [ "cartesian_move_map = CartesianMoveMap(\n", " coord_mask=torch.isfinite(start.coords).all(dim=-1)\n", ")\n", "kinematic_move_map = MoveMap.from_pose_stack(start)\n", "kinematic_move_map.move_all_named_torsions = True # named MC and SC torsions\n", "kinematic_move_map.move_all_jumps = False\n", "kinematic_move_map.move_all_root_jumps = False\n", "\n", "mainchain_mask, restrained_atom_names = declared_mainchain_atom_mask(start)\n", "constraint_diagnostics = StringIO()\n", "try:\n", " with redirect_stdout(constraint_diagnostics), redirect_stderr(constraint_diagnostics):\n", " constrained_start = create_mainchain_coordinate_constraints(start.clone())\n", "except Exception:\n", " print(constraint_diagnostics.getvalue())\n", " raise\n", "\n", "# One low-level Cα distance restraint, expressed in block-local atom indices.\n", "first_block, last_block = 0, start.max_n_blocks - 1\n", "first_ca = start.block_type(0, first_block).atom_to_idx[\"CA\"]\n", "last_ca = start.block_type(0, last_block).atom_to_idx[\"CA\"]\n", "first_coord_index = int(start.block_coord_offset64[0, first_block]) + first_ca\n", "last_coord_index = int(start.block_coord_offset64[0, last_block]) + last_ca\n", "target_distance = torch.linalg.vector_norm(\n", " start.coords[0, first_coord_index] - start.coords[0, last_coord_index]\n", ")\n", "distance_atoms = torch.tensor(\n", " [[[0, first_block, first_ca], [0, last_block, last_ca]]],\n", " dtype=torch.int32,\n", " device=device,\n", ")\n", "distance_params = torch.zeros((1, 4), dtype=torch.float32, device=device)\n", "distance_params[0, 0] = target_distance\n", "distance_params[0, 1] = 0.5\n", "distance_constraint_set = ConstraintSet.create_empty(device, 1).add_constraints(\n", " ConstraintEnergyTerm.harmonic,\n", " distance_atoms,\n", " distance_params,\n", ")\n", "distance_constrained_start = attrs.evolve(\n", " start, constraint_set=distance_constraint_set\n", ")\n", "\n", "constraint_batch = PoseStackBuilder.from_poses([start] * 2, device)\n", "batch_constraint_set = ConstraintSet.create_empty(\n", " device, constraint_batch.n_poses\n", ").add_constraints_to_all_poses(\n", " ConstraintEnergyTerm.harmonic,\n", " distance_atoms,\n", " distance_params,\n", ")\n", "distance_constrained_batch = attrs.evolve(\n", " constraint_batch, constraint_set=batch_constraint_set\n", ")\n", "assert len(distance_constraint_set.constraint_function_inds) == 1\n", "assert len(batch_constraint_set.constraint_function_inds) == 2\n", "\n", "CONSTRAINT_SIGMA_A = 0.5\n", "constraint_weight = float(score_function.get_weight(ScoreType.constraint))\n", "print(\n", " f\"distance restraint: block {first_block} CA ↔ block {last_block} CA; \"\n", " f\"target={float(target_distance):.3f} Å; sigma=0.5 Å\"\n", ")\n", "print(\n", " \"distance constraints in one pose / replicated batch:\",\n", " len(distance_constraint_set.constraint_function_inds),\n", " \"/\",\n", " len(batch_constraint_set.constraint_function_inds),\n", ")\n", "print(\n", " \"declared-main-chain coordinate restraints:\",\n", " len(constrained_start.constraint_set.constraint_function_inds),\n", ")\n", "print(\"coordinate-restraint atom names:\", \", \".join(restrained_atom_names))\n", "print(\"coordinate-restraint count:\", int(mainchain_mask.sum().item()))\n", "print(f\"coordinate-restraint sigma: {CONSTRAINT_SIGMA_A:.1f} Å\")\n", "print(f\"coordinate-restraint score weight: {constraint_weight:.1f}\")\n", "print(\"O is not TMol-declared main chain here and is not constrained.\")\n", "print(\"Weight 1.0 is intentional; constraint weights are protocol-specific.\")\n", "\n", "# Strictly a short smoke-test budget for tutorial/CI runtime. Finite output and\n", "# a lower objective after ten iterations do not demonstrate convergence.\n", "TUTORIAL_MAX_ITER = 10\n", "optimizer_kwargs = {\"max_iter\": TUTORIAL_MAX_ITER}\n", "print(f\"smoke-test optimizer max_iter: {TUTORIAL_MAX_ITER} (convergence not assessed)\")\n", "\n", "# Every branch starts from the same coordinates, score function, and iteration\n", "# budget. Within each coordinate model, only the presence of restraints changes.\n", "cart_unconstrained = run_cart_min(\n", " start.clone(),\n", " score_function,\n", " coord_mask=cartesian_move_map.coord_mask,\n", " optimizer_kwargs=optimizer_kwargs,\n", ")\n", "cart_constrained = run_cart_min(\n", " constrained_start.clone(),\n", " score_function,\n", " coord_mask=cartesian_move_map.coord_mask,\n", " optimizer_kwargs=optimizer_kwargs,\n", ")\n", "kin_unconstrained = run_kin_min(\n", " start.clone(),\n", " score_function,\n", " fold_forest,\n", " kinematic_move_map,\n", " optimizer_kwargs=optimizer_kwargs,\n", ")\n", "kin_constrained = run_kin_min(\n", " constrained_start.clone(),\n", " score_function,\n", " fold_forest,\n", " kinematic_move_map,\n", " optimizer_kwargs=optimizer_kwargs,\n", ")" ] }, { "cell_type": "code", "execution_count": 5, "id": "10e2283e", "metadata": { "tags": [ "collapse-code" ] }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/tmp/ipykernel_3837/382234577.py:78: UserWarning: Converting a tensor with requires_grad=True to a scalar may lead to unexpected behavior.\n", "Consider using tensor.detach() first. (Triggered internally at /__w/pytorch/pytorch/torch/csrc/autograd/generated/python_variable_methods.cpp:820.)\n", " return float(torch.sqrt(torch.mean(torch.sum(delta * delta, dim=-1))).cpu())\n" ] }, { "data": { "text/html": [ "\n", "\n", " \n", " \n", " \n", " \n", " \n", "\n", "
\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "\n", "\n", "\n", "\n", "\n", "
variantnon_constraint_score_unitsconstraint_score_unitsreported_total_score_unitsnon_constraint_score_change_unitsconstraint_score_change_unitsobjective_change_unitsall_atom_raw_RMS_displacement_Aall_atom_Kabsch_RMSD_Amainchain_raw_RMS_displacement_Amainchain_Kabsch_RMSD_Afinite_smoke_test_outputconvergence_status
start27.4256740.00000027.4256740.0000000.0000000.0000000.0000000.0000000.0000000.000000Truenot assessed
Cartesian, unconstrained10.5240350.00000010.524035-16.9016390.000000-16.9016390.0767750.0767750.0586330.054905Truenot assessed (10-iteration smoke test)
Cartesian, constrained10.5624450.26405210.826496-16.8632300.264052-16.5991780.0751840.0751690.0524460.049689Truenot assessed (10-iteration smoke test)
Kinematic, unconstrained15.2107040.00000015.210704-12.2149710.000000-12.2149714.4929561.6551693.9214570.901909Truenot assessed (10-iteration smoke test)
Kinematic, constrained20.7377890.88353621.621326-6.6878850.883536-5.8043480.3158620.2441280.0959350.081197Truenot assessed (10-iteration smoke test)
\n", "\n", "\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/3dmoljs_load.v0": "
\n

3Dmol.js failed to load for some reason. Please check your browser console for error messages.

\n
\n", "text/html": [ "
\n", "

3Dmol.js failed to load for some reason. Please check your browser console for error messages.

\n", "
\n", "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "\n", "
\n", " \n", "
\n", " \n", "
\n", "
Starting 1UBQ slice
\n", "
\n", "

3Dmol.js failed to load for some reason. Please check your browser console for error messages.

\n", "
\n", "\n", "
\n", "
\n", "
objective change -16.902 score units; non-constraint 10.524; constraint 0.000; main-chain raw/aligned 0.059/0.055 Å; convergence not assessed
\n", "
\n", "

3Dmol.js failed to load for some reason. Please check your browser console for error messages.

\n", "
\n", "\n", "
\n", "
\n", "
objective change -16.599 score units; non-constraint 10.562; constraint 0.264; main-chain raw/aligned 0.052/0.050 Å; convergence not assessed
\n", "
\n", "

3Dmol.js failed to load for some reason. Please check your browser console for error messages.

\n", "
\n", "\n", "
\n", "
\n", "
objective change -12.215 score units; non-constraint 15.211; constraint 0.000; main-chain raw/aligned 3.921/0.902 Å; convergence not assessed
\n", "
\n", "

3Dmol.js failed to load for some reason. Please check your browser console for error messages.

\n", "
\n", "\n", "
\n", "
\n", "
objective change -5.804 score units; non-constraint 20.738; constraint 0.884; main-chain raw/aligned 0.096/0.081 Å; convergence not assessed
\n", "
\n", "

3Dmol.js failed to load for some reason. Please check your browser console for error messages.

\n", "
\n", "\n", "
\n", "
\n", "
\n", "\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "variants = {\n", " \"Cartesian, unconstrained\": cart_unconstrained,\n", " \"Cartesian, constrained\": cart_constrained,\n", " \"Kinematic, unconstrained\": kin_unconstrained,\n", " \"Kinematic, constrained\": kin_constrained,\n", "}\n", "mainchain_mask, _ = declared_mainchain_atom_mask(start)\n", "start_components = score_components(start, score_function)\n", "rows = [\n", " {\n", " \"variant\": \"start\",\n", " **start_components,\n", " \"non_constraint_score_change_units\": 0.0,\n", " \"constraint_score_change_units\": 0.0,\n", " \"objective_change_units\": 0.0,\n", " \"all_atom_raw_RMS_displacement_A\": 0.0,\n", " \"all_atom_Kabsch_RMSD_A\": 0.0,\n", " \"mainchain_raw_RMS_displacement_A\": 0.0,\n", " \"mainchain_Kabsch_RMSD_A\": 0.0,\n", " \"finite_smoke_test_output\": True,\n", " \"convergence_status\": \"not assessed\",\n", " }\n", "]\n", "for name, pose_stack in variants.items():\n", " components = score_components(pose_stack, score_function)\n", " all_atom_raw = rms_displacement(start, pose_stack)\n", " all_atom_aligned = kabsch_aligned_rmsd(start, pose_stack)\n", " mainchain_raw = rms_displacement(start, pose_stack, mainchain_mask)\n", " mainchain_aligned = kabsch_aligned_rmsd(start, pose_stack, mainchain_mask)\n", " numeric_outputs = (\n", " *components.values(),\n", " all_atom_raw,\n", " all_atom_aligned,\n", " mainchain_raw,\n", " mainchain_aligned,\n", " )\n", " rows.append(\n", " {\n", " \"variant\": name,\n", " **components,\n", " \"non_constraint_score_change_units\": (\n", " components[\"non_constraint_score_units\"]\n", " - start_components[\"non_constraint_score_units\"]\n", " ),\n", " \"constraint_score_change_units\": (\n", " components[\"constraint_score_units\"]\n", " - start_components[\"constraint_score_units\"]\n", " ),\n", " \"objective_change_units\": (\n", " components[\"reported_total_score_units\"]\n", " - start_components[\"reported_total_score_units\"]\n", " ),\n", " \"all_atom_raw_RMS_displacement_A\": all_atom_raw,\n", " \"all_atom_Kabsch_RMSD_A\": all_atom_aligned,\n", " \"mainchain_raw_RMS_displacement_A\": mainchain_raw,\n", " \"mainchain_Kabsch_RMSD_A\": mainchain_aligned,\n", " \"finite_smoke_test_output\": bool(np.isfinite(numeric_outputs).all()),\n", " \"convergence_status\": \"not assessed (10-iteration smoke test)\",\n", " }\n", " )\n", "comparison_frame = pd.DataFrame(rows)\n", "show_table(comparison_frame)\n", "\n", "fig, axes = plt.subplots(2, 3, figsize=(18, 8))\n", "axes = axes.ravel()\n", "axes[0].barh(\n", " comparison_frame[\"variant\"], comparison_frame[\"non_constraint_score_units\"]\n", ")\n", "axes[0].set(xlabel=\"weighted score units\", title=\"Non-constraint score\")\n", "axes[1].barh(\n", " comparison_frame[\"variant\"], comparison_frame[\"constraint_score_units\"]\n", ")\n", "axes[1].set(xlabel=\"weighted score units\", title=\"Constraint penalty\")\n", "axes[2].barh(\n", " comparison_frame[\"variant\"],\n", " comparison_frame[\"all_atom_raw_RMS_displacement_A\"],\n", ")\n", "axes[2].set(xlabel=\"raw RMS displacement (Å)\", title=\"All atoms: input frame\")\n", "axes[3].barh(\n", " comparison_frame[\"variant\"], comparison_frame[\"all_atom_Kabsch_RMSD_A\"]\n", ")\n", "axes[3].set(xlabel=\"Kabsch RMSD (Å)\", title=\"All atoms: aligned\")\n", "axes[4].barh(\n", " comparison_frame[\"variant\"],\n", " comparison_frame[\"mainchain_raw_RMS_displacement_A\"],\n", ")\n", "axes[4].set(xlabel=\"raw RMS displacement (Å)\", title=\"Main chain: input frame\")\n", "axes[5].barh(\n", " comparison_frame[\"variant\"], comparison_frame[\"mainchain_Kabsch_RMSD_A\"]\n", ")\n", "axes[5].set(xlabel=\"Kabsch RMSD (Å)\", title=\"Main chain: aligned\")\n", "plt.tight_layout()\n", "plt.show()\n", "\n", "try:\n", " restraint_viewer = tmol.view(\n", " start,\n", " highlighted=mainchain_mask[start.real_atoms],\n", " highlight_color=\"#7b2cbf\",\n", " )\n", " restraint_viewer.show()\n", "except ImportError:\n", " print(\"Install py3Dmol to inspect the restrained main-chain atoms.\")\n", "\n", "viewer_structures = {\"before\": start, **variants}\n", "viewer_notes = {\"before\": \"Starting 1UBQ slice\"}\n", "for row in rows[1:]:\n", " viewer_notes[row[\"variant\"]] = (\n", " f\"objective change {row['objective_change_units']:+.3f} score units; \"\n", " f\"non-constraint {row['non_constraint_score_units']:.3f}; \"\n", " f\"constraint {row['constraint_score_units']:.3f}; \"\n", " f\"main-chain raw/aligned \"\n", " f\"{row['mainchain_raw_RMS_displacement_A']:.3f}/\"\n", " f\"{row['mainchain_Kabsch_RMSD_A']:.3f} Å; convergence not assessed\"\n", " )\n", "display(tmol.switchable_view(viewer_structures, notes=viewer_notes))" ] }, { "cell_type": "markdown", "id": "minimization-observations", "metadata": {}, "source": [ "**Expected observations.** Every minimized structure should have finite weighted scores, score/objective changes, raw displacements, and aligned RMSDs. Finite output—or even a lower objective—after `max_iter=10` is only a smoke-test result and must not be described as convergence. Establish convergence separately with a suitable iteration budget, stopping diagnostics, and repeatability checks. All-atom metrics include side-chain motion produced by minimization; no packing occurs in this notebook. Main-chain metrics use exactly the restrained TMol-declared N/CA/C atoms, highlighted in purple; O is excluded.\n", "\n", "Raw RMS displacement compares coordinates in the original laboratory frame. Kabsch RMSD first removes the best global translation and rotation. A large raw-versus-aligned gap in the unconstrained Cartesian result is evidence of rigid-body drift along its null modes, not the same thing as internal deformation. The kinematic root jump is fixed, so that branch has no equivalent whole-chain drift. Coordinate restraints should generally reduce main-chain motion relative to the matching unconstrained run. Those within-parameterization pairs are controlled comparisons; Cartesian and kinematic endpoints need not agree because their active degrees of freedom differ. The score columns are weighted TMol score units, not physical kcal/mol.\n" ] }, { "cell_type": "markdown", "id": "rescue-intro", "metadata": {}, "source": [ "## Restraint-guided rescue of a displaced local segment\n", "\n", "The preceding comparison starts from a deposited structure. This controlled rescue experiment creates an explicit defect: all atoms in zero-based blocks 3–4 are translated by the same vector while blocks 2–6 define the movable local shell. Three short Cartesian runs then start from exactly that perturbed structure:\n", "\n", "- no restraints;\n", "- reference main-chain coordinate restraints copied from the unperturbed pose; or\n", "- one reference Cα–Cα distance restraint linking fixed-side block 1 to displaced block 4.\n", "\n", "The experiment asks how restraint information trades against the non-constraint score and recovery toward the known reference. It is a method diagnostic, not loop modeling or structure prediction.\n" ] }, { "cell_type": "code", "execution_count": 6, "id": "rescue-code", "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", "\n", " \n", " \n", " \n", " \n", " \n", "\n", "
\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "\n", "\n", "\n", "\n", "
statenon_constraint_score_unitsconstraint_score_unitsreported_total_score_unitslocal_mainchain_RMSD_from_reference_Areference_distance_error_Amovable_atomsoptimizer_budget
perturbed input104.7932820.000000104.7932820.6811750.24116791input only
unconstrained rescue30.0002330.00000030.0002330.5651850.3213639115-iteration smoke test; convergence not assessed
reference coordinate rescue33.3321156.52032939.8524440.3296550.2023449115-iteration smoke test; convergence not assessed
reference distance rescue30.0328770.33263230.3655090.5601340.2883719115-iteration smoke test; convergence not assessed
\n", "\n", "\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "\n", "
\n", " \n", "
\n", " \n", "
\n", "
Unperturbed eight-residue reference
\n", "
\n", "

3Dmol.js failed to load for some reason. Please check your browser console for error messages.

\n", "
\n", "\n", "
\n", "
\n", "
local main-chain RMSD 0.681 Å; distance error 0.241 Å; non-constraint score 104.79
\n", "
\n", "

3Dmol.js failed to load for some reason. Please check your browser console for error messages.

\n", "
\n", "\n", "
\n", "
\n", "
local main-chain RMSD 0.565 Å; distance error 0.321 Å; non-constraint score 30.00
\n", "
\n", "

3Dmol.js failed to load for some reason. Please check your browser console for error messages.

\n", "
\n", "\n", "
\n", "
\n", "
local main-chain RMSD 0.330 Å; distance error 0.202 Å; non-constraint score 33.33
\n", "
\n", "

3Dmol.js failed to load for some reason. Please check your browser console for error messages.

\n", "
\n", "\n", "
\n", "
\n", "
local main-chain RMSD 0.560 Å; distance error 0.288 Å; non-constraint score 30.03
\n", "
\n", "

3Dmol.js failed to load for some reason. Please check your browser console for error messages.

\n", "
\n", "\n", "
\n", "
\n", "
\n", "\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "local_blocks = torch.zeros_like(start.block_type_ind, dtype=torch.bool)\n", "local_blocks[:, 2:7] = True\n", "displaced_blocks = torch.zeros_like(local_blocks)\n", "displaced_blocks[:, 3:5] = True\n", "local_coord_mask = res_mask_to_coord_mask(start, local_blocks) & start.real_atoms\n", "displaced_coord_mask = (\n", " res_mask_to_coord_mask(start, displaced_blocks) & start.real_atoms\n", ")\n", "local_mainchain_mask = mainchain_mask & local_coord_mask\n", "\n", "perturbed = start.clone()\n", "displacement = torch.tensor(\n", " [0.8, -0.6, 0.4], device=device, dtype=perturbed.coords.dtype\n", ")\n", "perturbed.coords[displaced_coord_mask] += displacement\n", "\n", "# The coordinate-constraint targets were created from the unperturbed start.\n", "coordinate_rescue_start = attrs.evolve(\n", " perturbed.clone(), constraint_set=constrained_start.constraint_set\n", ")\n", "\n", "anchor_block, rescued_block = 1, 4\n", "anchor_ca = start.block_type(0, anchor_block).atom_to_idx[\"CA\"]\n", "rescued_ca = start.block_type(0, rescued_block).atom_to_idx[\"CA\"]\n", "anchor_coord = int(start.block_coord_offset64[0, anchor_block]) + anchor_ca\n", "rescued_coord = int(start.block_coord_offset64[0, rescued_block]) + rescued_ca\n", "rescue_target_distance = torch.linalg.vector_norm(\n", " start.coords[0, anchor_coord] - start.coords[0, rescued_coord]\n", ")\n", "rescue_atoms = torch.tensor(\n", " [[[0, anchor_block, anchor_ca], [0, rescued_block, rescued_ca]]],\n", " dtype=torch.int32,\n", " device=device,\n", ")\n", "rescue_params = torch.zeros((1, 4), dtype=torch.float32, device=device)\n", "rescue_params[0, 0] = rescue_target_distance\n", "rescue_params[0, 1] = 0.5\n", "rescue_distance_set = ConstraintSet.create_empty(device, 1).add_constraints(\n", " ConstraintEnergyTerm.harmonic,\n", " rescue_atoms,\n", " rescue_params,\n", ")\n", "distance_rescue_start = attrs.evolve(\n", " perturbed.clone(), constraint_set=rescue_distance_set\n", ")\n", "\n", "rescue_budget = {\"max_iter\": 15}\n", "rescue_variants = {\n", " \"perturbed input\": perturbed,\n", " \"unconstrained rescue\": run_cart_min(\n", " perturbed.clone(),\n", " score_function,\n", " coord_mask=local_coord_mask,\n", " optimizer_kwargs=rescue_budget,\n", " ),\n", " \"reference coordinate rescue\": run_cart_min(\n", " coordinate_rescue_start,\n", " score_function,\n", " coord_mask=local_coord_mask,\n", " optimizer_kwargs=rescue_budget,\n", " ),\n", " \"reference distance rescue\": run_cart_min(\n", " distance_rescue_start,\n", " score_function,\n", " coord_mask=local_coord_mask,\n", " optimizer_kwargs=rescue_budget,\n", " ),\n", "}\n", "\n", "rescue_rows = []\n", "for label, pose_stack in rescue_variants.items():\n", " components = score_components(pose_stack, score_function)\n", " observed_distance = torch.linalg.vector_norm(\n", " pose_stack.coords[0, anchor_coord] - pose_stack.coords[0, rescued_coord]\n", " )\n", " rescue_rows.append(\n", " {\n", " \"state\": label,\n", " **components,\n", " \"local_mainchain_RMSD_from_reference_A\": rms_displacement(\n", " start, pose_stack, local_mainchain_mask\n", " ),\n", " \"reference_distance_error_A\": abs(\n", " float(observed_distance.detach().cpu())\n", " - float(rescue_target_distance.detach().cpu())\n", " ),\n", " \"movable_atoms\": int(local_coord_mask.sum().item()),\n", " \"optimizer_budget\": (\n", " \"input only\"\n", " if label == \"perturbed input\"\n", " else \"15-iteration smoke test; convergence not assessed\"\n", " ),\n", " }\n", " )\n", "rescue_frame = pd.DataFrame(rescue_rows)\n", "show_table(rescue_frame)\n", "\n", "fig, axis = plt.subplots(figsize=(7, 4.5))\n", "axis.scatter(\n", " rescue_frame[\"local_mainchain_RMSD_from_reference_A\"],\n", " rescue_frame[\"non_constraint_score_units\"],\n", " s=70,\n", ")\n", "for row in rescue_frame.itertuples():\n", " axis.annotate(\n", " row.state,\n", " (\n", " row.local_mainchain_RMSD_from_reference_A,\n", " row.non_constraint_score_units,\n", " ),\n", " xytext=(5, 5),\n", " textcoords=\"offset points\",\n", " fontsize=8,\n", " )\n", "axis.set(\n", " xlabel=\"local main-chain RMSD from reference (Å)\",\n", " ylabel=\"weighted non-constraint score\",\n", " title=\"Score improvement and structural recovery are distinct\",\n", ")\n", "axis.grid(alpha=0.3)\n", "plt.tight_layout()\n", "plt.show()\n", "\n", "display(\n", " tmol.switchable_view(\n", " {\"reference\": start, **rescue_variants},\n", " notes={\n", " \"reference\": \"Unperturbed eight-residue reference\",\n", " **{\n", " row.state: (\n", " f\"local main-chain RMSD \"\n", " f\"{row.local_mainchain_RMSD_from_reference_A:.3f} Å; \"\n", " f\"distance error {row.reference_distance_error_A:.3f} Å; \"\n", " f\"non-constraint score {row.non_constraint_score_units:.2f}\"\n", " )\n", " for row in rescue_frame.itertuples()\n", " },\n", " },\n", " )\n", ")" ] }, { "cell_type": "markdown", "id": "rescue-observations", "metadata": {}, "source": [ "**Expected observations.** All three minimized states should reduce the severe score penalty created by the displacement, but their structural recovery need not track score improvement exactly. Reference coordinate restraints should generally pull the moved main chain closer to the known starting geometry. One scalar distance restraint supplies much less information and cannot uniquely determine a local conformation. Finite output after 15 iterations is smoke-test evidence only; convergence and recovery quality must be assessed separately.\n" ] }, { "cell_type": "markdown", "id": "e3e673b7", "metadata": {}, "source": [ "## Rosetta comparison\n", "\n", "Rosetta's `MinMover` and Cartesian minimization use a `MoveMap` to select internal or Cartesian degrees of freedom. TMol separates these concepts into `MoveMap` for named torsion/jump DOFs and `CartesianMoveMap` for per-atom coordinate masks that apply across a `PoseStack`. Rosetta Cartesian workflows commonly choose a Cartesian-ready score function; TMol beta2016 already weights its five `cart_*` bonded terms.\n", "\n", "Rosetta `FoldTree` can root on a physical residue and combines chemical and jump connectivity in one tree. TMol `FoldForest` is batched, always uses a virtual root, and its automatic builder follows polymer connectivity but not disulfides; use validated custom edges when needed.\n", "\n", "Rosetta supports text constraint files and ambiguous or multi constraints. TMol instead assembles supported harmonic distance/coordinate, bounded-distance, and circular-harmonic torsion constraints through `ConstraintSet` and `ConstraintEnergyTerm`; it has no Rosetta constraint-file parser, ambiguous-constraint layer, or dedicated three-atom angle constraint. Circular-harmonic torsion differences are compared periodically across the −π/+π boundary.\n", "\n", "For executable PyRosetta context, compare [05.01 — High-Resolution Movers](https://nbviewer.org/github/RosettaCommons/PyRosetta.notebooks/blob/master/notebooks/05.01-High-Res-Movers.ipynb) and [05.02 — Refinement Protocol](https://nbviewer.org/github/RosettaCommons/PyRosetta.notebooks/blob/master/notebooks/05.02-Refinement-Protocol.ipynb). The APIs and numerical defaults are not interchangeable; reproduce a protocol only after matching its score function, active degrees of freedom, restraints, and optimizer settings.\n", "\n", "The [Rosetta-to-TMol crosswalk](rosetta_crosswalk.md) summarizes these API and protocol boundaries.\n", "\n", "## Next: compose packing and minimization\n", "\n", "After completing the parallel packing/design branch in [Tutorial 04](04_packing_and_mutation_scan.ipynb), continue to [06 — FastRelax](06_fast_relax.ipynb), which alternates packing with the Cartesian or kinematic minimization interfaces used here." ] }, { "cell_type": "markdown", "id": "339b5ce0", "metadata": {}, "source": [ "## Exercises\n", "\n", "1. Change the Cartesian coordinate mask so only residues 3–5 move, then compare the displacement table.\n", "2. Disable side-chain torsions in the kinematic `MoveMap` and enable only main-chain torsions for selected blocks.\n", "3. Replace the one Cα–Cα harmonic restraint with a tested `ConstraintEnergyTerm.bounded` distance constraint and verify its two-pose replication.\n", "4. Build a two-chain slice and compare its automatic forest with an explicit `FoldForest.from_edges()` definition.\n", "5. Apply `create_mainchain_coordinate_constraints()` to a mixed protein–nucleic-acid pose and inspect the atoms selected from each residue type's declared main chain." ] }, { "cell_type": "markdown", "id": "86c27616", "metadata": {}, "source": [ "## References\n", "\n", "- [Rosetta-to-TMol crosswalk](rosetta_crosswalk.md)\n", "- [Rosetta minimization tutorial](https://docs.rosettacommons.org/demos/latest/tutorials/minimization/minimization)\n", "- [Rosetta constraints tutorial](https://docs.rosettacommons.org/demos/latest/tutorials/Constraints_Tutorial/Constraints)\n", "- [Rosetta FoldTree tutorial](https://docs.rosettacommons.org/demos/latest/tutorials/fold_tree/fold_tree)\n", "- [PyRosetta 05.01 — High-Resolution Movers](https://nbviewer.org/github/RosettaCommons/PyRosetta.notebooks/blob/master/notebooks/05.01-High-Res-Movers.ipynb)\n", "- [PyRosetta 05.02 — Refinement Protocol](https://nbviewer.org/github/RosettaCommons/PyRosetta.notebooks/blob/master/notebooks/05.02-Refinement-Protocol.ipynb)\n", "- [Rosetta `FoldTree.hh`](https://github.com/RosettaCommons/rosetta/blob/main/source/src/core/kinematics/FoldTree.hh)\n", "- [Rosetta `ConstraintSet.cc`](https://github.com/RosettaCommons/rosetta/blob/main/source/src/core/scoring/constraints/ConstraintSet.cc)" ] } ], "metadata": { "accelerator": "GPU", "colab": { "gpuType": "T4" }, "language_info": { "name": "python" } }, "nbformat": 4, "nbformat_minor": 5 }