{ "cells": [ { "cell_type": "markdown", "id": "a380fea3", "metadata": {}, "source": [ "# Tutorial 04 — Packing and a Small Mutation Scan\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/04_packing_and_mutation_scan.ipynb)\n", "\n", "This tutorial repacks side chains in a small ubiquitin structure, inspects rotamer candidates, and composes example mutation-scan and design workflows.\n", "\n", "## Learning objectives\n", "\n", "- Build a repacking task and choose movable blocks.\n", "- Run the packer and inspect sequence and coordinates.\n", "- Distinguish repacking from design and examine sampling variability.\n", "\n", "## Before you begin\n", "\n", "- **Prerequisites:** [03 — Scoring and analysis](03_scoring_and_analysis.ipynb), including weighted scores and block-pair accounting.\n", "- **Curriculum:** This is the discrete-sampling branch after 03. Complete the parallel [05 — Minimization](05_minimization_constraints_kinematics.ipynb) branch before [06 — FastRelax](06_fast_relax.ipynb) combines both.\n", "- **Related:** [Packing workflow](../workflows/packing.md) · [Packing API](../api/pack.rst)\n", "\n", "Repacking preserves residue identity; design allows selected identities to change. The mutation scan is an example built from lower-level APIs, not a built-in TMol protocol. CPU and GPU packers can select different outcomes." ] }, { "cell_type": "markdown", "id": "1ae117e1", "metadata": {}, "source": [ "## Setup\n", "\n", "The setup uses the sampler construction exercised by TMol's packer tests and existing score/pack/minimize tutorial. The ten-residue slice keeps CPU execution and two-outcome comparisons practical. NumPy and PyTorch seeds are initialized, but the current CPU annealer uses the C `rand()` stream and is not controlled by `torch.manual_seed()`. Hydrogen coordinates are optimized during pose construction before scores are interpreted." ] }, { "cell_type": "code", "execution_count": 1, "id": "ec0a2e18", "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": "74d07645", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "device=cpu; input=1UBQ.cif; slice blocks=10\n" ] } ], "source": [ "from contextlib import redirect_stderr, redirect_stdout\n", "from io import StringIO\n", "from pathlib import Path\n", "from time import perf_counter\n", "import warnings\n", "\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.database import ParameterDatabase\n", "from tmol.io import pose_stack_from_biotite\n", "from tmol.numeric import coord_dihedrals\n", "from tmol.ops import (\n", " build_sidechain_coord_mask,\n", " compute_block_adjacency,\n", " compute_block_centroids_and_furthest_dist,\n", " res_mask_to_coord_mask,\n", ")\n", "from tmol.pack import PackerPalette, PackerTask, SetPackerTask, pack_rotamers\n", "from tmol.pack.rotamer import FixedAAChiSampler, IncludeCurrentSampler, build_rotamers\n", "from tmol.pack.rotamer.dunbrack import create_dunbrack_sampler_from_database\n", "from tmol.pose import PoseStackBuilder\n", "from tmol.score import beta2016_score_function\n", "\n", "SEED = 20260807\n", "np.random.seed(SEED)\n", "torch.manual_seed(SEED)\n", "if torch.cuda.is_available():\n", " torch.cuda.manual_seed_all(SEED)\n", "warnings.filterwarnings(\n", " \"ignore\", message=r\"Sparse invariant checks are implicitly disabled.*\"\n", ")\n", "\n", "device = (\n", " torch.device(\"cuda\", torch.cuda.current_device())\n", " if torch.cuda.is_available()\n", " else torch.device(\"cpu\")\n", ")\n", "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", "\n", "param_db = ParameterDatabase.get_default()\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 <= 10)]\n", "pose_diagnostics = StringIO()\n", "try:\n", " with redirect_stdout(pose_diagnostics), redirect_stderr(pose_diagnostics):\n", " # Optimize hydrogen coordinates before comparing interpreted scores.\n", " pose_stack = pose_stack_from_biotite(\n", " protein_slice, device, param_db=param_db, no_optH=False\n", " )\n", "except Exception:\n", " print(pose_diagnostics.getvalue())\n", " raise\n", "score_function = beta2016_score_function(device, param_db=param_db)\n", "\n", "\n", "def show_table(frame):\n", " try:\n", " from itables import show\n", " except ImportError:\n", " display(frame)\n", " return None\n", " return show(frame)\n", "\n", "\n", "def total_score(pose):\n", " scorer = score_function.render_whole_pose_scoring_module(pose)\n", " return float(scorer(pose.coords).detach().cpu()[0])\n", "\n", "print(f\"device={device}; input={cif_path.name}; slice blocks={pose_stack.max_n_blocks}\")" ] }, { "cell_type": "markdown", "id": "de1446e5", "metadata": {}, "source": [ "## Fixed-sequence regional repacking\n", "\n", "`PackerPalette` defines the residue-type space considered from each starting block. `PackerTask.restrict_to_repacking()` keeps each position's `name3` fixed. The task then uses Dunbrack rotamers, fixed-amino-acid chi samples, and the current conformation.\n", "\n", "Here residues 3–8 (zero-based block indices 2–7) are allowed to repack. `disable_packing_by_block_mask()` receives `True` where packing should be disabled." ] }, { "cell_type": "code", "execution_count": 3, "id": "604bcc80", "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", "\n", " \n", " \n", " \n", " \n", " \n", "\n", "
\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "\n", "\n", "
stagebeta2016score_changepacked_sidechain_RMS_displacement_Amax_sidechain_displacement_Achanged_sidechain_atoms
input27.6962030.0000000.0000000.0000000
regional repack19.816195-7.8800090.4918511.48222974
\n", "\n", "\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "palette = PackerPalette()\n", "repack_task = PackerTask(pose_stack, palette)\n", "repack_task.restrict_to_repacking()\n", "\n", "packing_region = torch.zeros(\n", " (pose_stack.n_poses, pose_stack.max_n_blocks),\n", " dtype=torch.bool,\n", " device=device,\n", ")\n", "packing_region[:, 2:8] = True\n", "repack_task.disable_packing_by_block_mask(~packing_region)\n", "repack_task.add_conformer_sampler(\n", " create_dunbrack_sampler_from_database(param_db, device)\n", ")\n", "repack_task.add_conformer_sampler(FixedAAChiSampler())\n", "repack_task.add_conformer_sampler(IncludeCurrentSampler())\n", "\n", "start_score = total_score(pose_stack)\n", "torch.manual_seed(SEED)\n", "repacked_pose = pack_rotamers(pose_stack, score_function, repack_task)\n", "repacked_score = total_score(repacked_pose)\n", "\n", "packing_atom_mask = res_mask_to_coord_mask(pose_stack, packing_region)\n", "packing_sidechain_mask = packing_atom_mask & build_sidechain_coord_mask(pose_stack)\n", "sidechain_displacement = torch.linalg.vector_norm(\n", " repacked_pose.coords - pose_stack.coords, dim=-1\n", ")[packing_sidechain_mask]\n", "sidechain_rms_displacement = float(\n", " torch.sqrt(torch.mean(sidechain_displacement.square())).detach().cpu()\n", ")\n", "max_sidechain_displacement = float(sidechain_displacement.max().detach().cpu())\n", "changed_sidechain_atoms = int((sidechain_displacement > 1e-3).sum().detach().cpu())\n", "\n", "repack_frame = pd.DataFrame(\n", " [\n", " {\n", " \"stage\": \"input\",\n", " \"beta2016\": start_score,\n", " \"score_change\": 0.0,\n", " \"packed_sidechain_RMS_displacement_A\": 0.0,\n", " \"max_sidechain_displacement_A\": 0.0,\n", " \"changed_sidechain_atoms\": 0,\n", " },\n", " {\n", " \"stage\": \"regional repack\",\n", " \"beta2016\": repacked_score,\n", " \"score_change\": repacked_score - start_score,\n", " \"packed_sidechain_RMS_displacement_A\": sidechain_rms_displacement,\n", " \"max_sidechain_displacement_A\": max_sidechain_displacement,\n", " \"changed_sidechain_atoms\": changed_sidechain_atoms,\n", " },\n", " ]\n", ")\n", "show_table(repack_frame)" ] }, { "cell_type": "markdown", "id": "245cfa6b", "metadata": {}, "source": [ "**Expected observations.** The amino-acid sequence is unchanged, only blocks 3–8 are allowed to choose side-chain conformers, and the score may decrease when the input side chains are suboptimal. The interactive table quantifies score change, RMS and maximum displacement over packed side-chain atoms, and how many moved more than 0.001 Å. Backbone movement should remain zero because the packer chooses discrete side-chain conformers rather than minimizing coordinates.\n", "\n", "**CPU and GPU annealers are different algorithms.** The current CPU implementation runs one trajectory with 20 outer cycles, using `5 × N_rotamers` uniformly sampled random trials per cycle (about five trials per rotamer on average) and a final quench. It draws from C `rand()`, so `torch.manual_seed()` does not control CPU packing. The current CUDA implementation starts 500 high-temperature trajectories, expands selected results into 1,250 low-temperature trajectories, and sends 312 onward to full quenching; it draws from PyTorch's CUDA Philox generator, so the PyTorch CUDA seed controls that random stream. Packing remains stochastic, and CPU and GPU results should be treated as separate search protocols rather than expected to reproduce one another.\n", "\n", "The viewer is interactive when the parent documentation environment provides `py3Dmol`." ] }, { "cell_type": "code", "execution_count": 4, "id": "9c7b1392", "metadata": { "tags": [ "collapse-code" ] }, "outputs": [ { "data": { "text/html": [ "\n", "
\n", " \n", "
\n", " \n", "
\n", "
weighted score: 27.696
\n", "
\n", "

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

\n", "
\n", "\n", "
\n", "
\n", "
score 19.816; Δ -7.880; side-chain RMS motion 0.492 Å
\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": [ "try:\n", " display(\n", " tmol.switchable_view(\n", " {\"input\": pose_stack, \"regional repack\": repacked_pose},\n", " notes={\n", " \"input\": f\"weighted score: {start_score:.3f}\",\n", " \"regional repack\": (\n", " f\"score {repacked_score:.3f}; Δ {repacked_score - start_score:+.3f}; \"\n", " f\"side-chain RMS motion {sidechain_rms_displacement:.3f} Å\"\n", " ),\n", " },\n", " width=720,\n", " height=420,\n", " )\n", " )\n", "except ImportError as exc:\n", " print(\"Interactive repacking comparison unavailable:\", exc)" ] }, { "cell_type": "markdown", "id": "a00be31a", "metadata": {}, "source": [ "## Expand side-chain sampling\n", "\n", "TMol's `PackerTask.or_expand_chi()` requests additional samples at approximately ±1 standard deviation around supported chi wells. TMol chi indices are zero-based: index `0` is χ1 and index `1` is χ2. This is the closest local sampling concept to Rosetta's `ex1` and `ex2` task options, but it does not imply protocol or candidate-set equivalence.\n", "\n", "Two separate questions are kept separate below. Building rotamers gives deterministic candidate counts and geometry for a fixed pose/task. Packing those candidates gives stochastic score outcomes. Extra sampling enlarges the search but does not guarantee a lower selected score. The CUDA path shows two seeded outcomes per setting; the CPU path shows one outcome because `torch.manual_seed()` does not seed its C RNG. Neither is a convergence study. `IncludeCurrentSampler` keeps the input conformation available." ] }, { "cell_type": "code", "execution_count": 5, "id": "dc8e6aba", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "CPU packing shown once per setting: torch seeds do not control C rand().\n" ] }, { "data": { "text/html": [ "\n", "\n", " \n", " \n", " \n", " \n", " \n", "\n", "
\n", " \n", " \n", " \n", " \n", "\n", "\n", "
samplingoutcomeweighted_score_units
standard119.816195
expanded χ1 + χ2119.586668
\n", "\n", "\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "\n", "\n", " \n", " \n", " \n", " \n", " \n", "\n", "
\n", " \n", " \n", " \n", " \n", " \n", " \n", "\n", "\n", "
samplingscore_meanscore_minscore_maxobserved_range
expanded χ1 + χ219.58666819.58666819.5866680.0
standard19.81619519.81619519.8161950.0
\n", "\n", "\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "\n", "
\n", " \n", "
\n", " \n", "
\n", "
outcome 1 weighted score 19.816
\n", "
\n", "

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

\n", "
\n", "\n", "
\n", "
\n", "
outcome 1 weighted score 19.587
\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": [ "expanded_task = PackerTask(pose_stack, palette)\n", "expanded_task.restrict_to_repacking()\n", "expanded_task.disable_packing_by_block_mask(~packing_region)\n", "expanded_task.add_conformer_sampler(\n", " create_dunbrack_sampler_from_database(param_db, device)\n", ")\n", "expanded_task.add_conformer_sampler(FixedAAChiSampler())\n", "expanded_task.add_conformer_sampler(IncludeCurrentSampler())\n", "# Zero-based chi indices 0 and 1 map conceptually to Rosetta ex1 and ex2.\n", "expanded_task.or_expand_chi(0)\n", "expanded_task.or_expand_chi(1)\n", "\n", "torch.manual_seed(SEED)\n", "expanded_repacked_pose = pack_rotamers(\n", " pose_stack, score_function, expanded_task\n", ")\n", "expanded_score = total_score(expanded_repacked_pose)\n", "\n", "# Keep this deliberately small. CUDA gets a second seeded outcome because\n", "# torch.manual_seed() controls its Philox stream; the CPU C RNG has no exposed\n", "# seed API, so repeating under a different torch seed would not be a controlled\n", "# replicate.\n", "sampling_outcome_rows = [\n", " {\n", " \"sampling\": \"standard\",\n", " \"outcome\": 1,\n", " \"weighted_score_units\": repacked_score,\n", " },\n", " {\n", " \"sampling\": \"expanded χ1 + χ2\",\n", " \"outcome\": 1,\n", " \"weighted_score_units\": expanded_score,\n", " },\n", "]\n", "if device.type == \"cuda\":\n", " torch.manual_seed(SEED + 1)\n", " standard_repeat_pose = pack_rotamers(pose_stack, score_function, repack_task)\n", " torch.manual_seed(SEED + 1001)\n", " expanded_repeat_pose = pack_rotamers(pose_stack, score_function, expanded_task)\n", " sampling_outcome_rows.extend(\n", " [\n", " {\n", " \"sampling\": \"standard\",\n", " \"outcome\": 2,\n", " \"weighted_score_units\": total_score(standard_repeat_pose),\n", " },\n", " {\n", " \"sampling\": \"expanded χ1 + χ2\",\n", " \"outcome\": 2,\n", " \"weighted_score_units\": total_score(expanded_repeat_pose),\n", " },\n", " ]\n", " )\n", "else:\n", " print(\"CPU packing shown once per setting: torch seeds do not control C rand().\")\n", "sampling_outcome_frame = pd.DataFrame(sampling_outcome_rows)\n", "show_table(sampling_outcome_frame)\n", "sampling_outcome_summary = (\n", " sampling_outcome_frame.groupby(\"sampling\", as_index=False)\n", " .agg(\n", " score_mean=(\"weighted_score_units\", \"mean\"),\n", " score_min=(\"weighted_score_units\", \"min\"),\n", " score_max=(\"weighted_score_units\", \"max\"),\n", " )\n", ")\n", "sampling_outcome_summary[\"observed_range\"] = (\n", " sampling_outcome_summary[\"score_max\"]\n", " - sampling_outcome_summary[\"score_min\"]\n", ")\n", "show_table(sampling_outcome_summary)\n", "try:\n", " display(\n", " tmol.switchable_view(\n", " {\n", " \"standard rotamers\": repacked_pose,\n", " \"expanded χ1 + χ2\": expanded_repacked_pose,\n", " },\n", " notes={\n", " \"standard rotamers\": f\"outcome 1 weighted score {repacked_score:.3f}\",\n", " \"expanded χ1 + χ2\": f\"outcome 1 weighted score {expanded_score:.3f}\",\n", " },\n", " )\n", " )\n", "except ImportError as exc:\n", " print(\"Interactive sampling comparison unavailable:\", exc)" ] }, { "cell_type": "markdown", "id": "bec70da7", "metadata": {}, "source": [ "## Inspect deterministic candidate expansion\n", "\n", "Expanded chi sampling changes the discrete search space before annealing. The table below builds both rotamer sets explicitly and reports deterministic candidate counts at each packed position. A wrapped χ1-versus-χ2 plot then shows candidate geometry for one representative block without treating internal rotamer storage order as a physical coordinate.\n", "\n", "These torsions describe the candidate set, not a trajectory or score result: simulated annealing evaluates assignments stochastically and returns only the selected final conformation." ] }, { "cell_type": "code", "execution_count": 6, "id": "853aa1d0", "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", "
block_indexresiduestandard_candidatesexpanded_candidatesadditional_candidates
2ILE75548
3PHE1310996
4VAL4106
5LYS41361320
6THR3710972
7LEU75548
\n", "\n", "\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "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", "
samplingrotamerchi1_degreeschi2_degreeschi3_degreeschi4_degrees
standard0-176.578568177.852783179.383820-179.999954
standard1177.91906768.981468176.515213178.500015
standard2-178.95297271.885971178.46687369.606857
standard3-58.962368-64.175163-175.639511-177.933014
standard4-170.350662-82.596588178.521988-177.399994
standard5-177.339264176.993134-176.099976-66.127434
standard6-65.590263-179.024628-179.595016179.460144
standard7-178.528931177.198334175.33511464.900032
standard8-58.109982-64.208847-173.958771-67.000092
standard9-173.606400178.399979-68.899940-68.500114
(392 more rows not shown)
\n", "\n", "\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "standard_rotamer_pose, standard_rotamers = build_rotamers(\n", " pose_stack,\n", " SetPackerTask.from_packer_task(repack_task),\n", " pose_stack.packed_block_types.chem_db,\n", ")\n", "expanded_rotamer_pose, expanded_rotamers = build_rotamers(\n", " pose_stack,\n", " SetPackerTask.from_packer_task(expanded_task),\n", " pose_stack.packed_block_types.chem_db,\n", ")\n", "\n", "rotamer_count_rows = []\n", "for block_index in range(2, 8):\n", " block_type = pose_stack.block_type(0, block_index)\n", " rotamer_count_rows.append(\n", " {\n", " \"block_index\": block_index,\n", " \"residue\": block_type.name3,\n", " \"standard_candidates\": int(\n", " standard_rotamers.n_rots_for_block[0, block_index]\n", " ),\n", " \"expanded_candidates\": int(\n", " expanded_rotamers.n_rots_for_block[0, block_index]\n", " ),\n", " }\n", " )\n", "rotamer_count_frame = pd.DataFrame(rotamer_count_rows)\n", "rotamer_count_frame[\"additional_candidates\"] = (\n", " rotamer_count_frame[\"expanded_candidates\"]\n", " - rotamer_count_frame[\"standard_candidates\"]\n", ")\n", "show_table(rotamer_count_frame)\n", "\n", "\n", "def named_chi_frame(label, rotamer_pose, rotamer_set, block_index):\n", " rows = []\n", " n_rotamers = int(rotamer_set.n_rots_for_block[0, block_index])\n", " rotamer_offset = int(rotamer_set.rot_offset_for_block[0, block_index])\n", " for local_rotamer in range(n_rotamers):\n", " rotamer_index = rotamer_offset + local_rotamer\n", " block_type_index = int(rotamer_set.block_type_ind_for_rot[rotamer_index])\n", " block_type = rotamer_pose.packed_block_types.active_block_types[\n", " block_type_index\n", " ]\n", " coordinate_offset = int(rotamer_set.coord_offset_for_rot[rotamer_index])\n", " row = {\"sampling\": label, \"rotamer\": local_rotamer}\n", " for torsion_index in block_type.sc_torsions:\n", " atom_indices = block_type.ordered_torsions[torsion_index, :, 0]\n", " if np.any(atom_indices < 0):\n", " continue\n", " coordinates = rotamer_set.coords[\n", " coordinate_offset\n", " + torch.as_tensor(atom_indices, dtype=torch.long, device=device)\n", " ].double()\n", " radians = coord_dihedrals(\n", " coordinates[0:1],\n", " coordinates[1:2],\n", " coordinates[2:3],\n", " coordinates[3:4],\n", " )[0]\n", " torsion_name = block_type.torsions[torsion_index].name\n", " row[f\"{torsion_name}_degrees\"] = float(torch.rad2deg(radians).cpu())\n", " rows.append(row)\n", " return pd.DataFrame(rows)\n", "\n", "\n", "# Block 5 is LYS in this 1UBQ slice and therefore demonstrates both chi1 and chi2.\n", "rotamer_inspection_block = 5\n", "rotamer_geometry_frame = pd.concat(\n", " [\n", " named_chi_frame(\n", " \"standard\",\n", " standard_rotamer_pose,\n", " standard_rotamers,\n", " rotamer_inspection_block,\n", " ),\n", " named_chi_frame(\n", " \"expanded\",\n", " expanded_rotamer_pose,\n", " expanded_rotamers,\n", " rotamer_inspection_block,\n", " ),\n", " ],\n", " ignore_index=True,\n", ")\n", "show_table(rotamer_geometry_frame)\n", "\n", "chi1_column = next(\n", " (\n", " column\n", " for column in rotamer_geometry_frame.columns\n", " if column.lower().startswith(\"chi1\") and column.endswith(\"_degrees\")\n", " ),\n", " None,\n", ")\n", "chi2_column = next(\n", " (\n", " column\n", " for column in rotamer_geometry_frame.columns\n", " if column.lower().startswith(\"chi2\") and column.endswith(\"_degrees\")\n", " ),\n", " None,\n", ")\n", "if chi1_column is not None and chi2_column is not None:\n", " wrapped_geometry = rotamer_geometry_frame.copy()\n", " wrapped_geometry[\"chi1_wrapped_degrees\"] = (\n", " (wrapped_geometry[chi1_column] + 180.0) % 360.0 - 180.0\n", " )\n", " wrapped_geometry[\"chi2_wrapped_degrees\"] = (\n", " (wrapped_geometry[chi2_column] + 180.0) % 360.0 - 180.0\n", " )\n", " fig, ax = plt.subplots(figsize=(5.5, 5.0))\n", " for label, values in wrapped_geometry.groupby(\"sampling\"):\n", " ax.scatter(\n", " values[\"chi1_wrapped_degrees\"],\n", " values[\"chi2_wrapped_degrees\"],\n", " label=label,\n", " alpha=0.7,\n", " )\n", " ax.set(\n", " xlim=(-180, 180),\n", " ylim=(-180, 180),\n", " xlabel=\"wrapped χ1 (degrees)\",\n", " ylabel=\"wrapped χ2 (degrees)\",\n", " title=f\"Candidate side-chain geometry at block {rotamer_inspection_block}\",\n", " )\n", " ax.set_aspect(\"equal\", adjustable=\"box\")\n", " ax.grid(alpha=0.3)\n", " ax.legend()\n", " plt.tight_layout()\n", " plt.show()" ] }, { "cell_type": "markdown", "id": "ae1831f7", "metadata": {}, "source": [ "## Deliberately small local-shell mutation scan\n", "\n", "> **Inspected helper, not a built-in protocol.** `PackerTask` currently has no public method that restricts one position to one amino-acid identity. The helper below only turns `per_block_is_block_type_allowed` entries from `True` to `False`, preserving the task's monotonic-mask contract. Its field use was inspected against `tmol/pack/packer_task.py` and packer tests.\n", "\n", "Every non-target position is restricted to its original block type. At the target, only considered block types with the requested `name3` remain. Repacking is additionally restricted to the target plus blocks selected by `compute_block_adjacency()`: centroid distance less than the sum of both furthest-atom radii plus the helper's default 5 Å constant. This adapts the local-neighborhood experimental design used by Rosetta TaskOperations without claiming a `NeighborhoodResidueSelector` API in TMol.\n", "\n", "The scan uses two jointly batched stochastic outcomes per identity. Identity distributions are summarized independently; differences are computed between their means, never by arbitrarily pairing WT and mutant outcomes. Two outcomes are enough to illustrate the analysis but not convergence, and observed spread may be exactly zero—particularly for a small CPU run. The WT row is a **repacked WT**, and every reported difference is a score-function delta, not a ΔΔG." ] }, { "cell_type": "code", "execution_count": 7, "id": "09bed27d", "metadata": {}, "outputs": [], "source": [ "def restrict_batched_substitutions(task, block_index, name3_by_pose):\n", " \"\"\"Keep the original sequence except for one requested identity per pose.\"\"\"\n", " if len(name3_by_pose) != task.per_block_is_block_type_allowed.shape[0]:\n", " raise ValueError(\"Provide exactly one requested identity per pose\")\n", " considered = task.per_block_considered_block_types\n", " keep = task.per_block_considered_block_types_is_orig.detach().clone()\n", " for pose_index, name3 in enumerate(name3_by_pose):\n", " target_considered = (\n", " considered[pose_index, block_index].detach().cpu().tolist()\n", " )\n", " target_keep = torch.tensor(\n", " [\n", " index >= 0 and task.pbt.active_block_types[index].name3 == name3\n", " for index in target_considered\n", " ],\n", " dtype=torch.bool,\n", " device=task.device,\n", " )\n", " if not torch.any(target_keep):\n", " raise ValueError(f\"{name3!r} is not considered at block {block_index}\")\n", " keep[pose_index, block_index] = target_keep\n", " task.per_block_is_block_type_allowed = torch.logical_and(\n", " task.per_block_is_block_type_allowed, keep\n", " )\n", " return task\n", "\n", "\n", "def add_standard_samplers(task):\n", " task.add_conformer_sampler(\n", " create_dunbrack_sampler_from_database(param_db, device)\n", " )\n", " task.add_conformer_sampler(FixedAAChiSampler())\n", " task.add_conformer_sampler(IncludeCurrentSampler())\n", " return task" ] }, { "cell_type": "code", "execution_count": 8, "id": "a43ea8b3", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "mutation target block 4 (A:5); local repacking shell has 7 blocks: A:2, A:3, A:4, A:5, A:6, A:7, A:8\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", "
block_indexpdb_labelvariantstateoutcometotal_weighted_score_unitstarget_to_rest_weighted_score_unitsshared_batch_seconds
14A:5ALAALA120.7992780.8751720.255724
24A:5LEULEU117.877546-1.5708850.255724
34A:5PHEPHE119.630051-0.8738220.255724
04A:5VALVAL (repacked WT)117.260197-2.1610990.255724
\n", "\n", "\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "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", "
variantstatetotal_score_meantotal_score_mintotal_score_maxtarget_to_rest_meantarget_to_rest_mintarget_to_rest_maxtotal_score_rangetarget_to_rest_rangetotal_difference_of_means_vs_repacked_wt_non_ddgtarget_to_rest_difference_of_means_vs_repacked_wt_non_ddg
3VALVAL (repacked WT)17.26019717.26019717.260197-2.161099-2.161099-2.1610990.00.00.0000000.000000
1LEULEU17.87754617.87754617.877546-1.570885-1.570885-1.5708850.00.00.6173500.590215
2PHEPHE19.63005119.63005119.630051-0.873822-0.873822-0.8738220.00.02.3698541.287277
0ALAALA20.79927820.79927820.7992780.8751720.8751720.8751720.00.03.5390823.036271
\n", "\n", "\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "target_block = 4\n", "original_type_index = int(pose_stack.block_type_ind64[0, target_block].item())\n", "original_name3 = pose_stack.packed_block_types.active_block_types[\n", " original_type_index\n", "].name3\n", "variants = list(dict.fromkeys([original_name3, \"ALA\", \"LEU\", \"PHE\"]))\n", "target_label = (\n", " f\"{pose_stack.pdb_info.chain_labels[0, target_block]}:\"\n", " f\"{pose_stack.pdb_info.residue_labels[0, target_block]}\"\n", " f\"{pose_stack.pdb_info.residue_insertion_codes[0, target_block]}\"\n", ")\n", "\n", "# Build one explicit local shell with the existing score_utils geometry helpers.\n", "block_centroids, block_radii = compute_block_centroids_and_furthest_dist(pose_stack)\n", "block_adjacency = compute_block_adjacency(block_centroids, block_radii)\n", "mutation_shell = block_adjacency[:, target_block].clone()\n", "mutation_shell[:, target_block] = True\n", "shell_block_indices = torch.nonzero(mutation_shell[0], as_tuple=False).flatten().tolist()\n", "shell_labels = [\n", " f\"{pose_stack.pdb_info.chain_labels[0, block]}:\"\n", " f\"{pose_stack.pdb_info.residue_labels[0, block]}\"\n", " f\"{pose_stack.pdb_info.residue_insertion_codes[0, block]}\"\n", " for block in shell_block_indices\n", "]\n", "print(\n", " f\"mutation target block {target_block} ({target_label}); local repacking shell \"\n", " f\"has {len(shell_block_indices)} blocks: {', '.join(shell_labels)}\"\n", ")\n", "\n", "\n", "def target_to_rest_score(pose, block_index):\n", " scorer = score_function.render_block_pair_scoring_module(pose)\n", " matrix = scorer(pose.coords, sum_terms=True, apply_weights=True)[0]\n", " partners = torch.ones(matrix.shape[0], dtype=torch.bool, device=matrix.device)\n", " partners[block_index] = False\n", " return float(\n", " (matrix[block_index, partners].sum() + matrix[partners, block_index].sum())\n", " .detach()\n", " .cpu()\n", " )\n", "\n", "\n", "# CUDA uses two seeded outcomes per identity. On CPU, show one batch member\n", "# per identity because torch.manual_seed() does not control the C RNG.\n", "n_scan_outcomes = 2 if device.type == \"cuda\" else 1\n", "scan_requests = [\n", " (outcome, variant)\n", " for outcome in range(1, n_scan_outcomes + 1)\n", " for variant in variants\n", "]\n", "requested_variants = [variant for _, variant in scan_requests]\n", "mutation_batch = PoseStackBuilder.from_poses(\n", " [pose_stack] * len(scan_requests), device\n", ")\n", "mutation_scan_task = PackerTask(mutation_batch, PackerPalette())\n", "restrict_batched_substitutions(\n", " mutation_scan_task, target_block, requested_variants\n", ")\n", "mutation_shell_batch = mutation_shell.expand(len(scan_requests), -1).clone()\n", "mutation_scan_task.disable_packing_by_block_mask(~mutation_shell_batch)\n", "add_standard_samplers(mutation_scan_task)\n", "\n", "torch.manual_seed(SEED) # Controls CUDA annealing, not the CPU C rand() stream.\n", "if device.type == \"cuda\":\n", " torch.cuda.synchronize()\n", "scan_start = perf_counter()\n", "packed_mutation_batch = pack_rotamers(\n", " mutation_batch, score_function, mutation_scan_task\n", ")\n", "if device.type == \"cuda\":\n", " torch.cuda.synchronize()\n", "scan_seconds = perf_counter() - scan_start\n", "\n", "scan_rows = []\n", "variant_poses = {}\n", "for pose_index, (outcome, variant) in enumerate(scan_requests):\n", " packed_variant = packed_mutation_batch.split(pose_index)\n", " state_label = f\"{variant} (repacked WT)\" if variant == original_name3 else variant\n", " if outcome == 1:\n", " variant_poses[state_label] = packed_variant\n", "\n", " # The monotonic identity helper must leave every non-target identity unchanged.\n", " for block_index in range(packed_variant.max_n_blocks):\n", " if block_index != target_block:\n", " assert (\n", " packed_variant.block_type(0, block_index).name3\n", " == pose_stack.block_type(0, block_index).name3\n", " )\n", "\n", " scan_rows.append(\n", " {\n", " \"block_index\": target_block,\n", " \"pdb_label\": target_label,\n", " \"variant\": variant,\n", " \"state\": state_label,\n", " \"outcome\": outcome,\n", " \"total_weighted_score_units\": total_score(packed_variant),\n", " \"target_to_rest_weighted_score_units\": target_to_rest_score(\n", " packed_variant, target_block\n", " ),\n", " \"shared_batch_seconds\": scan_seconds,\n", " }\n", " )\n", "\n", "scan_frame = pd.DataFrame(scan_rows)\n", "show_table(scan_frame.sort_values([\"variant\", \"outcome\"]))\n", "\n", "# Summarize each identity independently, then compare distribution means.\n", "scan_summary = (\n", " scan_frame.groupby([\"variant\", \"state\"], as_index=False)\n", " .agg(\n", " total_score_mean=(\"total_weighted_score_units\", \"mean\"),\n", " total_score_min=(\"total_weighted_score_units\", \"min\"),\n", " total_score_max=(\"total_weighted_score_units\", \"max\"),\n", " target_to_rest_mean=(\"target_to_rest_weighted_score_units\", \"mean\"),\n", " target_to_rest_min=(\"target_to_rest_weighted_score_units\", \"min\"),\n", " target_to_rest_max=(\"target_to_rest_weighted_score_units\", \"max\"),\n", " )\n", ")\n", "scan_summary[\"total_score_range\"] = (\n", " scan_summary[\"total_score_max\"] - scan_summary[\"total_score_min\"]\n", ")\n", "scan_summary[\"target_to_rest_range\"] = (\n", " scan_summary[\"target_to_rest_max\"] - scan_summary[\"target_to_rest_min\"]\n", ")\n", "wt_summary = scan_summary.loc[scan_summary[\"variant\"] == original_name3].iloc[0]\n", "scan_summary[\"total_difference_of_means_vs_repacked_wt_non_ddg\"] = (\n", " scan_summary[\"total_score_mean\"] - wt_summary[\"total_score_mean\"]\n", ")\n", "scan_summary[\"target_to_rest_difference_of_means_vs_repacked_wt_non_ddg\"] = (\n", " scan_summary[\"target_to_rest_mean\"] - wt_summary[\"target_to_rest_mean\"]\n", ")\n", "scan_summary = scan_summary.sort_values(\n", " \"total_difference_of_means_vs_repacked_wt_non_ddg\"\n", ")\n", "show_table(scan_summary)" ] }, { "cell_type": "code", "execution_count": 9, "id": "702d9cbe", "metadata": { "tags": [ "collapse-code" ] }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Orange: local repacking shell (7 blocks); mutation target: block 4 (A:5).\n" ] }, { "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" } ], "source": [ "plot_summary = scan_summary.sort_values(\n", " \"target_to_rest_difference_of_means_vs_repacked_wt_non_ddg\"\n", ").reset_index(drop=True)\n", "fig, ax = plt.subplots(figsize=(8, 4.2))\n", "for y_position, row in plot_summary.iterrows():\n", " outcome_offsets = (\n", " scan_frame.loc[\n", " scan_frame[\"variant\"] == row[\"variant\"],\n", " \"target_to_rest_weighted_score_units\",\n", " ].to_numpy()\n", " - wt_summary[\"target_to_rest_mean\"]\n", " )\n", " ax.hlines(\n", " y_position,\n", " outcome_offsets.min(),\n", " outcome_offsets.max(),\n", " color=\"0.45\",\n", " linewidth=2,\n", " )\n", " ax.scatter(outcome_offsets, np.full_like(outcome_offsets, y_position), color=\"0.35\")\n", " ax.scatter(\n", " row[\"target_to_rest_difference_of_means_vs_repacked_wt_non_ddg\"],\n", " y_position,\n", " color=\"tab:blue\",\n", " marker=\"D\",\n", " zorder=3,\n", " )\n", "ax.axvline(0.0, color=\"black\", linewidth=1)\n", "ax.set_yticks(np.arange(len(plot_summary)), plot_summary[\"state\"])\n", "ax.set(\n", " xlabel=(\n", " \"target-to-rest weighted score relative to independently summarized \"\n", " \"repacked-WT mean (non-ddG)\"\n", " ),\n", " title=f\"Two-outcome local-shell scan at {target_label}: outcomes, range, and mean\",\n", ")\n", "ax.grid(axis=\"x\", alpha=0.25)\n", "plt.tight_layout()\n", "plt.show()\n", "\n", "shell_atom_mask = res_mask_to_coord_mask(pose_stack, mutation_shell)\n", "try:\n", " shell_viewer = tmol.view(\n", " pose_stack,\n", " highlighted=shell_atom_mask[pose_stack.real_atoms],\n", " highlight_color=\"#ff7f0e\",\n", " )\n", " print(\n", " f\"Orange: local repacking shell ({len(shell_block_indices)} blocks); \"\n", " f\"mutation target: block {target_block} ({target_label}).\"\n", " )\n", " shell_viewer.show()\n", "except ImportError as exc:\n", " print(\"Interactive local-shell viewer unavailable:\", exc)" ] }, { "cell_type": "markdown", "id": "4d9da7b8", "metadata": {}, "source": [ "**Expected observations.** Variants can differ in both total score and target-to-rest score. CUDA outcomes may show annealing spread, but an observed range of exactly zero is valid and does not establish determinism or convergence. The CPU path reports one result per identity rather than presenting torch-reseeded calls as controlled replicates. `shared_batch_seconds` is the wall time for the single packer call containing all identities and outcomes, not a per-variant time. The orange highlight identifies the complete geometry-defined repacking shell; the printed author label identifies the mutated block.\n", "\n", "The WT distribution is an independently **repacked WT**, not the input structure and not an outcome-by-outcome partner for a mutant. Each identity's outcomes are summarized first. `target_to_rest_difference_of_means_vs_repacked_wt_non_ddg` then subtracts the independently summarized WT mean from the variant mean after both directed matrix orientations are combined; the total-score comparison uses the same difference-of-means rule. The plot centers outcomes on the WT mean, shows every observed point and range, and marks each mean with a diamond. Neither quantity is a ΔΔG: the workflow constructs no folded/unfolded, bound/unbound, or experimentally calibrated thermodynamic states. The one CPU result or two CUDA outcomes per identity are illustrative, not converged." ] }, { "cell_type": "code", "execution_count": 10, "id": "c6e9de16", "metadata": { "tags": [ "collapse-code" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "lowest mean total score in this two-outcome local scan: VAL (repacked WT) (a stochastic score result, not a stability ranking)\n" ] }, { "data": { "text/html": [ "\n", "
\n", " \n", "
\n", " \n", "
\n", "
outcome 1 structure; independently summarized mean score 17.260; observed range 0.000
\n", "
\n", "

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

\n", "
\n", "\n", "
\n", "
\n", "
outcome 1 structure; independently summarized mean score 20.799; observed range 0.000
\n", "
\n", "

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

\n", "
\n", "\n", "
\n", "
\n", "
outcome 1 structure; independently summarized mean score 17.878; observed range 0.000
\n", "
\n", "

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

\n", "
\n", "\n", "
\n", "
\n", "
outcome 1 structure; independently summarized mean score 19.630; observed range 0.000
\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": [ "lowest_mean_state = scan_summary.iloc[0]\n", "print(\n", " \"lowest mean total score in this two-outcome local scan:\",\n", " lowest_mean_state[\"state\"],\n", " \"(a stochastic score result, not a stability ranking)\",\n", ")\n", "summary_by_state = scan_summary.set_index(\"state\")\n", "try:\n", " display(\n", " tmol.switchable_view(\n", " variant_poses,\n", " notes={\n", " state: (\n", " f\"outcome 1 structure; independently summarized mean score \"\n", " f\"{summary_by_state.loc[state, 'total_score_mean']:.3f}; \"\n", " f\"observed range \"\n", " f\"{summary_by_state.loc[state, 'total_score_range']:.3f}\"\n", " )\n", " for state in variant_poses\n", " },\n", " width=720,\n", " height=420,\n", " )\n", " )\n", "except ImportError as exc:\n", " print(\"Interactive mutation comparison unavailable:\", exc)" ] }, { "cell_type": "markdown", "id": "e8bc4ce2", "metadata": {}, "source": [ "## Regional sequence design in a geometry-defined shell\n", "\n", "A mutation scan fixes one identity per pose. Design instead permits several identities at several positions and lets simulated annealing choose combinations jointly with side-chain conformers. The design positions define a centroid/radius adjacency shell: design blocks may change identity, neighboring shell blocks are repack-only, and all blocks outside the shell are disabled. The code verifies those blocks remain fixed to float32 reconstruction precision using each block's own coordinate offset.\n", "\n", "Here three batch members share one `PoseStack`; each pose receives its own complete packing call within the batch. On CUDA, each pose gets an independent Philox-driven full anneal (internally 500 high-temperature, 1,250 low-temperature, and 312 quench trajectories); the three poses are not three trajectories inside one annealer. On CPU, each pose uses the single-trajectory C-RNG implementation and batch members may collapse to identical results. The three members demonstrate the batched design API, not controlled CPU replicates, convergence, or identically searched replicates across devices.\n", "\n", "This is a small demonstration of TMol's lower-level task masks, not an equivalent of Rosetta resfiles, HBNet, FastDesign, or backbone design." ] }, { "cell_type": "code", "execution_count": 11, "id": "b21b451c", "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", "\n", "\n", "
block_indexpdb_labelstarting_identityrole
0A:1METfrozen
1A:2GLNrepack-only
2A:3ILErepack-only
3A:4PHErepack-only
4A:5VALdesign
5A:6LYSrepack-only
6A:7THRdesign
7A:8LEUrepack-only
8A:9THRrepack-only
9A:10GLYrepack-only
\n", "\n", "\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "\n", "\n", " \n", " \n", " \n", " \n", " \n", "\n", "
\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "\n", "\n", "\n", "
batch_memberblock_4_identityblock_6_identitysequence_pairtotal_scoremax_frozen_coordinate_change_Ashared_batch_seconds
1VALTHRVAL-THR14.6517810.0000040.377367
2VALTHRVAL-THR14.6517810.0000040.377367
3VALTHRVAL-THR14.6517810.0000040.377367
\n", "\n", "\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Orange: complete design packing shell; see the role table for design, repack-only, and frozen assignments.\n" ] }, { "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", "
VAL-THR; max frozen coordinate change 0.000 Å
\n", "
\n", "

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

\n", "
\n", "\n", "
\n", "
\n", "
VAL-THR; max frozen coordinate change 0.000 Å
\n", "
\n", "

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

\n", "
\n", "\n", "
\n", "
\n", "
VAL-THR; max frozen coordinate change 0.000 Å
\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": [ "def restrict_regional_design(task, allowed_name3_by_block):\n", " \"\"\"Keep the original identity elsewhere and allow a small design alphabet.\"\"\"\n", " considered = task.per_block_considered_block_types\n", " keep = task.per_block_considered_block_types_is_orig.detach().clone()\n", " for pose_index in range(keep.shape[0]):\n", " for block_index, allowed_names in allowed_name3_by_block.items():\n", " considered_types = (\n", " considered[pose_index, block_index].detach().cpu().tolist()\n", " )\n", " allowed = torch.tensor(\n", " [\n", " index >= 0\n", " and task.pbt.active_block_types[index].name3 in allowed_names\n", " for index in considered_types\n", " ],\n", " dtype=torch.bool,\n", " device=task.device,\n", " )\n", " if not torch.any(allowed):\n", " raise ValueError(f\"No requested identities at block {block_index}\")\n", " keep[pose_index, block_index] = allowed\n", " task.per_block_is_block_type_allowed = torch.logical_and(\n", " task.per_block_is_block_type_allowed, keep\n", " )\n", " return task\n", "\n", "\n", "design_blocks = [4, 6]\n", "design_alphabet = {\n", " block_index: {\n", " pose_stack.block_type(0, block_index).name3,\n", " \"ALA\",\n", " \"LEU\",\n", " \"PHE\",\n", " }\n", " for block_index in design_blocks\n", "}\n", "\n", "# The union of adjacency neighborhoods defines which blocks may pack.\n", "design_block_mask = torch.zeros(\n", " (pose_stack.n_poses, pose_stack.max_n_blocks),\n", " dtype=torch.bool,\n", " device=device,\n", ")\n", "design_block_mask[:, design_blocks] = True\n", "design_shell = torch.any(block_adjacency[:, design_blocks, :], dim=1)\n", "design_shell |= design_block_mask\n", "design_repack_only = design_shell & ~design_block_mask\n", "design_frozen = ~design_shell\n", "\n", "def design_pdb_label(block_index):\n", " return (\n", " f\"{pose_stack.pdb_info.chain_labels[0, block_index]}:\"\n", " f\"{pose_stack.pdb_info.residue_labels[0, block_index]}\"\n", " f\"{pose_stack.pdb_info.residue_insertion_codes[0, block_index]}\"\n", " )\n", "\n", "\n", "design_role_rows = []\n", "for block_index in range(pose_stack.max_n_blocks):\n", " if bool(design_block_mask[0, block_index]):\n", " role = \"design\"\n", " elif bool(design_repack_only[0, block_index]):\n", " role = \"repack-only\"\n", " else:\n", " role = \"frozen\"\n", " design_role_rows.append(\n", " {\n", " \"block_index\": block_index,\n", " \"pdb_label\": design_pdb_label(block_index),\n", " \"starting_identity\": pose_stack.block_type(0, block_index).name3,\n", " \"role\": role,\n", " }\n", " )\n", "design_role_frame = pd.DataFrame(design_role_rows)\n", "show_table(design_role_frame)\n", "\n", "n_design_batch_members = 3\n", "design_batch = PoseStackBuilder.from_poses(\n", " [pose_stack] * n_design_batch_members, device\n", ")\n", "design_task = PackerTask(design_batch, PackerPalette())\n", "restrict_regional_design(design_task, design_alphabet)\n", "design_shell_batch = design_shell.expand(n_design_batch_members, -1).clone()\n", "design_task.disable_packing_by_block_mask(~design_shell_batch)\n", "add_standard_samplers(design_task)\n", "\n", "torch.manual_seed(SEED)\n", "if device.type == \"cuda\":\n", " torch.cuda.synchronize()\n", "design_start = perf_counter()\n", "designed_batch = pack_rotamers(design_batch, score_function, design_task)\n", "if device.type == \"cuda\":\n", " torch.cuda.synchronize()\n", "design_seconds = perf_counter() - design_start\n", "\n", "design_rows = []\n", "design_poses = {}\n", "frozen_block_indices = torch.nonzero(\n", " design_frozen[0], as_tuple=False\n", ").flatten().tolist()\n", "for pose_index in range(n_design_batch_members):\n", " designed_pose = designed_batch.split(pose_index)\n", " label = f\"batch member {pose_index + 1}\"\n", " identities = [\n", " designed_pose.block_type(0, block_index).name3\n", " for block_index in design_blocks\n", " ]\n", "\n", " # Compare each frozen block in local coordinates; mutations can shift later offsets.\n", " max_frozen_coordinate_change = 0.0\n", " for block_index in frozen_block_indices:\n", " input_block_type = pose_stack.block_type(0, block_index)\n", " output_block_type = designed_pose.block_type(0, block_index)\n", " assert output_block_type.name == input_block_type.name\n", " n_block_atoms = len(input_block_type.atoms)\n", " input_offset = int(pose_stack.block_coord_offset64[0, block_index])\n", " output_offset = int(designed_pose.block_coord_offset64[0, block_index])\n", " input_block_coords = pose_stack.coords[\n", " 0, input_offset : input_offset + n_block_atoms\n", " ]\n", " output_block_coords = designed_pose.coords[\n", " 0, output_offset : output_offset + n_block_atoms\n", " ]\n", " # Pose reconstruction may introduce a few micro-angstroms of float32\n", " # roundoff even when packing is disabled for the block.\n", " torch.testing.assert_close(\n", " output_block_coords, input_block_coords, rtol=1e-6, atol=1e-5\n", " )\n", " block_change = float(\n", " torch.linalg.vector_norm(\n", " output_block_coords - input_block_coords, dim=-1\n", " )\n", " .max()\n", " .detach()\n", " .cpu()\n", " )\n", " max_frozen_coordinate_change = max(\n", " max_frozen_coordinate_change, block_change\n", " )\n", "\n", " design_poses[label] = designed_pose\n", " design_rows.append(\n", " {\n", " \"batch_member\": pose_index + 1,\n", " \"block_4_identity\": identities[0],\n", " \"block_6_identity\": identities[1],\n", " \"sequence_pair\": \"-\".join(identities),\n", " \"total_score\": total_score(designed_pose),\n", " \"max_frozen_coordinate_change_A\": max_frozen_coordinate_change,\n", " \"shared_batch_seconds\": design_seconds,\n", " }\n", " )\n", "\n", "design_frame = pd.DataFrame(design_rows).sort_values(\"total_score\")\n", "show_table(design_frame)\n", "\n", "design_shell_atom_mask = res_mask_to_coord_mask(pose_stack, design_shell)\n", "try:\n", " design_region_viewer = tmol.view(\n", " pose_stack,\n", " highlighted=design_shell_atom_mask[pose_stack.real_atoms],\n", " highlight_color=\"#ff7f0e\",\n", " )\n", " print(\n", " \"Orange: complete design packing shell; see the role table for \"\n", " \"design, repack-only, and frozen assignments.\"\n", " )\n", " design_region_viewer.show()\n", " display(\n", " tmol.switchable_view(\n", " design_poses,\n", " notes={\n", " f\"batch member {row['batch_member']}\": (\n", " f\"{row['sequence_pair']}; max frozen coordinate change \"\n", " f\"{row['max_frozen_coordinate_change_A']:.3f} Å\"\n", " )\n", " for row in design_rows\n", " },\n", " width=720,\n", " height=420,\n", " )\n", " )\n", "except ImportError as exc:\n", " print(\"Interactive design comparison unavailable:\", exc)" ] }, { "cell_type": "markdown", "id": "3a24eb51", "metadata": {}, "source": [ "## Rosetta comparison\n", "\n", "Both systems separate a task describing allowed identities/conformers from the packing algorithm. Rosetta has mature `ResidueSelector`, `TaskOperation`, resfile, mover, and mutation-scan protocol layers. The mutation and design shells above adapt that experimental design explicitly with TMol's centroid/radius adjacency helper and disable masks; neither is an implementation of Rosetta's `NeighborhoodResidueSelector`. The design role table makes the lower-level contract explicit: design positions may change identity, shell neighbors are repack-only, and blocks outside the shell are frozen and checked by block-local coordinate slices.\n", "\n", "Likewise, Rosetta `ex1`/`ex2` motivate the χ1/χ2 expansion comparison, while TMol receives zero-based chi indices `0`/`1` and does not promise the same candidates. TMol exposes lower-level `PackerPalette`/`PackerTask` masks and GPU-oriented packer machinery, but no native point-mutation-scan protocol or Rosetta `ResidueSelector` equivalent. The [Rosetta-to-TMol crosswalk](rosetta_crosswalk.md) summarizes these boundaries.\n", "\n", "For the complete Rosetta workflows, see [Optimizing Sidechains: The Packer](https://docs.rosettacommons.org/demos/latest/tutorials/Optimizing_Sidechains_The_Packer/Optimizing_Sidechains_The_Packer), [PyRosetta packing and regional relax](https://nbviewer.org/github/RosettaCommons/PyRosetta.notebooks/blob/master/notebooks/06.02-Packing-design-and-regional-relax.ipynb), [06.08 Point Mutation Scan](https://nbviewer.org/github/RosettaCommons/PyRosetta.notebooks/blob/master/notebooks/06.08-Point-Mutation-Scan.ipynb), and [16.01 distributed ddG/PSSM](https://nbviewer.org/github/RosettaCommons/PyRosetta.notebooks/blob/master/notebooks/16.01-PyData-ddG-pssm.ipynb).\n", "\n", "## Next: complete the continuous branch\n", "\n", "Continue to [05 — Minimization, constraints, and kinematics](05_minimization_constraints_kinematics.ipynb) if you have not completed it, then use [06 — FastRelax](06_fast_relax.ipynb) to compose fixed-sequence packing with continuous minimization under a staged score function." ] }, { "cell_type": "markdown", "id": "53543505", "metadata": {}, "source": [ "## Exercises\n", "\n", "1. Change the regional repacking mask and verify that disabled blocks retain their input coordinates.\n", "2. Change the adjacency constant, redisplay the mutation and design shells, and record which author-labeled blocks change role.\n", "3. Increase the scan to at least five independent outcomes per identity; summarize each distribution before computing differences of means, and do not call any score difference a $\\Delta\\Delta G$. Remember that `torch.manual_seed()` still does not seed the CPU C RNG.\n", "4. Add Cartesian minimization after each packed variant and state how that changes the computational experiment.\n", "5. Sketch an external scheduler that shards positions across GPUs while preserving one result row per position, identity, outcome, and score-function version." ] }, { "cell_type": "markdown", "id": "47862332", "metadata": {}, "source": [ "## References\n", "\n", "- [Rosetta-to-TMol crosswalk](rosetta_crosswalk.md)\n", "- [Rosetta Packer tutorial](https://docs.rosettacommons.org/demos/latest/tutorials/Optimizing_Sidechains_The_Packer/Optimizing_Sidechains_The_Packer)\n", "- [PyRosetta 06.01 Side Chain Conformations and Dunbrack Energies](https://nbviewer.org/github/RosettaCommons/PyRosetta.notebooks/blob/master/notebooks/06.01-Side-Chain-Conformations-and-Dunbrack-Energies.ipynb)\n", "- [PyRosetta 06.02 Packing and regional relax](https://nbviewer.org/github/RosettaCommons/PyRosetta.notebooks/blob/master/notebooks/06.02-Packing-design-and-regional-relax.ipynb)\n", "- [PyRosetta 06.08 Point Mutation Scan](https://nbviewer.org/github/RosettaCommons/PyRosetta.notebooks/blob/master/notebooks/06.08-Point-Mutation-Scan.ipynb)\n", "- [PyRosetta 16.01 distributed ddG/PSSM](https://nbviewer.org/github/RosettaCommons/PyRosetta.notebooks/blob/master/notebooks/16.01-PyData-ddG-pssm.ipynb)\n", "- [TMol repository](https://github.com/uw-ipd/tmol)" ] } ], "metadata": { "accelerator": "GPU", "colab": { "gpuType": "T4" }, "language_info": { "name": "python" } }, "nbformat": 4, "nbformat_minor": 5 }