{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Loop Modeling\n", "Keywords: loops, fold_tree_from_loops, CCD, KIC, cut-point variant, FoldTree, MoveMap\n", "\n", "Loop modeling is an important step in building homology models, designing enzymes, or docking with flexible loops. In this notebook, you'll learn how to manually set up a loop FoldTree to gain an understanding of how it works. However, in practice, you will not need to make the FoldTree from scratch, and we will see examples of this is the next notebook.\n", "\n", "\n", "## Suggested Readings\n", "\n", "* A. Canutescu & R. L. Dunbrack, “Cyclic coordinate descent: A robotics algorithm for protein loop closure,” Protein Sci. 12, 963-972 (2003).\n", "\n", "* Wang, P. Bradley & D. Baker, “Protein-protein docking with backbone flexibility,” J. Mol. Biol. 373, 503-519 (2007).\n", "\n", "* J. Mandell, E. A. Coutsias & T. Kortemme, “Sub-angstrom accuracy in protein loop reconstruction by robotics-inspired conformational sampling,” Nature Meth. 6, 551-552 (2009)." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "# Notebook setup\n", "import sys\n", "if 'google.colab' in sys.modules:\n", " !pip install pyrosettacolabsetup\n", " import pyrosettacolabsetup\n", " pyrosettacolabsetup.setup()\n", " print (\"Notebook is set for PyRosetta use in Colab. Have fun!\")" ] }, { "cell_type": "code", "execution_count": 39, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\u001b[0mcore.init: \u001b[0mChecking for fconfig files in pwd and ./rosetta/flags\n", "\u001b[0mcore.init: \u001b[0mRosetta version: PyRosetta4.Release.python36.mac r208 2019.04+release.fd666910a5e fd666910a5edac957383b32b3b4c9d10020f34c1 http://www.pyrosetta.org 2019-01-22T15:55:37\n", "\u001b[0mcore.init: \u001b[0mcommand: PyRosetta -ex1 -ex2aro -database /Users/kathyle/Computational Protein Prediction and Design/PyRosetta4.Release.python36.mac.release-208/pyrosetta/database\n", "\u001b[0mcore.init: \u001b[0m'RNG device' seed mode, using '/dev/urandom', seed=-128678703 seed_offset=0 real_seed=-128678703\n", "\u001b[0mcore.init.random: \u001b[0mRandomGenerator:init: Normal mode, seed=-128678703 RG_type=mt19937\n" ] } ], "source": [ "from pyrosetta import *\n", "from pyrosetta.rosetta import *\n", "from pyrosetta.teaching import *\n", "\n", "from rosetta.core.kinematics import FoldTree\n", "pyrosetta.init()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Fold Tree\n", "Because we typically want to isolate the conformational changes to the loop region, we need a framework to hold the rest of the protein together. This is accomplished — as was the case with protein-protein docking — with a fold tree, which is a graph that dictates the propagation of conformational changes throughout the Pose.\n", "\n", "For the following exercises, you can find the working PDB, `test_in.pdb`, and a 3mer fragment file, `test_in.frag3` in the `inputs` folder." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Make sure you are in the directory with the pdb files:**\n", "\n", "`cd google_drive/My\\ Drive/student-notebooks/`" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "#cd google_drive/My\\ Drive/student-notebooks/" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Fold Tree (from scratch)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Load the `test_in.pdb` structure (116 residues).\n", "```\n", "start_pose = pyrosetta.pose_from_file(\"inputs/test_in.pdb\")\n", "```" ] }, { "cell_type": "code", "execution_count": 63, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\u001b[0mcore.import_pose.import_pose: \u001b[0mFile 'inputs/test_in.pdb' automatically determined to be of type PDB\n" ] } ], "source": [ "start_pose = pyrosetta.pose_from_file(\"inputs/test_in.pdb\")\n", "pose.assign(start_pose)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We want to operate on the first loop, residues 15–24. For the fold tree, we place the jump anchors two residues outside of the loop range, i.e., residues 13–26. In loop modeling, the jump points are set at i-2 and j+2, where i and j are the beginning and end residues of the loop, respectively." ] }, { "cell_type": "code", "execution_count": 41, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "execution_count": 41, "metadata": { "image/png": { "width": "700" } }, "output_type": "execute_result" } ], "source": [ "from IPython.display import Image\n", "Image('./Media/fold-tree1.png',width='700')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "That is, we want a cut between residues 19 and 20, to allow motions in the loop that do not propagate through the rest of the protein. To tie the pieces together, we use a jump between residues 13 and 26. These residues will stay connected to each other.\n", "\n", "To make such a tree in PyRosetta, first we create a `FoldTree` object:\n", "\n", "```\n", "ft = FoldTree()\n", "```" ] }, { "cell_type": "code", "execution_count": 64, "metadata": {}, "outputs": [], "source": [ "ft = FoldTree()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "__Be careful that you don't re-run the same cell multiple times as you will keep adding these pieces to the FoldTree, which will mess it up__\n", "\n", "Then we add the \"edges” and the jump. Both `EDGE`s and `Jump`s are entered using the `FoldTree`’s `add_edge(start, end, code)` command, with peptide edges coded with a “-1” and jumps enumerated with the positive integers. (The first jump is coded “1”, the second “2”, etc.) The first edge is from residues 1 to 13:\n", "\n", "```\n", "ft.add_edge(1, 13, -1)\n", "```" ] }, { "cell_type": "code", "execution_count": 65, "metadata": {}, "outputs": [], "source": [ "ft.add_edge(1, 13, -1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Then the second is from 13 to 19. __An `EDGE` must always start from a residue that has already been defined in another `EDGE`__, thus we use 13 here and not 14. (The one exception is the first edge, which starts from the graph’s “root”).\n", "\n", "```\n", "ft.add_edge(13, 19, -1)\n", "```" ] }, { "cell_type": "code", "execution_count": 66, "metadata": {}, "outputs": [], "source": [ "ft.add_edge(13, 19, -1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Next, the `Jump`, which is specified with the integer code 1, tells Rosetta that this is a rigid-body connection, not a peptide `EDGE`:\n", "\n", "```\n", "ft.add_edge(13, 26, 1)\n", "```" ] }, { "cell_type": "code", "execution_count": 67, "metadata": {}, "outputs": [], "source": [ "ft.add_edge(13, 26, 1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Finally, we add the last two `EDGE`s, both starting from 26, which is the residue that has been previously defined in the tree:\n", "\n", "```\n", "ft.add_edge(26, 20, -1)\n", "ft.add_edge(26, 116, -1)\n", "```" ] }, { "cell_type": "code", "execution_count": 68, "metadata": {}, "outputs": [], "source": [ "ft.add_edge(26, 20, -1)\n", "ft.add_edge(26, 116, -1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Print the fold tree and check that this tree is valid:\n", "\n", "```\n", "print(ft)\n", "ft.check_fold_tree()\n", "```\n", "\n", "The latter command will return `False` if there are any invalid connections, disconnected parts, or undefined residues." ] }, { "cell_type": "code", "execution_count": 69, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "FOLD_TREE EDGE 1 13 -1 EDGE 13 19 -1 EDGE 13 26 1 EDGE 26 20 -1 EDGE 26 116 -1 \n" ] }, { "data": { "text/plain": [ "True" ] }, "execution_count": 69, "metadata": {}, "output_type": "execute_result" } ], "source": [ "print(ft)\n", "ft.check_fold_tree()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Finally, we attach this fold tree to the pose, overwriting its default fold tree. Print the `Pose`'s `FoldTree` to confirm you changed it:\n", "\n", "```\n", "print(pose.fold_tree())\n", "pose.fold_tree(ft)\n", "print(pose.fold_tree())\n", "```" ] }, { "cell_type": "code", "execution_count": 70, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "FOLD_TREE EDGE 1 116 -1 \n", "FOLD_TREE EDGE 1 13 -1 EDGE 13 19 -1 EDGE 13 26 1 EDGE 26 20 -1 EDGE 26 116 -1 \n" ] } ], "source": [ "print(pose.fold_tree())\n", "pose.fold_tree(ft)\n", "print(pose.fold_tree())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Fold Tree (using functions)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In the previous section, we created a FoldTree and manually created the cutpoint variants. However, it is often more practical to use the pre-made functions. In order to use these functions, we first need to make a `Loop` object." ] }, { "cell_type": "markdown", "metadata": {}, "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Single loop" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Once you have a loop defined in a `Loop` object, you can set your fold tree with the `set_single_loop_fold_tree` command. Note that the `FoldTree` will look slightly different compared to the one we manually created:\n", "\n", "```\n", "pose.assign(start_pose)\n", "print(pose.fold_tree())\n", "set_single_loop_fold_tree(pose, loop1)\n", "print(pose.fold_tree())\n", "```" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Multiple Loops\n", "\n", "Multiple loops can be stored in a `Loops` object. We can create a `loop2` object for the 78–83 loop and then create a `Loops` object:\n", "\n", "```\n", "loop2 = Loop(78, 83, 80)\n", "\n", "loops = Loops()\n", "loops.add_loop(loop1)\n", "loops.add_loop(loop2)\n", "```" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Next, we can use the `fold_tree_from_loops` function, which requires a pose, a Loops object, and an empty `FoldTree`." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "pose.assign(start_pose) # start with our original pose\n", "ft = FoldTree() # start with an empty FoldTree\n", "\n", "fold_tree_from_loops(pose, loops, ft);\n", "pose.fold_tree(ft); # attaching our new FoldTree to our working pose\n", "add_cutpoint_variants(pose);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Exercises" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "1. **Optional PyMOL Exercise:** Test out your fold tree. Do `pose.set_phi(res, 180)` for res values of 10, 13, 16, 23, 26 and 29. View each in PyMOL with the `PyMOLMover`.\n", "\n", "```\n", "pose.assign(start_pose)\n", "pmm = PyMOLMover() # unique port number here, if needed\n", "pmm.keep_history(True)\n", "pmm.apply(pose)\n", "for res in (10, 13, 16, 23, 26, 29):\n", " pose.set_phi(res, 180)\n", "pmm.apply(pose)\n", "```" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "2. Sketch a fold tree that you could use for modeling a loop from residues 78–83. Remember that a loop from residues i to j uses a fold tree with a jump from residues i-2 to j+2." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "3. What edges would you use to generate the above fold tree? See the above steps for how to add `EDGE`s to the `FoldTree`" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To save some time and help avoid mistakes, there are a couple functions that will assist in the creation of fold trees:" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "4. Try each of the following and print the fold tree. What does each of the following do?\n", "\n", "```\n", "ft.clear()\n", "print(ft)\n", "\n", "ft.simple_tree(116)\n", "print(ft)\n", "\n", "ft.new_jump(76, 85, 80)\n", "print(ft)\n", "```" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "5. Use these FoldTree methods to check your answer to question 3." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "6. Use the above commands to make a fold tree to model both loops (15–24 and 78–83) simultaneously. Note you'll need more than one `Jump`" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Cyclic Coordination Descent (CCD) Loop Closure\n", "\n", "Canutescu & Dunbrack’s CCD routine is implemented as a `Mover`. It first requires that the loop is defined using the `Loop` class. In addition to the FoldTree that you created in the previous section (whether by hand or using a function), you will also need to create a `MoveMap` with the loop residues marked as flexible (both backbone and side-chain torsion angles). Like many specialty objects in Rosetta, the CCD `Mover` is located in its own namespace and is not loaded in by default when the rest of Rosetta is imported into Python. You can either import the module or refer to its namespace when calling it. Here we show the module import:\n", "\n", "```\n", "from pyrosetta.rosetta.protocols.loops import Loop, Loops, set_single_loop_fold_tree, loop_rmsd\n", "from pyrosetta.rosetta.protocols.loops.loop_closure.ccd import *\n", "\n", "loop1 = Loop(15, 24, 19)\n", "\n", "loop_mm = MoveMap()\n", "loop_mm.set_bb_true_range(15, 24)\n", "loop_mm.set_chi_true_range(15, 24)\n", "\n", "ccd = CCDLoopClosureMover(loop1, loop_mm)\n", "print(ccd)\n", "```\n", "\n", "__Question:__ When declaring the `Loop` object, what do 15, 24, and 19 mean, respectively? See what is written out when you `print` the `ccd` object" ] }, { "cell_type": "code", "execution_count": 71, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Mover name: CCDLoopClosureMover, Mover type: CCDLoopClosureMover, Mover current tag:NoTag\n", "LOOP start: 15 stop: 24 cut: 19 size: 10 skip rate: 0 extended?: False\n", "\n", "Number of CCD cycles: 100\n", "Tolerance: 0.08\n", "bRama check: True\n", "Max total delta helix: 10\n", "Max total delta strand: 50\n", "Max total delta loop: 75\n", "Movemap: \n", "\n", "-------------------------------\n", " resnum Type TRUE/FALSE \n", "-------------------------------\n", " DEFAULT BB FALSE\n", " DEFAULT SC FALSE\n", " DEFAULT NU FALSE\n", " DEFAULT BRANCH FALSE\n", " 015 BB TRUE\n", " SC TRUE\n", " 016 BB TRUE\n", " SC TRUE\n", " 017 BB TRUE\n", " SC TRUE\n", " 018 BB TRUE\n", " SC TRUE\n", " 019 BB TRUE\n", " SC TRUE\n", " 020 BB TRUE\n", " SC TRUE\n", " 021 BB TRUE\n", " SC TRUE\n", " 022 BB TRUE\n", " SC TRUE\n", " 023 BB TRUE\n", " SC TRUE\n", " 024 BB TRUE\n", " SC TRUE\n", "-------------------------------\n", " jumpnum Type TRUE/FALSE \n", "-------------------------------\n", " DEFAULT JUMP FALSE\n", "-------------------------------\n", " resnum atomnum Type TRUE/FALSE \n", "-------------------------------\n", " DEFAULT PHI FALSE\n", " DEFAULT THETA FALSE\n", " DEFAULT D FALSE\n", " DEFAULT RB1 FALSE\n", " DEFAULT RB2 FALSE\n", " DEFAULT RB3 FALSE\n", " DEFAULT RB4 FALSE\n", " DEFAULT RB5 FALSE\n", " DEFAULT RB6 FALSE\n", "-------------------------------\n", "\n", "RamaCheck: \n", "RamaCheck1B:\n", "\n", "Temperature: 0.25\n", "Maximum Ramachandran Score Increase Tolerated: 2\n", "\n" ] } ], "source": [ "from pyrosetta.rosetta.protocols.loops import Loop, Loops, set_single_loop_fold_tree, loop_rmsd\n", "from pyrosetta.rosetta.protocols.loops.loop_closure.ccd import *\n", "\n", "loop1 = Loop(15, 24, 19)\n", "\n", "loop_mm = MoveMap()\n", "loop_mm.set_bb_true_range(15, 24)\n", "loop_mm.set_chi_true_range(15, 24)\n", "\n", "ccd = CCDLoopClosureMover(loop1, loop_mm)\n", "print(ccd)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Before running the CCD algorithm, it is important to convert the residues around the cut site of the loop to “cut-point variants”:\n", "\n", "```\n", "add_single_cutpoint_variant(pose, loop1)\n", "```" ] }, { "cell_type": "code", "execution_count": 72, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\u001b[0mprotocols.loops.loops_main: \u001b[0mAdded cutpoint variant to residue 19\n", "\u001b[0mprotocols.loops.loops_main: \u001b[0mAdded cutpoint variant to residue 20\n" ] }, { "data": { "text/plain": [ "True" ] }, "execution_count": 72, "metadata": {}, "output_type": "execute_result" } ], "source": [ "add_single_cutpoint_variant(pose, loop1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "7. Now that the cutpoint variant has been added, open the loop using `set_phi`, and `apply` the CCD `Mover` on the `Pose`. Does it close the loop? Is the bond across the cut point protein-like?" ] }, { "cell_type": "code", "execution_count": 75, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 75, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Break the loop\n", "pose.set_phi(16, 10) # 10 degrees is arbitrary\n", "pose.set_phi(17, 10)\n", "pose.set_phi(18, 10)\n", "pose.set_phi(19, 10)\n", "pose.dump_pdb(\"outputs/brokenloop.pdb\") # Be sure to look at it in PyMOL!" ] }, { "cell_type": "code", "execution_count": 77, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 77, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Apply CCD Mover\n", "ccd.apply(pose)\n", "pose.dump_pdb(\"outputs/ccdloop.pdb\") # Compare this to brokenloop.pdb and test_in.pdb in PyMOL. What's the difference?" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Note:** To use CCD on multiple loops, you have to iterate over each one." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Loop Building\n", "\n", "The `MoveMap` and the `FoldTree` work together. By using a `MoveMap`, you can ensure that a `Mover` will only operate inside the loop region." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "At this point, you should be able to write your own loop protocol that will build the loop at low-resolution using fragments. Some tips:\n", "\n", "\n", "* Create a MoveMap that will allow motions only in the two loop regions defined in our MoveMap above.\n", "* Create a ClassicFragmentMover using your MoveMap and the 3-residue fragment file provided, test_in.frag3. \n", "* Use the cen_std score function, but add the chainbreak score component with a weight of 1.\n", "* Do 100 fragment insertions.\n", "* After each fragment insertion, close the loop with CCD, then use a MonteCarlo object to accept or reject the combination move.\n", "* Bonus: use SequenceMover and TrialMover to tighten up your code.\n", "* Further bonus: use the JobDistributor to allow your program to make multiple structures." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "`Loop` RMSD is typically measured in a fixed reference frame of the whole protein, and it can be computed on Cα atoms or all backbone atoms. PyRosetta has a built-in function for calculating deviation of all the loops, and its output can be added as additional info in the `PyJobDistributor`. __If the `lrms` comes out to zero, return to the above cells and move one of the loops__:\n", "\n", "```\n", "lrms = loop_rmsd(pose, start_pose, loops, True)\n", "print(lrms)\n", "sfxn = get_score_function()\n", "\n", "jd = PyJobDistributor(\"loop_test\", 1, sfxn)\n", "jd.additional_decoy_info = \" LRMSD: \" + str(lrms)\n", "jd.output_decoy(pose)\n", "```\n", "\n", "(The fourth argument in `loop_rmsd()` tells whether or not the RMSD is calculated for Cα atoms only.)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If you first perturb the loop residues by setting all the residues to extended conformations (φ=ψ=180°), can your code close the two loops and find reasonable conformations? What is the loop RMS?" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## High-Resolution Loop Protocol\n", "\n", "In high-resolution, loop optimization needs smaller perturbations such as that from `Small` and `Shear` moves. The classic Rosetta loop refinement protocol is available as a `Mover` and is located in the `pyrosetta.rosetta.protocols.loops.loop_mover.refine` namespace:\n", "\n", "```\n", "from pyrosetta.rosetta.protocols.loops.loop_mover.refine import *\n", "loop_refine = LoopMover_Refine_CCD(loops)\n", "```\n", "\n", "The `Mover` uses its own default, high-resolution score function, and it will generate its own `MoveMap` based on the definition of the loops." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "`apply` this `Mover` to a few of your low-resolution loop models after switching them to full atom versions. How far does refinement move the loops? Do the loops remain closed? Note: `loop_refine.apply(pose)` might take a while." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Kinematic Closure (KIC) Protocol\n", "\n", "The kinematic loop closure methods of Mandell et al. are also available in several prepared `Movers` and protocols." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A single closure of a loop using the direct mathematical solution using polynomial resultants can be performed by applying the `KinematicMover`. Rather than using a `Loop` object, this `Mover` is set up by specifying the three “pivot” residues. The `KinematicMover` determines new torsion angles for the pivot residues by solving the closure equations.\n", "\n", "```\n", "from pyrosetta.rosetta.protocols.loops.loop_closure.kinematic_closure import *\n", "\n", "set_single_loop_fold_tree(pose, loop1)\n", "pmm.apply(pose)\n", "kic_mover = KinematicMover()\n", "kic_mover.set_pivots(16, 20, 24)\n", "kic_mover.apply(pose)\n", "pmm.apply(pose)\n", "```\n", "\n", "Like the `CCDLoopClosureMover`, the `KinematicMover` can be applied after various perturbations that alter or open the loop." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The full loop prediction protocol of Mandell et al. has been implemented as separate `Movers` for the low- and high-resolution stages. The `LoopMover_Perturb_KIC` operates on a centroid representation `Pose`, and it is designed to predict a loop de novo. The `LoopMover_Refine_KIC` operates in the full-atom representation, and it is designed to refine a loop making small perturbations from a starting conformation such as one output by the `LoopMover_Perturb_KIC` `Mover`. Here is an example of the usage of both:\n", "```\n", "from pyrosetta.rosetta.protocols.loops.loop_mover.perturb import *\n", "from pyrosetta.rosetta.protocols.loops.loop_mover.refine import *\n", "\n", "loops = Loops()\n", "loops.add_loop(loop1)\n", "\n", "set_single_loop_fold_tree(pose, loop1)\n", "\n", "sw = SwitchResidueTypeSetMover(\"centroid\")\n", "sw.apply(pose)\n", "kic_perturb = LoopMover_Perturb_KIC(loops)\n", "#kic_perturb.apply(pose)\n", "sw = SwitchResidueTypeSetMover(\"fa_standard\")\n", "sw.apply(pose)\n", "kic_refine = LoopMover_Refine_KIC(loops)\n", "#kic_refine.apply(pose)\n", "```\n", "\n", "__Because these are full prediction protocols, they will require some time to perform on your computer.__ Each will result in a single decoy structure; note that Mandell et al. generated 1000 decoy structures for blind predictions of 12-residue loops." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "11. Time permitting, repeat exercises 8–10, replacing the CCD `Mover` with the appropriate kinematic `Movers`." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Simultaneous Loop Modeling and Docking\n", "\n", "Antibodies have two chains, light (L) and heavy (H), which can move relative to each other. They also have a long, hypervariable H3 loop, typically residues 95–102. Antibodies are common protein drugs, and they are often created by exploiting the immune system of a mouse. There is a need for high-quality homology models of antibodies." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "12. Sketch a fold tree that you could use to model an antibody with a flexible H3 loop and H and L chains that can move relative to each other." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "13. Write a low-resolution protocol to alternate docking and loop modeling steps. Use your code to model cetuximab. Use the job distributor to track your decoys. What is the lowest RMSD you can create in 100 decoys?" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "anaconda-cloud": {}, "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.6.0" }, "toc": { "base_numbering": 1, "nav_menu": {}, "number_sections": true, "sideBar": true, "skip_h1_title": false, "title_cell": "Table of Contents", "title_sidebar": "Contents", "toc_cell": false, "toc_position": { "height": "calc(100% - 180px)", "left": "10px", "top": "150px", "width": "341.0625px" }, "toc_section_display": true, "toc_window_display": true } }, "nbformat": 4, "nbformat_minor": 1 }