CS-ROSETTA: System for chemical shifts based protein structure prediction using ROSETTA

Install.com	CS-ROSETTA installation C-shell script(last modified at 11/17/2009, version 1.01)
CSRosetta.tar.Z	CS-ROSETTA main package, scripts, examples (last modified at 11/17/2009, version 1.01)
PDBH.tar.Z	Database of PDB files, required by MFR/CS-ROSETTA
CS.tar.Z	Database of chemical shifts files, required by MFR/CS-ROSETTA
ANGLESS.tar.Z	Database of secondary structure classifications and ROSETTA-idealized backbone torsion angles, required by CS-ROSETTA
"Hybrid" database	New database (required for "hybrid" fragment selection method)
changeLog

Installation

The current implementation of CS-ROSETTA requires the MFR program to perform fragment selection and the ROSETTA program to conduct the protein structure prediction. Therefore, before installing and using the CS-ROSETTA package, the newest NMRPipe (incl. the MFR modules stored in dyn.tar.Z, mfr.tar.Z, pdbH.tar.Z) (http://spin.niddk.nih.gov/NMRPipe) and ROSETTA programs (http://www.rosettacommons.org/software/) MUST to be installed.

To install the ROSETTA2.x program, users need to (1) register for a license at http://www.rosettacommons.org/software/, (2) download (at least) the required packages (RosettaBundle-2.3.0.tgz and rosetta_fragments-2.3.0.tgz) to the installation directory (for example $ROSETTA_DIR), (3) uncompress RosettaBundle-2.3.0.tgz, all four generated sub-packages (with names of rosetta*.tgz) and rosetta_fragments-2.3.0.tgz, (4) go to the rosetta++ directory and type "make gcc" (for Linux installation) to compile the ROSETTA source codes. After successful compilation, an executable ROSETTA file with default name "rosetta.gcc" will be generated.

Use of the 'hybrid' fragment selection procedure requires a set of initial fragment candidates selected by the standard ROSETTA fragment selection procedure, which can be performed locally with a perl script make_fragments_2000.pl (modified from the script make_fragments.pl of the ROSETTA fragment package). To run this script, several other programs, such as PSI-BLAST, PSIPRED, JUFO, PROFphd and/or SAM, are required to be installed and properly configured. Please see here (ROSETTA website) for the details on how to properly install those required programs and use this script. (Note: a set of database files specifically prepared for the 'hybrid' fragment selection method are required and can be downloaded here)

Download all above files to the installation directory ($baseDir), type 'install.com' to start the installation. The correctly installed CS-ROSETTA program contains the following contents in the installation directory $baseDir:

./com	CS-ROSETTA scripts directory
Adjust_CS_Offset.com	Add an offset to a given type of chemical shift
bmrb2fasta.com	Generate a FASTA sequence file from a BMRB chemical shift file
bmrb2talos.com	Convert a BMRB chemical shift file to TALOS-format
correctCACB_D_effect.com	Apply deuteration effect corrections for 13CA and 13CB chemical shifts
cs2fasta.com	Generate a FASTA sequence file from the header of a TALOS chemical shift table file
csrosettaInit.com	CS-ROSETTA initialization script
extract_pdb.com	Generate PDB full-atom coordinates files from a ROSETTA(2.x) silent output file
extract_lowscore_decoys.py	Python script to extract N lowest energy models from a ROSETTA silent output file to a new silent output file
fasta2pdb.com	Generate a 'dummy'-PDB file from a FASTA sequence file, which is required by MFR as the reference structure
make_fragments_2000.pl	Generate 2000 initial ROSETTA fragments (used by runCSRjob_hybrid.com for a hybrid fragment selection module procedure; modified from the original script in the ROSETTA_fragment package)
mfr2rosetta.com	Convert a typical MFR-format fragment file to ROSETTA(2.x) format
mfr.tcl	Modified MFR starting script from the original 'mfr.tcl' in NMRPipe, required by CS-ROSETTA
mfr.com	Conduct MFR fragments search
paths.txt	Template of "paths.txt" file for ROSETTA
pdb2fasta.com	Generate a FASTA sequence file from a PDB file
pdbrms	Calculate CA-rmsd for a set of PDB coordinates
renumber_pdb.com	Renumber sequence number for a PDB coordinate file
rosetta2GDB.com	Convert a ROSETTA(2.x) fragment file to a generic table file
rosettaFrag2csFrag.com	Apply chemical shift scoring for a set of ROSETTA fragment candidates
runCSRjob.com	Run MFR fragment search and prepare inputs for the next step of ROSETTA(2.x) fragment assembly
runCSRjob_hybrid.com	Run fragment search using a hybrid method and prepare inputs for the next step of ROSETTA(2.x) fragment assembly
runRosetta.com	Template of ROSETTA(2.x) starting script
runCSRescore.com	Re-score ROSETTA (2.x) full-atom models using experimental chemical shifts
runRosettaRescore.com	Extract and rescore segments from ROSETTA(2.x) full-atom models
sparta	Starting script for program SPARTA
talos	Starting script for program TALOS (a 'fast' C++ version)
./PDBH	Directory of PDB coordinates database
./CS	Directory of SPARTA-assigned chemical shifts database
./ANGLESS	Directory of secondary structure classification and ROSETTA-idealized backbone torsion angles database
./src	Directory of supporting programs
SPARTA	Directory for the chemical shifts prediction program SPARTA
TALOS	Directory for the backbone torsion angle prediction program TALOS (a 'fast' C++ version)
mfr2rosetta	Directory for a C++ program to convert MFR-format fragments to ROSETTA-format
nnmake	Directory for a Fortran program to generate the initial ROSETTA fragment candidates (modified from the original program in the ROSETTA_fragment package)
pdbrms	Directory for a C++ program to calculate RMSD value between two sets of PDB coordinates
rosettaFrag2csFrag	Directory for a C++ program to calculate chemical shift score for a set of ROSETTA fragment candidates
./example	Directory of a complete example for protein GB3
./input/gb3.*	GB3 input experimental chemical shift table (.tab) and reference experimental structure (.pdb)
./output_hybrid/	All sample output files for GB3 CS-ROSETTA runs using the 'hybrid' fragment selection
./output_rosetta2/	All sample output files for GB3 CS-ROSETTA runs using the ROSETTA2.x
./output_rosetta3/	All sample output files for GB3 CS-ROSETTA runs using the ROSETTA3.x
./output_rosetta_FnD/	All sample output files for GB3 homodimer CS-ROSETTA runs using the ROSETTA2.3.0
runCSRtest.com	Script to test CS-ROSETTA installation

The initialization script csrosettaInit.com includes the definitions for all environmental variables required by CS-ROSETTA. Please check if the variables $rosettaDir and $csrosettaDir defined in csrosettaInit.com:

are correctly configured according to the ROSETTA and CS-ROSETTA installation directories.

In order to use the package, users MUST first execute the above initialization script, for instance by adding the following command to their .cshrc file:

If the package is installed successfully and environmental variables are set up correctly, the script in the example directory (examples/runCSRTest.com) should work successfully.

CS-ROSETTA utilizes the protein backbone 15N, 1HN, 1HA, 13CA, 13CB and 13C' chemical shifts as inputs to search a structural database for best matched fragments. The chemical shifts need to be in TALOS format, as defined at http://spin.niddk.nih.gov/NMRPipe/talos/#preparing shifts, and contain ONLY backbone 15N, 1HN, 1HA, 13C', 13CA and 13CB shifts. If starting from a standard BMRB format chemical shift file, a C-shell script $baseDir/com/brmb2talos.com can be used to generate a TALOS-format chemical shift file using:

Residues from the disordered tails and loops are identified from the input chemical shifts and the criteria in the paper:
(1) S2 < 0.7 from the RCI analysis, and
(2) no "good" predictions using the program TALOS

A RCI analysis can be performed from the RCI server or from running a TALOS+ analysis .

It is recommended to excluded positively identified flexible residues in the N- and C-terminal tails from the structure prediction by preparing a 'truncated' input chemical shift table file that excludes data (both sequence and chemical shifts) from those residues (Note that the rest residues must be re-numbered so that the 'truncated' sequence start from residue #1). For long flexible loops, it is advantageous to exclude all terms from the ROSETTA full-atom energy and the chemical shifts rescoring (see details in Evaluation of CS-ROSETTA models)

CS-ROSETTA has been designed to work in a black-box manner, and is supported by multiple C-shell/C++/python/perl scripts/programs. To use CS-ROSETTA for protein structure prediction, users can simply follow a three-step procedure:

The script runCSRjob.com is the master script to generate MFR fragment candidates. To use this script, an input chemical shift filename MUST be specified in a command line such as:

where $OUTPUT_DIR is the output directory of the fragments and scripts for running ROSETTA (or the ROSETTA running directory), $MFR_EXCL is the list of the proteins with homologous sequence and known structural homologs to the target protein, which (for test purpose) users may wish to exclude from the MFR structural database prior to MFR fragment searching, $PDB_NAME and $CHAIN are the 4-letter and 1-letter dummy names indicating the protein name and chain ID, respectively, $TAG is a 2-letter dummy tag (used by ROSETTA), $N_MODEL is the total number of models to be predicted.

The output of running this script will be the MFR-selected 9-residue and 3-residue fragment candidates (with file names of $OUTPUT_DIR/$TAG$PDB_NAME$CHAIN09_05.200_v1_3 and $OUTPUT_DIR/$TAG$PDB_NAME$CHAIN03_05.200_v1_3, respectively), a FASTA sequence file ($OUTPUT_DIR/$PDB_NAME$CHAIN.fasta), a ROSETTA paths definition file ($OUTPUT_DIR/paths.txt) and a script file ($OUTPUT_DIR/runRosetta.com) for starting ROSETTA structure generation.

It is recommended for users to read through and understand this script, which will facilitate use of the MFR program and other supporting scripts, and solve any problems during the MFR search (for example, by checking the intermediate and log files). This script (1) checks input chemical shifts and prepares input files for the MFR program, (2) performs the MFR fragment search, (3) converts the selected fragments to ROSETTA format and (4) prepares inputs and script for running ROSETTA structure generation. In detail:

The current MFR program in NMRPipe requires a TALOS format chemical shift table file as input (see Section of "Preparing of chemical shift table"). A pre-check step will be performed first to check for possible chemical shift referencing problems and chemical shift errors/outliers. The chemical shifts with identified referencing problem, for example a 2.7ppm referencing offset for the 13CA chemical shifts, can be corrected by using:

A "reference PDB" coordinate file is needed to provide the MFR program with the protein's amino acid sequence. For this purpose, runCSRjob.com creates a dummy "reference PDB" coordinate file from its FASTA sequence using:

The script runCSRjob.com then conducts a MFR fragment search following a command line of:

where $MFR_EXCL is a list of protein names (without .pdb suffix) that users like to exclude from the MFR structural database prior to the fragment search. MFR fragment selection from searching the structural database is a time-consuming job (1-3 hours); the 'log' file can be used to check the progress.

The MFR-selected 9-residues and 3-residues fragment candidates, generated after running the MFR fragment search, have file names frag9.$PDB_NAME.mfr.tab and frag3.$PDB_NAME.mfr.tab, respectively. Script mfr2rosetta.com can be utilized to convert these fragments to standard ROSETTA format:

runCSRjob.com generates at the last step a new directory (defined by variable $OUTPUT_DIR) and prepares the following required inputs and script for running ROSETTA fragment assembly and structure generation:

For proteins with incompleted/imperfect chemical shift assignments, a hybrid fragment selection method is recommended for selecting fragment candidates [click here to see the reference]. The script runCSRjob_hybrid.com is the master script to generate fragment candidates with the hybrid method. To use this script, an input chemical shift table file (in TALOS format) MUST be specified in a command line such as:

The following variables are hard-coded in this script analogous to those in the script runCSRjob.com.:

The output of running this script will be the 9-residue and 3-residue fragments (with file names of $OUTPUT_DIR/$TAG$PDB_NAME$CHAIN09_05.200_v1_3 and $OUTPUT_DIR/$TAG$PDB_NAME$CHAIN03_05.200_v1_3, respectively), a FASTA sequence file ($OUTPUT_DIR/$PDB_NAME$CHAIN.fasta), a ROSETTA paths definition file ($OUTPUT_DIR/paths.txt) and a script file ($OUTPUT_DIR/runRosetta.com) for starting ROSETTA structure generation.

This script (1) checks input chemical shifts, (2) performs a conventional ROSETTA fragment search for the initial fragment candidates, (3) performs a "MFR" fragment search for the final fragment candidates and (4) prepares inputs and script for running ROSETTA structure generation. In detail:

Similar to the script runCSRjob.com, a pre-check step will be performed first to check for the possible chemical shift referencing problems and chemical shift errors/outliers. A FASTA sequence file (with filename of t000_.fasta by default) will be generated for the next step.

The script runCSRjob_hybrid.com then conducts a "standard" ROSETTA fragment search following a command line of:

where make_fragments_2000.pl is a perl script to generate 2000 ROSETTA fragment candidates for each overlapped 3-residue and 9-residue target fragment. The output of running this command line will be two files: $TAG$PDB_NAME$CHAIN03_05.000_v1_3 and $TAG$PDB_NAME$CHAIN03_05.000_v1_3.

An option of "-nohoms" can be used in order to omit homologs (with a PSI-BLAST e-score < 0.05) from the search:

Note that running script make_fragments_2000.pl on the low profile computer may fail due to the requirement of massive memory space.

The script rosettaFrag2csFrag then will be used to calculate the chemical shift scores for the above initial fragment candidates:

where $FRAG9_FNAME is the filename of the initial ROSETTA fragment candidates, $inCS2.tab stands for the input secondary chemical shift table file prepared in step (1). The output of running this command line will be a new fragment candidate file $FRAG9_FNAME.csScore.tab containing a chemical shift score for each fragment candidate.

The final 200 fragment candidates with the best chemical shift scores are kept for each overlapped 3-residue and 9-residue target fragment.

Similar to the script runCSRjob.com, the script runCSRjob_hybrid.com generates at its last step a new directory (defined by variable $OUTPUT_DIR) and prepares the required inputs and script for running ROSETTA fragment assembly and structure generation.

The script runRosetta.com generated by running runCSRjob.com or runCSRjob_hybrid.com can be used to start the standard ROSETTA structure generation (fragment assembly and full-atom relaxation). This script includes solely a standard ROSETTA command line defining the inputs and parameters for fragment assembly and full-atom relaxation

where $TAG, $PDB_NAME, $CHAIN (variables for protein identities) and $N_MODEL (total number of predicted models) are automatically replaced by their values defined in the script runCSRjob.com.

Typing runRosetta.com in the working directory (where the files of the selected fragment candidates, FASTA sequence and paths.txt are stored) will start the standard ROSETTA structure prediction. The output of the ROSETTA run is a so-called silent output file with name $TAG$PDB_NAME.out, which includes the scores and full-atom descriptions for all accepted models.

The ROSETTA fragment assembly and relaxation procedure is computationally demanding (on the order of 5-10 minutes per model). Therefore, use of computer clusters is highly recommended. In order to run multiple ROSETTA jobs in parallel for a given project, users can simply run the same script runRosetta.com for each 'parallel' job in the same working directory; ROSETTA will output the results from each job to a single silent output file.

A ROSETTA silent output file $TAG$PDB_NAME.out contains a header in its first two lines (first line: the sequence information; second line: definition of scores and values), and for each model, a score line (which starts with "SCORE:") and the residue-specific description of this model. An example ROSETTA silent output file is shown below:

Before rescoring ROSETTA full-atom models using the experimental chemical shifts, it is recommended to extract the models with low ROSETTA energy and 'discard' the 'bad' models with high ROSETTA energy. This expedites further analysis and can be performed by a simple command line:

where the script extract_lowscore_decoys.py (courtesy of whip.bakerlab.org) is used to extract the N lowest-energy models (the energy of a model is defined as the first number in the SCORE line of a silent output file) from a silent file. The output is a new silent output file containing only the selected N lowest-energy models.

If residues in flexible loops are positively identified (e.g., by RCI analysis), the energy terms for those residues should be excluded from the ROSETTA full-atom energy. For this purpose, the energy of all models in a ROSETTA silent output file can be rescored by a script runRosettaRescore.com and a command line of:

where "ref.pdb" is a reference PDB coordinate file and required by standard ROSETTA "-extract_segment" module (the C-alpha RMSD values relative to this structure will also be calculated during the re-scoring; for instance, the full atom PDB coordinate file extracted from the lowest energy ROSETTA model can be used here; see "Full-atom PDB coordinates extraction"); "seg.txt" is a text file defining the segment for which ROSETTA will calculate the new full-atom energy. Here is an example of "seg.txt":

which tells ROSETTA that only residues 6-60, 80-89 and 120-130 are kept and used for calculating the new full-atom energy for all models; this file MUST locate in the current directory. The output is a new ROSETTA silent file with file name of $TAG$PDB_NAME_segment.out.

The script runCSrescore.com can be used to apply the chemical shift based "energy-rescoring" for all ROSETTA full-atom models, using the following command line:

where inCS.tab is the initial experimental chemical shift input file (the same input file used by the script runCSRjob.com for the fragment selection procedure). This script:

To rescore the ROSETTA full-atom models, the full-atom PDB coordinates are required to be 'extracted' using their full-atom description encoded in the silent output file, which can be done by using a script extract_pdb.com with a command line such as:

This script actually runs the following ROSETTA command to generate full-atom PDB coordinates from the information in silent output file 'silent_file.out':

Note that the generated PDB coordinates will be stored in a directory defined in the paths.txt file. The extracted PDB coordinate files will be named according to their 'description' labels defined in the silent output.

(2) Calculate predicted chemical shifts and "chemical shift scores" for ROSETTA full-atom models

The ROSETTA full-atom models are evaluated by comparing the initial experimental chemical shifts with the SPARTA-predicted chemical shifts for the models. SPARTA takes the standard PDB coordinate for proteins and predicts the backbone 15N, 1HN, 1H , 13CA, 13CB and 13C' chemical shifts using the following command line:

where inPDB.pdb contains the input PDB coordinates file, inCS.tab is the input experimental chemical shifts (the same input as used for the MFR fragment search). The output is a file with predicted chemical shifts, and the chi2 value between the predicted and experimental chemical shifts will be also calculated.

The script runCS_rescore.com runs SPARTA chemical shift prediction for all full-atom PDB coordinates generated above, and all outputs will be stored in a default directory "./pred".

For each full-atom model, its name and raw ROSETTA full-atom energy score are extracted from the ROSETTA silent output file silent_file.out and stored in a file "name.rawscore.txt". Next, the energy score will be 'corrected' by using the corresponding chemical shift chi2 value (stored in file "CS_chi2.txt"). The new file with the model names and re-scored energy will be "name.rescore.txt", an example of this file contains the following contents:

The C_alpha RMSD values between each model and the model with the lowest re-scored energy are calculated using the script pdbrms. pdbrms is a C++ program used to calculate the coordinate RMSD values between one PDB format structure and a set of protein PDB coordinates. For example, to calculate the C-alpha RMSD between ref.pdb and 1.pdb, 2.pdb, 3.pdb, the following command line can be used:

The script runCSrescore.com will identify the model with the lowest rescored energy, and calculate the C_alpha RMSD values to this model for all models in the ./output directory. The final output file "name.rms.rescore.txt" will contain the model names, C-alpha RMSD values and re-scored energies:

By default, the ROSETTA running directory (./rosetta) contains the following contents upon finishing the above CS-ROSETTA protein structure generation:

Using Rosetta 3.x versions requires different input data format and different command options.

In order to install a ROSETTA3.x program, users need to (1) register for a license at http://www.rosettacommons.org/software/, (2) download (at least) the required packages (for example, rosetta3.2.1_Bundles.tgz and rosetta3.2.1_fragments.tgz for Rosetta3.2.1) to the installation directory (for example $ROSETTA_DIR), (3) uncompress rosetta3.2.1_Bundles.tgz, all four generated sub-packages (with names of rosetta*.tgz) and rosetta3.2.1_fragments.tgz, (4) go to the rosetta_source directory and type "./scons.py bin mode=release" (for Linux installation) to compile the ROSETTA3.x source codes. After successful compilation, numbers executable ROSETTA files will be generated, links to those files can be found at /rosetta_source/bin/ directory.

If ROSETTA3.x is installed in a default way (i.e., with a database directory of $ROSETTA_DIR/rosetta_database, a source directory of $ROSETTA_DIR/rosetta_source and a bin directory of $ROSETTA_DIR/rosetta_source/bin for the links to the compiled executable files), the installation script install.com can be used to install CS-ROSETTA program and automatically setup the ROSETTA3.x in CS-ROSETTA.

Otherwise, the following ROSETTA3.X configuration lines in the initialization script $baseDir/com/csrosettaInit.com need to be manually set up :

An additional script runCSRjob3.com is provided to generate MFR fragment inputs for ROSETTA3.x. Use of this script is similar to runCSRjob.com script. The output contains:

The script runRosetta3.com generated in the previous step can be used to run ROSETTA3.x and generate protein structure. Similar to the runRosetta.com script, this script includes solely a standard ROSETTA3.x command line defining the inputs and parameters for fragment assembly and full-atom relaxation.

Note that ROSETTA3.x has different naming method for the generated structures compared to ROSETTA2.x, all ROSETTA3.x structures generated by a given run will be named as S_TAG_AAAAAAAA, where "TAG" is a user defined tag (by "-user_tag" option) and "AAAAAAAA" is a 8-digital index number. Running multiple ROSETTA jobs in parallel for a given project is also different for ROSETTA3.x, users are still able to run the same script runRosetta3.com for each 'parallel' job in the same working directory, but the -use_tag option MUST be different for each job. ROSETTA3.x will still output the structures from different jobs running in the same working directory to a single silent output file (default.out), any two ROSETTA3.x jobs with identical -user_tag option will generate structures with identical name.

A separated script runCSrescore3.com is provided to evaluate the protein structure generated by ROSETTA3.x. This script can be used in a same manner as the script runCSrescore.com for evaluation of ROSETTA2.x generated structures [see details here]. Note that ROSETTA3.x currently is not able to calculate the energy scores for part of the protein, so the final chemical shift rescored ROSETTA(3.x) energy will be calculated based on the ROSETTA(3.x) raw energy of all residues.

After finishing CS-ROSETTA structure generation, users have to decide whether the ROSETTA models are acceptable. For this purpose, it is convenient to plot the "landscape" of (re-scored) ROSETTA full-atom energies of all models with respect to their C_alpha RMSD values relative to the lowest-energy model, using the data stored in a file "name.rms.rescore.txt".

By using the current method implemented in CS-ROSETTA package, 5,000 to 20,000 predicted CS-ROSETTA models are generally required to obtain convergence. For small proteins (<= 90-100 amino acids), 1,000 to 5,000 CS-ROSETTA models often suffice. ROSETTA takes about 5-10 minutes to calculate one all-atom model on a single 2.4GHz CPU.

ROSETTA now can apply the simultaneous prediction of protein folding and docking for symmetric homomultimers. CS-ROSETTA is updated to provide an interface to use this "fold-and-dock" feature (currently only available for CS-ROSETTA with ROSETTA 2.3.0; check here for how to run "fold-and-dock" application in ROSETTA3.2.1) and generate structures for (small) home-dimers and home-tetramer from their chemical shifts.

The script runCSRjob.com is updated to generate fragment inputs and prepare ROSETTA running script for folding and docking a symmetric homomultimer, An newly added option $SYMM in the runCSRjob.com script must to be firstly defined according to the symmetry of the homomultimer to be modeled:

The script runRosetta.FnD.$SYMM.com generated in the previous step can be used to run ROSETTA 2.3.0 and generate structure for homomultimers.

The ROSETTA "folding-and-docking" procedure is more computationally demanding (on the order of hours per model for small homomultimers).

The following steps of chemical shift rescoring and model selection are similar to those of the CS-ROSETTA runs for a monomeric protein.

RDC data now can be used to assist the ROSETTA(3.X)/CS-ROSETTA structure generation in together with the NMR chemical shifts. In order to run a chemical shift based CS-ROSETTA structure generation with the additional RDC data, please refer to "How to use CS-Rosetta with Rosetta 3.X", and replace the ROSETTA3.X command line in the runRosetta3.com script with:

where the rdc_file is the raw RDC file (currently only the backbone H-N RDCs can be used) with a format of:

FAQs

How to use known disulfide bond information in CS-ROSETTA?

Answer

In order to include the known disulfide bond information for the CS-ROSETTA structure prediction, an additional option " - in:fix_disulf disulf.cst" needs to be added to the ROSETTA3.x command line in the runRosetta3.com script, where "disulf.cst" is a disulfide bond definition file (and must be located in the same working directory unless its full path is provided as well). An example "disulf.cst" file containing a definition of two disulfide bonds (between residues Cys6 and Cys88 and between Cys38 and Cys68) is listed below:
6 88
38 68

Why no (or no sufficient) fragment candidates obtained after MFR fragment search?

Answer

The current MFR program (implemented in NMRPipe) searches for fragment candidates with a default threshold of 3.0 for chemical shift matching score (-csThresh 3.0), which is good for most cases. If the experimental chemical shifts involving in a given target fragment are highly unusual, there will be no (or no sufficient) fragment candidates could be selected. When this happens, please first check the chemical shift referencing and make sure that the experimental chemical shifts involved in those "problematic" target fragments are correct. (Script runCSRjob.com will list the number of selected fragment candidates for each target fragment, and the "problematic target fragment" will be listed with a warning message)
Users can "force" the MFR program to generate fragment candidates using a larger csThresh value, for example 5.0, by:

copy script runCSRjob.com to current directory

replace the line
"mfr.com -cs ${CS_NAME} -ref ${REF_NAME} -out ${PDB_NAME}.mfr.tab -excl ${MFR_EXCL}>& ${PDB_NAME}.mfr.log"
with
"mfr.com -cs ${CS_NAME} -ref ${REF_NAME} -out ${PDB_NAME}.mfr.tab -excl ${MFR_EXCL} -csThresh 5.0>& ${PDB_NAME}.mfr.log"

run runCSRjob.com inCS.tab to get fragment candidates

Note that those fragment candidates, which could only be obtained by a MFR fragment search with a larger csThresh value, are often not accurate.

Use of "H", instead of "HN", as the atom name for amide proton in the experimental chemical shift table file is another reason for no (sufficient) fragment candidates (a bug of current MFR module).

How to exclude protein(s) from the structural database during the fragment search?

Answer

For select fragment candidates using a MFR method:

find the exact names of the proteins you like to exclude in the file $CSROSETTA/PDBH/resolution.tab
copy script runCSRjob.com to current directory
find the line set MFR_EXCL = "NONE_", and replace NONE_ with the list of protein names
run runCSRjob.com inCS.tab to get fragment candidates.

For select fragment candidates using a hybrid method:

copy script runCSRjob_hybrid.com to current directory
find the line make_fragments_2000.pl $SEQ_NAME >& make_fragments_2000.log, and replace it with make_fragments_2000.pl -nohoms $SEQ_NAME >& make_fragments_2000.log
run runCSRjob_hybrid.com inCS.tab to get fragment candidates

During the Rosetta2.x parallel jobs, how to avoid the same results (ROSETTA models) assembled from using the identical random seed numbers?

Answer

If you run jobs in a cluster of parallel cpus, sometimes you will get exact same results. This is a general problem for Rosetta(2.x). The reason is that some cpus are starting from exactly the same random seed. One solution for this is to add -seed_offset followed by an int number to your command line, in this way, you can force each cpu to start from a different seed with that offset number. You can also try to run with -constant_seed -jran in multiple clusters, yes, the selection of the integers for the jran should be between 1 million and 4 million. The default value is 1111111.You can certainly choose different values if you want to submit jobs to different clusters.
- from "Rosetta Commons Forum" [link]