Rosetta 3.3
Documentation for the FlexPepDock application
Author:
Barak Raveh, Nir London, Ora Schueler-Furman

Metadata

Last updated May 05, 2011 ; PI: Ora Schueler-Furman oraf@ekmd.huji.ac.il.

Code and Demo

References

The main references for the FlexPepDock Refinement protocol and the FlexPepDock ab-initio protocol include additional scientific background, in-depth technical details about the protocols, and large-scale assessment of their performance over a large dataset of peptide-protein complexes:

Refinement protocol:

Raveh B*, London N* and Schueler-Furman O
Sub-angstrom Modeling of Complexes between Flexible Peptides and Globular Proteins.
Proteins, 78(9):2029–2040 (2010).

ab-initio protocol:

Raveh B, London N, Zimmerman L and Schueler-Furman O
Rosetta FlexPepDockab-initio: Simultaneous Folding, Docking and Refinement of Peptides onto Their Receptors.
PLoS ONE, 6(4): e18934 (2011).

Purpose

A wide range of regulatory processes in the cell are mediated by flexible peptides that fold upon binding to globular proteins. The FlexPepDock Refinement protocol and the FlexPepDock ab-initio protocols are designed to create high-resolution models of complexes between flexible peptides and globular proteins. Both protocols were benchmarked over a large dataset of peptide-protein interactions, including challenging cases such as docking to unbound (free-form) receptor models (see References).

Refinement vs. ab-initio protocol:

Algorithm

Refinement protocol: The input to the protocol is an initial coarse model of the peptide-protein complex in PDB format (approximate backbone coordinates for peptide in the receptor binding site). Initial side-chain coordinates (such as the crystallographic side-chains of an unbound receptor) can be optionally provided as part of the input model. A preliminary step in the Refinement protocol involves the pre-packing of the input structure, to remove internal clashes in the protein monomer and the peptide (see prepack mode below). In the main part of the protocol, the peptide backbone and its rigid-body orientation are optimized relative to the receptor protein using the Monte-Carlo with Minimization approach, in addition to on-the-fly side-chain optimization. An optional low-resolution (centroid) pre-optimization may improve performance further. The main part of the protocol is repeated k times. The output models are then ranked by the user based on their energy score. The Refinement protocol is described in detail in the Methods section in Raveh, London et al., Proteins 2010 (see References).

ab-initio protocol: The input to the ab-initio protocol is: (1) A model of the peptide-protein complex in PDB format similar to the Refinement protocol, but starting from arbitrary (e.g., extended) peptide backbone conformation. It is required that the peptide is initially positioned in some proximity to the true binding pocket, but the exact starting orientation may vary. A preiminary step for the ab-initio protocol is the generation of fragment libraries for the peptide sequence, with 3-mer, 5-mer and 9-mer fragments (these can be generated automatically via a script from the starting structure, as shown in protocol_capture/FlexPepDock_AbInitio/ demo files). Another preliminary step is pre-packing, as in the Refinement protocol. The first step in the main part of the protocol involves a Monte-Carlo simulation for de-novo folding and docking of the peptide over the protein surface in low-resolution (centroid) mode, using a combination of fragment insertions, random backbone perturbations and rigid-body transformation moves. In the second step, the resulting low-resolution model is refined with FlexPepDock Refinement. As in the independent refinement protocol, the output models are then ranked by the used based on their energy score, or also subjected to clustering for improved performance. Our ab-initio protocol is described in detail in the Methods section in Raveh, London, Zimmerman et al., PLoS ONE 2011 (see References).

For more information, see the following tips about correct usage of FlexPepDock.

Modes

Input Files

FlexPepDock requires the following inputs:

Options

Note that the -flexpep_prepack and -flexPepDockingMinimizeOnly flags are mutually exclusive with respect to the -lowres_abinitio and -pep_refine, as they denote completely different modes of functionally (-pep_refine and -lowres_abinitio are commonly used together, for ab-initio peptide modeling followed by refinement).

I. Common FlexPepDock flags:

Flag Description Type Default
-receptor_chain chain-id of receptor protein String first chain in input
-peptide_chain chain-id of peptide protein String second chain in input
-lowres_abinitio Low-resolution ab-initio folding and docking model. String false
-pep_refine Refinement mode. (equivalent to obsolete -rbMCM -torsionsMCM flags) String false
-lowres_preoptimize Perform a preliminary round of centroid mode optimization before Refinement. See more details in Tips. Boolean false
-flexpep_prepack Prepacking mode. Optimize the side-chains of each monomer separately (without any docking). Boolean false
-flexpep_score_only Read in a complex, score it and output interface statistics Boolean false
-flexPepDockingMinimizeOnly Minimization mode. Perform only a short minimization of the input complex Boolean false
-ref_startstruct Alternative start structure for scoring statistics, instead of the original start structure (useful as reference for rescoring previous runs with the flexpep_score_only flag.) File N/A
-peptide_anchor Set the peptide anchor residue manually. It is recommended to override the default value only if one strongly suspects the critical region for peptide binding is extremely remote from its center of mass. Integer Residue nearest to the peptide center of mass.

