Protein Design

Bold text means that these files and/or this information is provided.

Italicized text means that this material will NOT be conducted during the workshop

fixed with text means you should type the command into your terminal

If you want to try making files that already exist (e.g., input files), write them to a different directory! (mkdir my_dir)

Introduction

Objective: In this exercise, we will examine the Rosetta design features by mutating user-specified residues. The membrane protein we will be using is a homo-dimer, so we will employ RosettaMembrane and RosettaSymmetry to model the dimer during design. RosettaScripts will be used to combine the two applications.

Rosetta Applications: RosettaDesign, RosettaMembrane, RosettaSymmetry, RosettaScripts

Input and Analysis Scripts: clean_pdb.py, get_fasta_from_pdb.py

Tutorial

Preparation: Locate the necessary input PDB file.

    cd ~/rosetta_workshop/tutorials/protein_design

Included in this folder is a PDB file downloaded from the Protein Data Bank (www.rcsb.org ID:3UKM). Open this in pymol to familiarize yourself with the structure:

    pymol 3UKM.pdb         

You should notice that this file shows two homo-dimers. We will focus on the dimer made from Chains A and B (lower dimer when loaded). This will be important when setting up the symmetry definition file in the next step. Close pymol and proceed to step 1.

1. Setting up the symmetric PDB

   1. Rosetta Symmetry. In this step, we will create the proper symmetry definition file for this particular protein structure. We will need the input structure from the preparation step.

      cd Step1_symm
      
      cp ../3UKM.pdb .

      (this copies the pdb file to the Step1 directory)

      Next, we will use a perl script in Rosetta to generate a symmetry file from the input crystal structure. First, if you'd like to display the current options for this script, simply enter:

      ~/rosetta_workshop/Rosetta/main/source/src/apps/public/symmetry/make_symmdef_file.pl

      Next, we will use non-crystallographic mode (NCS), Chain A as the reference, Chain B as an interacting chain, and include the input structure. The output will be redirected, using the greater than sign, into a new file called 3UKM.symm.

      ~/rosetta_workshop/Rosetta/main/source/src/apps/public/symmetry/make_symmdef_file.pl \
      -m NCS -a A -i B -p 3UKM.pdb > 3UKM.symm

      The perl script will generate a couple of outputs:

      • 3UKM_INPUT.pdb = chain A
      • 3UKM.kin
      • 3UKM_model_AB.pdb = model generated to show subunit interactions with the input
      • 3UKM_symm.pdb = model generated to show the full point group symmetry
      • 3UKM.symm = symmetry definition file that you just created

      Examine symmetry file equation. gedit 3UKM.symm

      Does this make sense? Refer to the slide in the Tutorial Overview section entitled Rosetta Symmetry Definition File. This will explain the sections that make up the symm file.

   2. Next, we will use clean_pdb.py to prepare the input protomer for setting up symmetry.

      ~/rosetta_workshop/Rosetta/tools/protein_tools/scripts/clean_pdb.py 3UKM A

      clean_pdb.py strips PDB code that Rosetta can not parse such as comments, anisotropic atom positions, unnatural amino acid types, and waters. The first argument in the script is the 4-letter PDB code and the second argument is a string containing the chains to return, in this case, only chain A.

   3. Now, we will use the clean input structure to test the symmetry definition file. We will accomplish this through a very basic use of RosettaScripts. While still in the same directory:

      gedit setup_symm.xml

      And look at the contents of the file, which should look like this:

      <ROSETTASCRIPTS>
          <SCOREFXNS>
          </SCOREFXNS>
          <TASKOPERATIONS>
          </TASKOPERATIONS>
          <FILTERS>
          </FILTERS>
          <MOVERS>
            <SetupForSymmetry name="setup_symm" definition="3UKM.symm" />
          </MOVERS>
          <APPLY_TO_POSE>
          </APPLY_TO_POSE>
          <PROTOCOLS>
            <Add mover_name="setup_symm" />
          </PROTOCOLS>
      </ROSETTASCRIPTS>

      Next, run this protocol using RosettaScripts. We applied the setup_symm protocol to the input structure, 3UKM_A.pdb.

      ~/rosetta_workshop/Rosetta/main/source/bin/rosetta_scripts.default.linuxgccrelease \
      -parser:protocol setup_symm.xml -s 3UKM_A.pdb -out:prefix setupsymm_ \
      -database ~/rosetta_workshop/Rosetta/main/database

      When Rosetta is finished, examine the output structure using pymol:

      pymol setupsymm_3UKM_A_0001.pdb

      Does the resulting structure look as you would expect? Sometimes you have to make manual adjustments to the symmetry definition file by paying careful attention to the jumps. In this case, it looks great. Before we move forward, examine the score file generated from setting up symmetry:

      gedit setupsymm_score.sc

      The total energy score of the protein is the first number. For this protein, you will probably see a number in the positive 5000s. We know that this is not a good score for a protein. Before moving on to an application such as design, it is recommended to energetically minimize the structure in some way to get rid of imperfections in the crystal structure.

      Additionally, this score is based on the default Rosetta scoring function. We will need to create a span file and add the membrane high resolution scoring function into our XML script.

   4. We need to create a span file which will tell Rosetta where the membrane-spanning region is on our protein. Step 1.2 output a fasta file.

      cat 3UKM_A.fasta

      In a web browser, go to octopus.cbr.su.se and paste the fasta sequence into the form. Then click "Submit OCTOPUS" (There is also an option to use SPOCTOPUS which considers signal peptide sequences).

      When it's done running, near the top it will say "A text version of the topology prediciton can be found in the OCTOPUS topology file (txt)" click on that link.

      Select all of the text and copy.

      gedit 3UKM.topo 

      paste the text into this file and save.

      A script in Rosetta will take this topo file named 3UKM.topo and create a span file named 3UKM.span:

      ~/rosetta_workshop/Rosetta/main/source/src/apps/public/membrane_abinitio/octopus2span.pl \
      3UKM.topo > 3UKM.span

