Exercise 9: RosettaScripts and RosettaDiagrams Contents

Workshop in Computational Structural Biology (81855), Spring 2014
Exercise 9: RosettaScripts and RosettaDiagrams
In this exercise we will learn about the principle of combining different Rosetta components for our needs
through RosettaScripts. Then we will use RosettaDiagrams as a tool that allows to create RosettaScripts
code without the need of knowing how to write in XML syntax. For the RosettaScripts documentation, see
https://www.rosettacommons.org/docs/latest/RosettaScripts.html
Contents
Exercise 9: RosettaScripts and RosettaDiagrams
1
RosettaScripts logic
1
Changing the existing code
1
Scripting using RosettaDiagrams
2
RosettaScripts logic
All steps in a Rosetta simulation can be described as steps that change the protein (performed by objects
called movers) and steps that calculate values for different protein properties (performed by filters).
The calculated value can optionally be used to filter for models that fulfill certain conditions.
Practically all applications in Rosetta can be performed using RosettaScripts, with the additional option of
combining different procedures and changing default values. This comes in handy especially in cases
where we do not have flags that allow us to modify the run parameters through the command line. Without
RosettaScripts (and PyRosetta) the only option we would have would have been to write new source code
or to change Rosetta's existing code (as you have done for MyMinimize.cc in ex3), options that are more
complicated and sometimes risky.
Recall the docking procedure you performed in ex8. Now you will perform docking and refinement using
RosettaScripts.
Question 1: Under $CSBW_HOME/resources/ex9/ you can find dock_refine.xml. Open the file.
Under MOVERS you can see that a mover called "dock1" has been created. Name the different properties
this mover has and shortly explain what they mean.
Copy
the
cohesin-dockerin
complex
to
your
working
directory
(cp $CSBW_HOME/resources/ex9/coh-doc.pdb .), and run the XML code using the following
command:
$> rosetta_scripts.linuxgccrelease \
-database $ROSETTA_DB \
-s coh-doc.pdb \
-nstruct 15 \
-parser:protocol dock_refine.xml \
> RScripts.docking.log
Question 2: Who is your lowest scoring decoy? What is its score?
Changing the existing code
You will now change the protocol's post docking step of ddg calculation. As you remember from class,
DDG is a calculation of the change in energy upon mutation infliction. In RosettaScripts, this is performed
through filters, since the actual output pose does not change, so this DDG value becomes in a sense a
scoring term that can (but does not have to) be used in order to filter out undesired structures.
1
Take the existing lines that are relevant for DDG calculation and change them so that this filter will screen
out non-promising conformations, will use a threshold of -20, will do repacking but not repacking of the
bound structure and will repeat the DDG calculation 3 times. If you are not sure how to do this you may
use RosettaDiagrams, for which you have instructions below. Don't forget that all movers that can be used
in RosettaScripts are documented under the Filters section of the RosettaScripts documentation.
Question 3: What are the lines that need to be added in order to preform the DDG filtering? (write them in
your answer or copy the RosettaDiagrams output code lines that are relevant for this docking step).
Question 4: After making this change, run the application again. Look at the log file, which contains the
DDG information for different trials. How do the ddg values you got in this run compare to those from the
previous run?
Scripting using RosettaDiagrams
RosettaDiagrams is another layer of simplification. It was developed by Lior Zimmerman and can be
accessed through the RosettaDiagrams web page. This interface allows a user to graphically design a
Rosetta protocol work-flow and outputs the relevant XML code that is needed for running RosettaScripts
from the command line.
We will now use RosettaDiagrams to create the dock_refine.xml code from scratch. From the
Palette panel, under Movers, create a Docking mover, and set its properties to the values stated in the
XML code. Note that if you do not have the property you wish to fill in your panel you can
Add attribute and a new line will appear for you to fill in. Do the same for the MinMover and the
RotamerTrialsMinMover. Next, in the Palette panel, under Filters (at the bottom) create a DDG,
Sasa and Rmsd filters with the desired attributes. Finally, still in Palette, under TaskOperations
you'll find ProteinInterfaceDesign, RestrictToRepacking and InitializeFromCommandline. For each mover
cooperating with a task-operation, state the name of the TaskOperation under the mover's properties.
Now you can start the protocol: connect your docking mover to your RT-min mover, create two copies of
the RT-min mover and connect them too. Then continue in the following order: connect the minMover, ddg
filter, sasa and rms filters.
Question 5: Send with the exercise a picture of the RosettaDiagrams window (a simple print screen
should do the trick). Run this script (use -nstruct 10) and open the output files in PyMOL. Attach a ray
traced image of the alignment to the coh-doc.pdb file.
Now we will examine the changes that can easily be performed in the code. For comparison, think of the
required steps to change MyMinimize.cc in ex3 and the long compilation needed in order to apply the
change.
Question 6: What property should you change in order to minimize the structure with backbone flexibility?
Rerun the script after applying the change. How do the results compare to those from the last run?
Question 7: (Bonus) Change the docking protocol so that it would not only perform docking, but will also
design dockerin (i.e. chain b). What is/are the changes you made (note that you should avoid conflicting
instructions, so change all instructions related to design in the protocol)?
2

Download Report