{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "*This notebook contains material from [PyRosetta](https://RosettaCommons.github.io/PyRosetta.notebooks);\n", "content is available [on Github](https://github.com/RosettaCommons/PyRosetta.notebooks.git).*" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "< [Side Chain Conformations and Dunbrack Energies](http://nbviewer.jupyter.org/github/RosettaCommons/PyRosetta.notebooks/blob/master/notebooks/06.01-Side-Chain-Conformations-and-Dunbrack-Energies.ipynb) | [Contents](toc.ipynb) | [Index](index.ipynb) | [Protein Design with a Resfile and FastRelax](http://nbviewer.jupyter.org/github/RosettaCommons/PyRosetta.notebooks/blob/master/notebooks/06.03-Design-with-a-resfile-and-relax.ipynb) >

\"Open" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Packing and Relax\n", "Keywords: PackRotamersMover, FastRelax, MoveMapFactory, cartesian, ResidueSelector, NeighborhoodResidueSelector, CDRResidueSelector, TaskFactory, TaskOperation, InitializeFromCommandline, RestrictToRepacking, PreventRepackingRLT, OperateOnResidueSubsetOperation, SimpleMetric, SequenceMetric, clone()\n", "\n", "## Overview\n", "Here, you will learn how to optimize the side-chains of a protein. In Rosetta, we call this `packing`. We will use TaskFactories to control which residues are optimized. We will use this knowledge to refine a specific region of a protein. In the next workshop, we will use what we learned here to begin designing proteins." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "!pip install pyrosettacolabsetup\n", "import pyrosettacolabsetup; pyrosettacolabsetup.install_pyrosetta()\n", "import pyrosetta; pyrosetta.init()\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Make sure you are in the directory with the pdb files:**\n", "\n", "`cd google_drive/MyDrive/student-notebooks/`" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Imports\n", "\n", "Before we begin, we must import some specific machinery from Rosetta. Much of these tools are automatically imported when we do `from pyrosetta import *`, however, some are not. You should get into the habit of importing everything you need. This will get you comfortable with the organization of Rosetta and make it easier to find tools that are beyond the scope of these workshops." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#Python\n", "from pyrosetta import *\n", "from pyrosetta.rosetta import *\n", "from pyrosetta.teaching import *\n", "\n", "#Core Includes\n", "from rosetta.core.kinematics import MoveMap\n", "from rosetta.core.kinematics import FoldTree\n", "from rosetta.core.pack.task import TaskFactory\n", "from rosetta.core.pack.task import operation\n", "from rosetta.core.simple_metrics import metrics\n", "from rosetta.core.select import residue_selector as selections\n", "from rosetta.core import select\n", "from rosetta.core.select.movemap import *\n", "\n", "#Protocol Includes\n", "from rosetta.protocols import minimization_packing as pack_min\n", "from rosetta.protocols import relax as rel\n", "from rosetta.protocols.antibody.residue_selector import CDRResidueSelector\n", "from rosetta.protocols.antibody import *\n", "from rosetta.protocols.loops import *\n", "from rosetta.protocols.relax import FastRelax\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Intitlialization \n", "\n", "Here, we will use command-line options to set the relax rounds to 2 instead of default 5 for speed of demo. This is a bit tricky to do in code.\n", "We also set the input antibody numbering scheme so that Rosetta understands the nomenclature of our antibody. \n", "\n", "\n", "Note that typically, we would add these options: `-ex1` and `-ex2` in order to increase the amount of rotamers\n", " available for packing, but this will slow us down for the demo, so we are keeping this out." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "init('-use_input_sc -input_ab_scheme AHo_Scheme -ignore_unrecognized_res \\\n", " -ignore_zero_occupancy false -load_PDB_components false -relax:default_repeats 2 -no_fconfig')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Import and copy pose\n", "\n", "Begin by importing a pose. Here, we are going to use an antibody from the PDB. \n", "Note that we use the clone function to copy the pose into `original_pose`. Using the equal sign will only make what is known as a shallow copy in python and anything we do to pose will be seen in original_pose. The clone operation copies all the data into the original_pose and is the Rosetta equivalent of the python module, `copy.deep_copy`. " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#Import a pose\n", "pose = pose_from_pdb(\"inputs/2r0l_1_1.pdb\")\n", "original_pose = pose.clone()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Setup a Normal TaskFactory\n", "\n", "A `TaskFactory` is what we use to control packing specific residues in a pose. We first pass InitializeFromCommandLine which uses any of the options specified in the `pyrosetta.init()` function.\n", "\n", "The `TaskFactory` is made up of a list of `TaskOperations`. These Taskops make up the bread and butter of controlling packing (and subsequently design). The taskops can be given to factory in any order. \n", "\n", "In Rosetta, ALL residues are set to both pack AND design by default. We use taskops to turn things off, like creating an ice sculpture. Here, we turn design off by using the `RestrictToRepacking` operation." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "tf = TaskFactory()\n", "tf.push_back(operation.InitializeFromCommandline())\n", "tf.push_back(operation.RestrictToRepacking())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Setup The Packer\n", "\n", "Here, we setup the packer and pass the TaskFactory to it. In general, if something can be packed, it will accept a TaskFactory. Every time the protein is packed for a single round, the TaskFactory will generate what is called the PackerTask. This object has all of the instructions needed for Rosetta to do packing and design. Some TaskOperations can respond to environmental changes in the pose, such as neighboring residues and dynamically change at each packing step. This is one of the reasons we use the TaskFactory machinery to setup packing instead of hacking the PackerTask itself as has been done in some of the earlier tutorials you may see on the web. " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "packer = pack_min.PackRotamersMover()\n", "packer.task_factory(tf)\n", "\n", "#Note that we are not passing a scorefunction here. We will use the default, cmd-line scorefunction, \n", "# which is accessed through rosetta.core.scoring.get_score_function() and part of the packer. We use use a scorefunction later. \n", "\n", "#Run the packer. (Note this may take a few minutes)\n", "#Skip for tests\n", "if not os.getenv(\"DEBUG\"):\n", " packer.apply(pose)\n", "\n", "#Dump the PDB\n", "pose.dump_pdb('/outputs/2r0l_all_repack.pdb')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Lets compare the energies of the before and after pose. Any difference?" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\n", "scorefxn = get_score_function()\n", "before = scorefxn.score(original_pose)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Check the sequence of the pose and the original pose using either the `SequenceMetric` \n", " `rosetta.core.simple_metrics.metrics.SequenceMetric` (and it's calculate function) OR directly using the pose's `.sequence()` function. \n", " Make sure that the poses have the same sequence - as packing is just design using single residue rotamers." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "deletable": false, "nbgrader": { "cell_type": "code", "checksum": "7b4dddbe4b5e491982f0bfbea220172a", "grade": true, "grade_id": "cell-cec829da5f2ee5f9", "locked": false, "points": 0, "schema_version": 3, "solution": true } }, "outputs": [], "source": [ "YOUR-CODE-HERE" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Regional Packing\n", "\n", "Lets pack just a single CDR loop. How do we do this? Use a `TaskFactory` and a `TaskOperation`. \n", " To make things easier, we will use a `ResidueSelector` to select the CDR. You will see more of this later.\n", " Briefly, a ResidueSelector returns a boolean vector that is the length of the pose. Each boolean is an indication of whether the residue was selected or not. Because the vector is the same length of the pose, the index is the residue number. There are many `ResidueSelectors` in rosetta, including ones for `AND` and `OR` operations to combine them. Note where most of them come from above: `from rosetta.core.select import residue_selector as selections`\n", "\n", "### Make selection using the CDRResidueSelector and NeighborhoodResidueSelector\n", "\n", "We will use the NeighborhoodResidueSelector to pack the CDR loop and its surrounding neighbors, which defaults to 6 angstrums. Each time we pack, the TaskFactory will be used to generate packing instructions (`PackerTask`) - and subsequently, the neighbors that we are packing will be updated each time to reflect this changing state of the pose." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "nbr_selector = selections.NeighborhoodResidueSelector()\n", "cdr_selector = CDRResidueSelector()\n", "cdr_selector.set_cdr(h1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note that h1 is what is called an enum. It is a named integer. This is better than passing around strings, \n", " and you will start to see many of these around Rosetta. They were imported when we imported the antibody namespace at \n", " the top of this workshop. Score terms such as fa_dun are also enums." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "nbr_selector.set_focus_selector(cdr_selector)\n", "nbr_selector.set_include_focus_in_subset(True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Restrict to our selection\n", "\n", "Lets turn off packing for everything but the H1 loop and its neighbors. By using a TF, every time packing is done,\n", " we regenerate the neighbors. Using the NeighborhoodResidueSelector we actually use the pose energies object that\n", " has a list of neighbors instead of doing an N by N calculation each time!\n", " \n", "In order to do this, we create what is known as a Residue Level Task Operation, or RLT, and then pass that into the `OperateOnResidueSubset`. Use your tab completion to see how many RLTs there are." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "prevent_repacking_rlt = operation.PreventRepackingRLT()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#True indicates here that we are flipping the selection. So that we are turning off everything but the CDR and\n", "# its neighbors.\n", "\n", "prevent_subset_repacking = operation.OperateOnResidueSubset(prevent_repacking_rlt, nbr_selector, True )\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Lets check to see what residues have been selected as the CDR, and then the CDR and its neighbors. We will use this to make sure our PackerTask is setup properly" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "cdr_res = []\n", "print(\"CDR\")\n", "for i in select.get_residue_set_from_subset(cdr_selector.apply(pose)):\n", " print(i)\n", " cdr_res.append(i)\n", " \n", "print(\"\\nCDR+Neighbors\")\n", "for i in select.get_residue_set_from_subset(nbr_selector.apply(pose)):\n", " if i in cdr_res:\n", " print(i,\"CDR\")\n", " else:\n", " print(i)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Reset the pose" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\n", "pose = original_pose.clone()\n", "\n", "tf.push_back(prevent_subset_repacking)\n", "\n", "pack_cdrs_and_neighbors_tf = tf.clone()\n", "\n", "packer.task_factory(tf)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Before we start, lets take a look at our PackerTask. Are we designing anything? Does this match our selection?" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(tf.create_task_and_apply_taskoperations(pose))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now lets Run the packer and dump the PDB.\n", "\n", "Note how many rotamers were used and how many positions were done. Now run it again. Have those numbers changed?\n", " Why?" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "deletable": false, "nbgrader": { "cell_type": "code", "checksum": "cd23a3d657e0c8ba13e16dfb228fd1ee", "grade": true, "grade_id": "cell-08b16c378d66130f", "locked": false, "points": 0, "schema_version": 3, "solution": true } }, "outputs": [], "source": [ "YOUR-CODE-HERE" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Design\n", "\n", "Lets design this CDR. We already almost everything we need created, so lets do this!!\n", "\n", "Note, since we added the RestrictToRepacking TaskOperation to our original `TaskFactory`, we need to reset (clear) it. " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\n", "pose = original_pose.clone()\n", "\n", "tf.clear()\n", "tf.push_back(operation.InitializeFromCommandline())\n", "tf.push_back(prevent_subset_repacking)\n", "\n", "#Turn off design of neighbors\n", "nbr_selector2 = selections.NeighborhoodResidueSelector()\n", "nbr_selector2.set_focus_selector(cdr_selector)\n", "nbr_selector2.set_include_focus_in_subset(False)\n", "\n", "restrict_to_repack = operation.RestrictToRepackingRLT()\n", "prevent_nbr_design = operation.OperateOnResidueSubset(restrict_to_repack, nbr_selector2, False )\n", "tf.push_back(prevent_nbr_design)\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Once again, lets check to make sure we have created the correct TaskFactory. You should now see that the CDRs we selected are set to design into any of the amino acids. " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(tf.create_task_and_apply_taskoperations(pose))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Set and Run\n", "\n", "Set the new tf to the packer and run it. This will take a few minutes as for each CDR we packing rotamers for all 20 amino acids instead of just the native residue. Take note of how many rotamers are built compared to when we didn't do any design.\n", "\n", "Dump the PDB and take a look. " ] }, { "cell_type": "code", "execution_count": null, "metadata": { "deletable": false, "nbgrader": { "cell_type": "code", "checksum": "c6cb7fdb29bd0c1468a03131bbfe227b", "grade": true, "grade_id": "cell-b968c1e06844bc48", "locked": false, "points": 0, "schema_version": 3, "solution": true } }, "outputs": [], "source": [ "YOUR-CODE-HERE" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Relax\n", "\n", "Lets first relax the whole protein. This will take some time, so after you run it, take a break and stretch! As usual, you can find the output in the `expected_outputs` directory of this directory.\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\n", "pose = original_pose.clone()\n", "fr = FastRelax()\n", "\n", "#Here, we have to set a scorefunction or we segfault. \n", "# Error checking is important, and protocols should use a default scorefunction. We will manage.\n", "\n", "fr.set_scorefxn(scorefxn)\n", "\n", "#Lets run this. This takes a very long time, so we are going decrease the amount of minimization cycles we use.\n", "# This is generally only recommended for cartesian, but we just want everything to run fast at the moment.\n", "fr.max_iter(100)\n", "\n", "#Run the code\n", "\n", "#Dump the pdb and take a look." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "deletable": false, "nbgrader": { "cell_type": "code", "checksum": "ee81fc22169ad91355329b70f0eb910e", "grade": true, "grade_id": "cell-f24a49a10fcb07cf", "locked": false, "points": 0, "schema_version": 3, "solution": true } }, "outputs": [], "source": [ "YOUR-CODE-HERE" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Check the energy difference here once again. Note how low it is compared to simply packing\n", "\n", "delta = ?" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "deletable": false, "nbgrader": { "cell_type": "code", "checksum": "cdb67033df62cc4077690557f81a85fa", "grade": true, "grade_id": "cell-6ba91002ffac69a7", "locked": false, "points": 0, "schema_version": 3, "solution": true } }, "outputs": [], "source": [ "YOUR-CODE-HERE" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Regional Relax\n", "\n", "So that was fun, but what we really want is to optimize regions of the protein that we care about. \n", " This can be tricky, so to start off, lets do the basic thing and see what happens. \n", " \n", "We will use a `MoveMapFactory`, which allows us to use `ResidueSelectors`. \n", "More information on the `MoveMapFactory` in terms of RosettaScripts, can be found here: https://www.rosettacommons.org/docs/latest/scripting_documentation/RosettaScripts/MoveMapFactories/MoveMapFactories-RosettaScripts\n", "\n", "The default is to have everything OFF first, and turn specific things on." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\n", "pose = original_pose.clone()\n", "mmf = MoveMapFactory()\n", "\n", "#mm_enable and mm_disable are Enums (numbered variables) that come when we import the MMF\n", "mmf.add_bb_action(mm_enable, cdr_selector)\n", "#mmf.add_chi_action(mm_enable, cdr_selector) We are taking this out for speed.\n", "\n", "mm = mmf.create_movemap_from_pose(pose)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Lets take a look at our `MoveMap` that the `MoveMapFactory` creates. Pass the movemap to `print()` We should only have a few residues there.\n", "\n", "Here, we only want to pack the region and neighbors. NOT all 500 residues!\n", "\n", "Lets use the cloned TaskFactory we used to repack the CDRs and neighbors, since we will be allowing the backbone of the CDRs to move." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "fr.set_movemap_factory(mmf)\n", "fr.set_task_factory(pack_cdrs_and_neighbors_tf)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Run this, take a break and then lets see the results.\n", "Dump the pose and take a look at it. " ] }, { "cell_type": "code", "execution_count": null, "metadata": { "deletable": false, "nbgrader": { "cell_type": "code", "checksum": "2ac231008d839acd2245597daf2c5572", "grade": true, "grade_id": "cell-897997d6124746e0", "locked": false, "points": 0, "schema_version": 3, "solution": true } }, "outputs": [], "source": [ "YOUR-CODE-HERE" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**What is wrong with this Pose???**\n", "\n", "\n", "Okay, so we know whats wrong here, right? Right?\n", "The pose is moving too much where we don't want it. This is due to the FoldTree\n", " There are two fixes for this - modify the foldtree (using a Loop foldtree as you will see in later tutorials) or use cartesian-space refinement. \n", " \n", " Lets do the easier of the two - cartesian!\n", " \n", " ### Regional Relax - Cartesian" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\n", "pose = original_pose.clone()\n", "cart_sf = create_score_function(\"ref2015_cart\")\n", "mmf.set_cartesian(True)\n", "fr.set_movemap_factory(mmf)\n", "fr.set_scorefxn(cart_sf)\n", "fr.cartesian(True)\n", "\n", "#This is a general recommendation for cartesian minimization - it lowers the number of maximum cycles.\n", "# More than this only increases time of protocol, but has little effect on energies/structure\n", "fr.max_iter(200)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Run relax Lets dump the pose and take a look again. Does this look better? How are the energies?" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "deletable": false, "nbgrader": { "cell_type": "code", "checksum": "74165b82e9e4c96e7323d829055d2a27", "grade": true, "grade_id": "cell-f2b1c60beff8a6d8", "locked": false, "points": 0, "schema_version": 3, "solution": true } }, "outputs": [], "source": [ "YOUR-CODE-HERE" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Regional Relax - Classic\n", "\n", "Now lets do the the classic way. Were going to take advantage of the fact that we have an Antibody here.\n", "\n", "We need to create our FoldTree and apply it to our pose before we minimize. We are going to make an AntibodyInfo object that will allow us to do this easier. Otherwise, we need to know the starting/end points of the CDR loop we are interested in. If you are interested in Antibodies, there is an Antibody Workshop later as well that will use some of the tools you have learned here. \n", "\n", "We will also use the function `fold_tree_from_loops` that is part of the loop modeling framework - also covered in later workshops. Rosetta can be difficult for sure, but the ability to use all of the different libraries in Rosetta can be a powerful tool. " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ " \n", "pose = original_pose.clone()\n", "\n", "ab_info = AntibodyInfo(pose)\n", "ft = FoldTree()\n", "\n", "\n", "start = ab_info.get_CDR_start(h1, pose)\n", "stop = ab_info.get_CDR_end(h1, pose)\n", "cutpoint = int((stop-start)/2) + start\n", "cdr_loop = Loop(start, stop, cutpoint)\n", "cdr_loops = Loops()\n", "cdr_loops.add_loop(cdr_loop)\n", " \n", "fold_tree_from_loops(pose, cdr_loops, ft)\n", "pose.fold_tree(ft)\n", "original_ft = pose.fold_tree()\n", "add_cutpoint_variants(pose)\n", "\n", "#Add chainbreak term so we don't get wacky stuff. This term helps keep the peptide closed during bb movement.\n", "scorefxn_ch = scorefxn\n", "scorefxn_ch.set_weight(rosetta.core.scoring.chainbreak, 100)\n", "\n", "#Setup our FastRelax again for dihedral-space.\n", "\n", "mmf.set_cartesian(False)\n", "fr.set_scorefxn(scorefxn_ch)\n", "fr.cartesian(False)\n", "fr.set_movemap_factory(mmf)\n", "fr.max_iter(0) #Reset to default - if its 0, then we don't set it in the MinMover that FastRelax runs\n", "\n", "#Run relax here\n", "\n", "#Skip for tests\n", "if not os.getenv(\"DEBUG\"):\n", " fr.apply(pose)\n", "\n", "#Reapply the original fold tree\n", "pose.fold_tree(original_ft)\n", "\n", "pose.dump_pdb('outputs/2r0l_dih_rel_H1.pdb')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "How does the pose look? Better/worse than cartesian? No difference? How do the energies compare? Which is more general? \n", "\n", "## Conclusions\n", "\n", "That should get you started with packing/relax! We even covered some advanced topics you will see later this week such as the TaskFactory and Residue Selectors!\n", "\n", "Onto the next one!" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "< [Side Chain Conformations and Dunbrack Energies](http://nbviewer.jupyter.org/github/RosettaCommons/PyRosetta.notebooks/blob/master/notebooks/06.01-Side-Chain-Conformations-and-Dunbrack-Energies.ipynb) | [Contents](toc.ipynb) | [Index](index.ipynb) | [Protein Design with a Resfile and FastRelax](http://nbviewer.jupyter.org/github/RosettaCommons/PyRosetta.notebooks/blob/master/notebooks/06.03-Design-with-a-resfile-and-relax.ipynb) >

\"Open" ] } ], "metadata": { "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.7.6" }, "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": {}, "toc_section_display": true, "toc_window_display": true } }, "nbformat": 4, "nbformat_minor": 1 }