2. Energy minimization of the starting structure (See Appendix).

   Relax is a common protocol used in Rosetta to minimize protein structures. Unfortunately, we will not have enough time today to generate several relaxed structures. More information on how a relax step may be set up can be found in the appendix for this protocol. Typically, 100 relax models is sufficient to find a low-energy structure.

   I have provided output for this step in the Step2_relax directory. I have also described the methods to use for analysis of relaxed structures.

3. Prepare files for protein design at user-specified residues.

   1. With an energy minimized input structure, we are almost ready to design our protein! In this step, we will first combine SetupForSymmetry and SymPackRotamers movers in another RosettaScripts protocol.

      cd ../Step3_design
      ls

      You should see several input files ready for you to use. Here you will find the symmetry definition file, an energy minimized input structure named chA_relax_3UKM.pdb, and an XML file.

      gedit symm_design.xml

      Here I have provided the required XML file to complete this task:

      <ROSETTASCRIPTS>
          <SCOREFXNS>
            <mem_highres weights="membrane_highres_Menv_smooth.wts" symmetric="1" />
          </SCOREFXNS>
          <TASKOPERATIONS>
            <InitializeFromCommandline name="ifcl"/>
          </TASKOPERATIONS>
          <FILTERS>
          </FILTERS>
          <MOVERS>
            <SetupForSymmetry name="setup_symm" definition="3UKM.symm" />
            <SymPackRotamersMover name="sym_pack" scorefxn="mem_highres" task_operations="ifcl"/>
          </MOVERS>
          <APPLY_TO_POSE>
          </APPLY_TO_POSE>
          <PROTOCOLS>
            <Add mover_name="setup_symm" />
            <Add mover_name="sym_pack" />
          </PROTOCOLS>
      </ROSETTASCRIPTS>

      Notice under SCOREFXN, the membrane high-resolution weights are specified. Read the XML and see if you understand the different sections. Reference the lecture slides if you need to. Exit out of the file when you are done.

      ~/rosetta_workshop/Rosetta/main/source/bin/rosetta_scripts.default.linuxgccrelease \
      -parser:protocol symm_design.xml -s chA_relax_3UKM.pdb -in:file:spanfile 3UKM.span \
      -membrane:no_interpolate_Mpair -membrane:Membed_init -membrane:Menv_penalties \
      -score:weights membrane_highres_Menv_smooth.wts -out:prefix full_design_ \
      -database ~/rosetta_workshop/Rosetta/main/database/ -nstruct 1

      In the interest of time, we will only do one full design of the protein. In the output folder, I have included 10 output structures.

   2. Now we will run design again, but this time guide design with a resfile. A resfile is a file that is read by RosettaScripts during design. The file specifies a residue number, chain ID, and a command associated with the particular residue. This command alerts the packer with how to deal with the residue. (see slides on resfile for more examples)

      Design is done on a fixed backbone. Today we will use a hypothetical situation where a number of residues will be simply re-packed (minimized side-chains) by the command NATAA. A small number of residues will have a specific group of amino acids to chose from during design, and two residues will consider all amino acid rotamers during design.

      gedit design.resfile

      The resfile should resemble this:

      NATAA
      start
      
      29 A ALLAA
      30 A PIKAA P
      31 A ALLAA
      39 A PIKAA LIY
      46 A PIKAA FL   
      52 A PIKAA C 
      58 A PIKAA L
      61 A PIKAA FLI
      62 A APOLAR 
      65 A PIKAA VI
      66 A PIKAA LVS
      67 A POLAR
      68 A PIKAA A
      69 A APOLAR  
      70 A PIKAA NRG
      72 A PIKAA G
      94 A PIKAA TI
      95 A PIKAA TIV
      96 A PIKAA G 
      97 A PIKAA YFL
      98 A PIKAA G
      99 A PIKAA HNYD

      Based on sequence alignments from homologous proteins, we know that these positions prefer a certain type of amino acid. We are going to use a resfile to guide Rosetta during design. Look at your lecture slides and understand which amino acid rotamers will be allowed at each position. When you are comfortable with the format, exit the file. If you have questions about what you would expect-ASK!

      Now, we will create an XML file that will read in the resfile. First, copy the current XML file and rename it symm_res_design.xml

      cp symm_design.xml symm_res_design.xml
      gedit symm_res_design.xml

      Next, find the section labeled TASKOPERATIONS. Insert this task operation underneath the <TASKOPERATION> line, and before the </TASKOPERATIONS> line:

       <ReadResfile name="rrf" filename= "3UKM.resfile" />

      Notice, we gave this task the name "rrf". Find the SymPackRotamersMover under and add "rrf" after the task operations tag so it resembles this:

      <SymPackRotamersMover name="sym_pack" scorefxn="mem_highres" task_operations="ifcl,rrf"/>

   3. Design the protein at user-specified residues. We have a relaxed input structure, a symmetry definition file, a resfile to direct design, and an XML protocol to setup symmetry, and design according to a resfile. We are now ready to move forward with design!

      ~/rosetta_workshop/Rosetta/main/source/bin/rosetta_scripts.default.linuxgccrelease \
      -parser:protocol symm_res_design.xml -s chA_relax_3UKM.pdb -in:file:spanfile 3UKM.span \
      -membrane:no_interpolate_Mpair -membrane:Membed_init -membrane:Menv_penalties \
      -score:weights membrane_highres_Menv_smooth.wts -out:prefix design_ \
      -database ~/rosetta_workshop/Rosetta/main/database/ -nstruct 2

      Again, many, many more structures than just 2 should be made for production runs. In the interest of time, we will just run 2 for today. This step will simply ensure that you can successfully run Rosetta Symmetry and Design. Use the output structures provided in the Step3_design/output folder for the analysis step. Note that this folder contains only 10 models. In your own experiments, you will likely want to make more than just 10 models.

   4. Analysis of Designs. Now that we have a few design structures, we want to examine one of the regions we designed. First, we must sort the top five structures by score. You should still be in the Step3_design folder.

      cd ./output/resfile_design
      ls
      
      grep pose resfile_design*.pdb | sort -nk 23 | head -5

      This shows you the top 5 structures by best score. We can use awk to store the list of the top 5.

      grep pose resfile_design*.pdb | sort -nk 23 | head -5 | \
      awk '{print(substr($1,1,length($1)-5))}' > best.list

      Next, we will use awk to automate generating fastas for each of our top models.

      cat best.list |\
      awk '{system(\
      "python2.7 ~/rosetta_workshop/Rosetta/tools/protein_tools/scripts/get_fasta_from_pdb.py \
      "$1" A "substr($1,1,length($1)-3)"fasta")}' 

      Now we can cat all of the fastas and use WebLogo to generate a figure to show our designed residues.

      cat *.fasta > all_fasta.txt 
      
      gedit all_fasta.txt

      (If you are running out of time, you can cd into ../Step4_analysis where the fastas of the top 5 models for each design experiment are included)

      Now, copy and paste the text into the WebLogo server weblogo.berkeley.edu/logo.cgi

      Under advanced logo options, choose Logo Range to be 57-73. Now Click Create Logo at the Bottom.

      If you need to, you can re-open the resfile you used in the design step to see if Rosetta Design did what you expected.

      For example: Residue 58 should be L, residue 61 could be F, L, or I, and residue 67 could be any polar residue.

      Since we have restricted design a lot, we expect to see single identities for these positions in this sequence logo.

      If you have enough time, you can go back and make a sequence logo over this same range for the full design output. Compare the logos. You should see quite a bit more variation in the full design sequence logo.

APPENDIX

1. This is the explanation for Step 2 (which we skipped in the tutorial session to reduce run-time). Please make sure you are in the Step2_relax folder. You can create relaxed structures in a similar way that we set up symmetry, using RosettaScripts:

    <ROSETTASCRIPTS>
    <SCOREFXNS>
      <mem_highres weights="membrane_highres_Menv_smooth.wts" symmetric=1 />
    </SCOREFXNS>
    <TASKOPERATIONS>
      <InitializeFromCommandline name=ifcl/>
      <RestrictToRepacking name=rtr />
    </TASKOPERATIONS>
    <FILTERS>
    </FILTERS>
    <MOVERS>
      <SetupForSymmetry name=setup_symm definition=3UKM.symm />
      <FastRelax name=fast_rlx scorefxn=mem_highres task_operations=ifcl,rtr />
    </MOVERS>
    <APPLY_TO_POSE>
    </APPLY_TO_POSE>
    <PROTOCOLS>
      <Add mover_name=setup_symm />
      <Add mover_name=fast_rlx />
    </PROTOCOLS>
    </ROSETTASCRIPTS>

Then, run using the command-line:

        ~/rosetta_workshop/Rosetta/main/source/bin/rosetta_scripts.default.linuxgccrelease \
        -parser:protocol symm_relax.xml -s 3UKM_A.pdb -in:file:spanfile 3UKM.span \
        -membrane:no_interpolate_Mpair -membrane:Membed_init -membrane:Menv_penalties \
        -score:weights membrane_highres_Menv_smooth.wts \
        -database ~/rosetta_workshop/Rosetta/main/database/ 

2. Analyze the output. There are a few ways of going about this. Some may look at just the best scoring models. Others calculate the RMSD of the relaxed models to the input structure and plot the Score vs. RMSD to find the best (lowest) scoring model that is most similar to the input structure.

A normal looking energy funnel

Ideally, the lowest scoring model would also have the lowest RMSD. This model should be used in all subsequent steps in redesign. Generally in design, we use an ensemble of structures accounting for the lowest cluster of RMSD’s and scores.

Last, a note for Protein Design Analysis. In future versions of Rosetta, a script named Deep_Analysis will be available as an alternative to the WebLogo server. It will be in tools/protein_tools/scripts/deep_analysis. There are many options such as using fastas or pdbs as your input. You can also pass a resfile to specify which regions you want to appear on the logo (instead of a single range).