II. Relevant Common Rosetta flags

More information on common Rosetta flags can be found in the relevant rosetta manual pages). In particular, flags related to the job-distributor (jd2), scoring function, constraint files and packing resfiles are identical to those in any other Rosetta protocol).

Flag Description
-in:file:s
Or
-in:file:silent
Specify starting structure (in:file:s for PDB format, in:file:silent for silent file format).
-in:file:silent_struct_type
-out:file:silent_struct_type
Format of silent file to be read in/out. For silent output, use the binary file type since other types may not support ideal form

-native

Specify the native structure for which to compare in RMSD calculations. This is a required flag. When the native is not given, the starting structure is used for reference.
-nstruct Number of models to create in the simulation
-unboundrot Add the position-sepcific rotamers of the specified structure to the rotamer library (usually used to include rotamers of unbound receptor)
-use_input_sc Include rotamer conformations from the input structure during side-chain repacking. Unlike the -unboundrot flag, not all rotamers from the input structure are added each time to the rotamer library, only those conformations accepted at the end of each round are kept and the remaining conformations are lost.
-ex1/-ex1aro -ex2/-ex2aro -ex3 -ex4 Adding extra side-chain rotamers (highly recommended). The -ex1 and -ex2aro flags were used in our own tests, and therefore are recommended as default values.
-database The Rosetta database
-frag3 / -frag5 / -frag9

3mer / 5mer / 9mer fragments files for ab-initio peptide docking (9mer fragments for peptides longer than 9).

III. Expert flags

	
Flag Description Type Default
-rep_ramp_cycles

The number of outer cycles for the protocol. In each cycle, the repulsive energy of Rosetta is gradually rampped up and the attractive energy is rampped down, before inner-cycles of Monte-Carlo with Minimiation (MCM) are applied.

Integer

10

-mcm_cycles

Number of inner-cycles for both rigid-body and torsion-angle Monte-Carlo with Minimization (MCM) procedures.

Integer 8
-smove_angle_range Defines the perturbations size of small/sheer moves. Real 6.0
-extend_peptide

start the protocol with the peptide in extended conformation (neglect original peptide conformation ; extend from the anchor residue)

Boolean false
-rbMCM Perform rigid body refinement by Monte-Carlo with Minimization (obsolete) Boolean false
-torsionsMCM Perform peptide backbone refinement by Monte-Carlo with Minimization (obsolete) Boolean false
-frag3/5/9_weight Relative weight of different fragment libraries in ab-initio fragment insertion cycles. Real 1.0 / 0.25 / 0.1

Tips

Examples

More tips

When you should / should not use FlexPepDock:

Expected Outputs

The output of a FlexPepDock run is a score file (score.sc by default) and k model structures (as specified by the -nstruct flag and the other common Rosetta input and output flags). The score of each model is the second column of the score file. Model selection should be made based on either the score or reweighted-score columns (which exhibited superior performance in the ab-initio benchmarks).

Interpretation of FlexPepDock-specific score terms: (for the common Rosetta scoring terms, please also see the relevant manual page).
	

total_score* Total score of the complex
reweighted_sc* Reweighted score of the complex, in which interface residues are given double weight, and peptide residues are given triple weight
I_bsa Buried surface area of the interface
I_hb Number of hydrogen bonds across the interface
I_pack Packing statistics of the interface
I_sc Interface score (sum over energy contributed by interface residues of both partners)
pep_sc Peptide score (sum over energy contributed by the peptide to the total score; consists of the internal peptide energy and the interface energy)
I_unsat Number of buried unsatisfied HB donors and acceptors at the interface.
rms (ALL/BB/CA)

RMSD between output model and the native structure, over all peptide (heavy/backbone/C-alpha) atoms

rms (ALL/BB/CA)_if RMSD between output model and the native structure, over all peptide interface (heavy/backbone/C-alpha) atoms
startRMS(all/bb/ca) RMSD between start and native structures, over all peptide (heavy/backbone/C-alpha) atoms

*For all interface terms, the interface residues are defined as those whose C-Beta atoms (C-Alpha for Glycines) are up to 8A away from any corresponding atom in the partner protein

Post Processing

Except for model selection by total score or reweighted score, and possibly clustering (see Tips section), no special post-processing steps are needed. For the ab-initio protocol, the protocol capture README file in protocol_capture/FlexPepDock_AbInitio/ contains all the information needed for clustering. However, advanced users may optionally use Rosetta Commands for the cluster application directly for assessing whether top-scoring models converge to a consensus solution. For FlexPepDock Refinement, clustering is an optional step, and is not considered an integral part of the Refinement protocol, as described and tested in Raveh et al.

 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines