phenix_logo
Python-based Hierarchical ENvironment for Integrated Xtallography
Documentation Home
 

Molecular replacement and autobuilding using Phaser, Rosetta, and autobuild with mr_rosetta

Author(s)
Purpose
Tools from Rosetta that are used in mr_rosetta
Steps where mr_rosetta uses structure-modeling algorithms
Summary of the procedure used in mr_rosetta
Details of the procedure used in mr_rosetta
Notes on the procedure used in mr_rosetta
Viewing solutions and restarting with saved solutions
Running mr_rosetta on a cluster
Single file system required for mr_rosetta
Read/write delay allows for slow NFS disks
Tracking your log files
Re-running parts of your mr_rosetta jobs
Failures in sub-processes
Stopping mr_rosetta
Ignoring long-running place_model jobs and going on
Installing Rosetta for use with mr_rosetta
Setting up for a run of mr_rosetta A. Fragment files from the Robetta server
Setting up for a run of mr_rosetta B. Alignment files fromthe hhpred server
Search models and alignment files
Output files from mr_rosetta
Graphical interface
Adding a specific Rosetta command (disulfides to fix)to mr_rosetta
Parameters files in mr_rosetta
Examples
Standard run of mr_rosetta
Running mr_rosetta with a model that is already place in the unit cell
Rebuilding your model with Rosetta before MR
Running mr_rosetta from a homology search (with an hhr file)
Getting a default parameters file for mr_rosetta
Testing mr_rosetta
Possible Problems
Environment problems when running mr_rosetta
Debugging problems with running mr_rosetta
Specific limitations and problems
Literature
Additional information
List of all mr_rosetta keywords

Author(s)

  • mr_rosetta: Tom Terwilliger, Frank DiMaio, Randy Read, David Baker

Purpose

mr_rosetta is a procedure for extending the range of molecular replacement by combining tools from the structure-modeling field (Rosetta) with crystallographic molecular replacement, model-building, density modification and refinement. The approach is described in Dimaio et al. (2011). It can also be used to rebuild a model with a combination of Rosetta and Phenix tools.

A key requirement for using mr_rosetta is that you have to have a sequence alignment of the protein used as a template to model your target protein. You can try several different alignments, but a good alignment has to be in your set of alignments or the procedure will be unlikely to be successful. The reason is that Rosetta homology modeling makes strong use of the sequence, so if your alignment is incorrect you are essentially trying to build the wrong molecule.

The basic process is to find MR solutions with automr, rebuild them with Rosetta, then rebuild those models with phenix.autobuild. The combination of Rosetta rebuilding and phenix rebuilding is the key part of this method. In slightly more detail, this process is to select possible MR solutions (one of which must later be shown to be correct for the procedure to succeed)with automr (Phaser), score with LLG following Rosetta relaxation, pick the best solutions, rebuild each of these with Rosetta including map information (density term), score the resulting models with Rosetta, select the highest and score with LLG, verify that the top solutions are all about the same (electron density maps are correlated), and rebuild the top models with autobuild. mr_rosetta can handle a single copy of a single chain, or multiple copies of a single chain (NCS), or multiple copies of multiple chains (groups of NCS). If you supply one or more input search models, then the entire crystallographic asymmetric unit must contain some multiple of the search models you supply (phaser will be used to find copies of the search model). NCS will be found automatically in your search model and in any models assembled by mr_rosetta. NOTE: if your molecule has multiple chain types, then you cannot use the simple hhr file input (see below) and you cannot automatically run pre-refinement with rosetta on your molecule. Instead you need to use mr_model_preparation and phenix.automr to place your model. Then you can supply the aligned, placed structure to mr_rosetta for rebuilding. Additionally in this case you will need to supply a different set of fragments files for each chain type.

Tools from Rosetta that are used in mr_rosetta

  • Calculation of Rosetta energies for a model.
  • Model relaxation (rebuilding) including just the Rosetta standard energy term. This optional rebuilding can be carried out before molecular replacement, improving the starting model.
  • Model completion and relaxation (filling in missing sections and rebuilding) with Rosetta energies and fit to a map (Dimaio et al., 2009). This step is carried out after an MR solution has been found. The placed model is used to calculate a 2Fo-Fc map and fit to this map is used as a target in addition to the standard Rosetta energies. Note: Sequence-specific fragment libraries are used in this process (obtained from the Robetta webserver).

Steps where mr_rosetta uses structure-modeling algorithms

  • Prior to MR. Edited templates are optionally rebuilt before carrying out molecular replacement.
  • In scoring MR solutions. MR solutions are scored by Phaser LLG scores calculated after model relaxation with Rosetta including the term for fit to the current density map.
  • In rebuilding MR solutions. Initial molecular replacement solutions are rebuilt using Rosetta model completion and relaxation including the term for fit to the current density map

Summary of the procedure used in mr_rosetta

The overall process in one cycle of mr_rosetta is: (a) edit the model and place it in the unit cell (e.g., MR, molecular replacement), (b) score all MR solutions and take the best ones by LLG for further steps, (c) rebuild each model 20-2000 times using Rosetta and density-modified 2Fo-Fc map to yield Rosetta models, (d) refine Rosetta models, average density from top 20%, continue rebuilding each Rosetta model using averaged density, and (e) take top models based on LLG score and rebuild with autobuild. An optional prerefinement step is to carry out Rosetta modeling in step (a) above, before carrying out molecular replacement.

Details of the procedure used in mr_rosetta

  1. Check installation and verify that Rosetta binary and libraries are available (can specify with keywords rosetta_path (overall path to rosetta directories), and the keywords (paths relative to overall rosetta_path) rosetta_binary_dir, rosetta_binary_name, rosetta_script_dir, rosetta_database_dir)
  2. Read reflections file (must be CCP4 mtz and have a freeR set; use phenix GUI or import_and_add_free to set up)
  3. An optional model editing step. If an hhpred .hhr file is supplied, read through this file, download the PDB files specified, apply alignments specified to generate pairs of alignment files and edited models (e.g., 2cng.ali, 2cng_mr.pdb based on 2cng.pdb). This step is carried out by sculptor using a default protocol. NOTE 1: For tailoring of this step, use mr_model_preparation and then supply the aligned model to mr_rosetta. NOTE 2: If your structure contains more than one chain or requires more than one homology model to represent the structure, then you need to use mr_model_preparation and phenix.automr to place your model. Then you can supply the aligned, placed structure to mr_rosetta for rebuilding.
  4. NOTE: The steps below are carried out for each model/alignment file pair supplied, (or for each pair generated from by mr_rosetta if an hhpred .hhr file is supplied with alignment information).
  5. Check model, alignment file and sequence file to verify that they match (i.e., that the alignment file can be applied to the model to yield a model with the sequence in the sequence file). Copy overall B-factor and list of B-factors for atoms from the model to be substituted into subsequent models before scoring. Rewrite the sequence file into standard (fasta) format.
  6. Optional Rosetta modelling prior to molecular replacement (prerefinement). The edited starting model (template) is rebuilt with Rosetta using the standard Rosetta energy functions and a fragments library specific to the target sequence to fill in gaps. (If no gaps are present, no fragments files are necessary).
  7. Run automr to find molecular replacement solutions (default number_of_output_models=5).
  8. Refine (if refine_after_mr=True) each MR solution with refine. Use resulting 2mFo-DFc map as starting point for density modification, yielding density-modified current density map for this refined solution, to be used in Rosetta rebuilding below. Ignore refined model. Note (but ignore) LLG of refined model.
  9. Determine the baseline LLG for model improvement. This LLG can either be the LLG obtained in the previous step, or an LLG obtained after rebuilding the MR model with Rosetta. Optionally perform rosetta relaxation (rebuilding rescore_mr.nstruct models, typically 5) models without filling in missing sections, including a density term from the map in the prevous step. The sequence of all parts of the model at this point will match the target sequence. Score each solution by LLG. These models are not carried forward, but taking the best LLG for any rebuilt model as the score for the original model from MR. This score will be used later to prioritize MR solutions for further analysis.
  10. Sample relaxation script used to run relaxation in Rosetta:
    #!/bin/sh 
    cd MR_ROSETTA_1/RESCORE_MR_1/RELAX_AND_SCORE_IN_SETS_1/RUN_1/WORK_1
     /net/terwill/rosetta/rosetta_source/bin/mr_protocols.default.linuxgccrelease \
    -database /net/terwill/rosetta/rosetta_database \
    -MR:mode cm \
    -in:file:extended_pose 1 \
    -in:file:fasta MR_ROSETTA_1/WORK_1/EDITED_1crb_fasta.txt \
    -in:file:alignment MR_ROSETTA_1/WORK_1/EDITED_1crb_2qo4.ali \
    -in:file:template_pdb MR_ROSETTA_1/AutoMR_run_1_/2QO4.1.pdb \
    -relax:default_repeats 4 \
    -relax:jump_move true \
    -edensity:mapreso   3.00 \
    -edensity:grid_spacing 1.5 \
    -edensity:mapfile \
         MR_ROSETTA_1/AutoMR_run_1_/2QO4.1_refine_001_map_coeffs.map \
    -edensity:sliding_window_wt 1.0 \
    -edensity:sliding_window 5 \
    -cm:aln_format grishin \
    -MR:max_gaplength_to_model 0 \
    -nstruct 1 \
    -ignore_unrecognized_res  \
    -overwrite 
    
  11. Take the top (max_solutions_to_rebuild=5) models from step 5 and rebuild them with Rosetta, this time filling in missing sections and including the density term with the current map (the same map as used above in relaxation) as part of the target function, generating total of (rosetta_rebuild.nstruct=20) rebuilt models. These are Rosetta models. The sequence of these models will be the same as that of the target (unless there are long gaps in the template that cannot be filled by Rosetta). Note: in many cases 20 models is sufficient...in others far more models will make the method work better (i.e., 1000 or 2000 models). This can take a lot of time unless you have a cluster to run on. This Rosetta rebuilding step uses a library of fragments specific to the target sequence to fill in any gaps. (If no gaps are present, no fragments files are necessary). Sample rebuild script used:
    #!/bin/sh 
    cd MR_ROSETTA_1/WORK_1/REBUILD_IN_SETS_1/RUN_1/WORK_1
     /net/terwill/rosetta/rosetta_source/bin/mr_protocols.default.linuxgccrelease \
    -database /net/terwill/rosetta/rosetta_database \
    -MR:mode cm \
    -in:file:extended_pose 1 \
    -in:file:fasta MR_ROSETTA_1/WORK_1/EDITED_1crb_fasta.txt \
    -in:file:alignment MR_ROSETTA_1/WORK_1/EDITED_1crb_2qo4.ali \
    -in:file:template_pdb MR_ROSETTA_1/AutoMR_run_1_/2QO4.1.pdb \
    -loops:frag_sizes 9 3.2 \
    -loops:frag_files inputs/aa1crb_09_05.200_v1_3.gz \
       inputs/aa1crb_03_05.200_v1_3.gz none \
    -loops:random_order \
    -loops:random_grow_loops_by 5 \
    -loops:extended \
    -loops:remodel quick_ccd \
    -loops:relax relax \
    -relax:default_repeats 4 \
    -relax:jump_move true \
    -edensity:mapreso     3.00 \
    -edensity:grid_spacing 1.5 \
    -edensity:mapfile  MR_ROSETTA_1/AutoMR_run_1_/2QO4.1_refine_001_map_coeffs.map \
    -edensity:sliding_window_wt 1.0 \
    -edensity:sliding_window 5 \
    -cm:aln_format grishin \
    -MR:max_gaplength_to_model 8 \
    -nstruct 1  \
    -ignore_unrecognized_res \
    -overwrite
    
  12. Choose top (percentage_to_rescore=10) rebuilt models based on Rosetta score (including density term) and rescore them based on LLG
  13. Determine whether the top (number_of_required_cc=5) best LLG score Rosetta models are all similar (map correlation between map for top model with each )
  14. Refine with phenix.refine the top Rosetta models based on LLG (if refine_top_models.run_refine_top_models=True, percent_to_refine=20). Save new 2mFo-DFc map, density modify the map, and then average the top density-modified maps (top based on Rosetta score) to yield an averaged density map used in the next relaxation step. Ignore the refined model.
  15. Relax (rebuild) the Rosetta models from into their corresponding density maps from with Rosetta, generating (relax_top_models.nstruct=5) models for each. Score each relaxed model with LLG, take best LLG as score. Save best relaxed model as new solution. Sample relax script used:
    #!/bin/sh 
    cd MR_ROSETTA_1/GROUP_OF_RESCORE_MR_ROSETTA_2/RUN_1/RESCORE_MR_1/RELAX_AND_SCORE_IN_SETS_1/RUN_1/WORK_1
     /net/terwill/rosetta/rosetta_source/bin/mr_protocols.default.linuxgccrelease \
    -database /net/terwill/rosetta/rosetta_database \
    -MR:mode relax \
    -in::file::s \
     MR_ROSETTA_1/WORK_1/REBUILD_IN_SETS_1/RUN_8/WORK_1/S_2QO4B_0001_edited.pdb \
    -relax:default_repeats 4 \
    -relax:jump_move true \
    -edensity:mapreso   3.00 \
    -edensity:grid_spacing 1.5 \
    -edensity:mapfile \
     MR_ROSETTA_1/WORK_1/REBUILD_IN_SETS_1/RUN_8/WORK_1/S_2QO4B_0001_edited_refine_001_map_coeffs.map \
    -edensity:sliding_window_wt 1.0 \
    -edensity:sliding_window 5 \
    -nstruct 1 \
    -overwrite 
    
  16. Take the top (number_to_autobuild=5) relaxed refined rebuilt Rosetta models from the previous step (scored by LLG) and rebuild them with phenix.autobuild. Report the R/freeR of each model.

Notes on the procedure used in mr_rosetta

  1. Viewing solutions and restarting with saved solutions

    At each stage, existing solutions are saved as a python "pkl" file and can be read back in to mr_rosetta with "mr_rosetta_solutions=xxx.pkl". These solutions can be displayed with "display_solutions=True". Existing solutions are stored as "mr_rosetta_solution" objects which keep track of the model and its history, the map_coefficients and labels, etc. These can be read in to mr_rosetta with the keyword "mr_rosetta_solutions=results.pkl" and used as inputs for subsequent runs, starting at any step that can use those solutions. NOTE: You can re-start mr_rosetta only at the beginning of major stages (like "place_model", "rosetta_rebuild" etc)...but not in between. Normally at the end of a major stage a .pkl file is written out with text like "type this to see all the results". You can almost always give your original command, the command "start_point=xxx" and "mr_rosetta_solutions=my_pickle_file.pkl" and it should then continue on from there.

  2. Running mr_rosetta on a cluster

    Jobs can be run on a single machine or on a cluster. A run command for single jobs (single_run_command="sh") and a run command for batch jobs (group_run_command=qsub) can be specified as well as the number of processors to use (nproc=200).

    The qsub command is used in Sun Grid Engine clusters. You can also use mr_rosetta on a Condor cluster, using group_run_command="condor_submit ".

  3. Single file system required for mr_rosetta

    All files are stored on a single file system that must be accessible to all jobs.

  4. Read/write delay allows for slow NFS disks

    Read/write to files are (generally) accompanied by a wait for appearance of the new file of up to max_wait_time=100 sec.

  5. Tracking your log files

    mr_rosetta runs all cpu-intensive jobs as sub-processes. When it submits a sub process to do the work it lists the name of the corresponding log file. You can work your way down to the bottom level at any time by reading through these log files, copying the name of the next log file, and opening it until you get to the place where the actual work is done.

  6. Re-running parts of your mr_rosetta jobs

    Sub-processes are always run in sub-directories. Each sub-process has a file "RUN_FILE_1" that contains the information to run the sub-process, a parameter file PARAMS_1.eff and a log file "RUN_FILE_1.log" with the log file of running that sub-process. Note that you can use the parameters files to re-run any jobs that you want. You can say something like:

    phenix.mr_rosetta PARAMS_1.eff
    and that will rerun the job specified in that directory.
  7. Failures in sub-processes

    If some sub-processes fail, normally the failures will be ignored. This is useful as your overall job can often continue even if a few refinement or rosetta jobs fail. However if the failure is from the queueing system (rather than in the actual running of the jobs) then the overall job may still fail.

  8. Stopping mr_rosetta

    If you create a file "STOPWIZARD" in the top level directory (i.e., MR_ROSETTA_1/), then each job in the entire process will stop as soon as any Phenix part of the process takes over (i.e., as soon as Rosetta jobs finish).

  9. Ignoring long-running place_model jobs and going on

    There are two ways to avoid the problem of having one or more long-running (and very likely eventually unsuccessful) place_model sub-processes that prevent mr_rosetta from going on. One way is to set the parameter sufficient_number_finished=nn, where you are satisfied if any nn place_model jobs finish successfully. Then once nn jobs finish, all the rest are simply ignored and mr_rosetta goes on. The jobs that are ignored will continue on until they finish (and will still be ignored.) A second way is to edit the value of sufficient_number_finished after mr_rosetta has started. This is convenient if you see that all the jobs except for one or two are done, and these seem to be going on forever. You can create a little file "GO_ON" in the directory where place_model is being run that contains the value you want for sufficient_number_finished (if you want it to stop right away and at least one job is finished, just put in 1). This directory is the directory where the log files for place_model are located. For example your overall log file might say,

    Splitting work into 2 jobs and running with 2 processors using sh 
    background=True in /Users/terwill/unix/misc/junk/test_place_model/MR_ROSETTA_7/GROUP_OF_PLACE_MODEL_1
    
    in which case that directory is where you would put GO_ON, where the file GO_ON just contains a number (the value for sufficient_number_finished). As in the use of sufficient_number_finished, the ignored jobs do not actually stop, so if you really want to stop them you will need to do that in another way (mr_rosetta does not capture the job numbers for sub-processes so it can't stop them, it can only monitor what they have done.)

    NOTE: you can use this second method with the GO_ON file to tell mr_rosetta how many finished jobs to require for any set of sub-processes. Just put this file in the directory specified for that group of sub-processes. This also works for other phenix tools including autobuild, ligandfit and find_all_ligands that have the 'Splitting work into...' text in their log files.

Installing Rosetta for use with mr_rosetta

To run mr_rosetta, you need to install Rosetta from the Baker laboratory at the University of Washington. This is pretty easy, and a summary of steps is given below. Once you have installed Rosetta you need to set the environmental variable $PHENIX_ROSETTA_PATH. Then you have all the software you will need for running mr_rosetta.

Note: this set of instructions is for Rosetta version 3.2...presumably future versions will look very similar except for the numbering.

Downloading and installing Rosetta is pretty easy if your computer is compatible and it takes about an hour if you have a 2-processor machine...or just a few minutes if you have a multiprocessor machine to compile with.

NOTE: If trouble...see the FULL INSTRUCTIONS at http://www.rosettacommons.org/manuals/archive/rosetta3.2_user_guide/ or http://www.rosettacommons.org/manuals/archive/rosetta3.2_ or http://www.rosettacommons.org/manuals/archive/rosetta3.2.1_user_guide/

NOTE: If trouble on ubuntu 11.04 or later...also see: http://morganbye.net/blog/2011/05/rosetta-32-ubuntu-1104 (but just concerning basic.settings and options.settings modifications and using : scons bin mode=release cxx=gcc cxx_ver=4.5)

  1. go to https://c4c.uwc4c.com/express_license_technologies/rosetta, find "Academic License" and click on "LICENSE". Fill out the form, and receive by email a link to the download site and a login/password.
  2. Go to Rosetta 3.2 on the download site, select Download, and Download Rosetta "as one bundle". Note if you have a mac you may need to install some additional patches (please see the instructions on the download page).
  3. Unpack and install Rosetta: Go to the directory where you want to install it and move the downloaded file "rosetta3.2_Bundles.tgz" there. Then...
    tar xzf rosetta3.2_Bundles.tgz
    
    This should give you a directory rosetta-3.2 that contains:
    BioTools		new_apps.note		rosetta_demos
    foldit			release.note		rosetta_fragments
    manual			rosetta_database	rosetta_source
    
    NOTE: if your directory contains .tgz files instead of the listing above you may need to also run the same tar command on the individual .tgz files.
  4. Now you want to compile. You must have python on your machine...if not you will need to install it from http://www.python.org/. You will also need scons. If you don't have scons you can get it from www.scons.org/. NOTE: you will need version 2.2 or later of python and 0.96.1 of scons. You can check your versions with:
      python --version
      scons --version
    
  5. NOTE 2: on Ubuntu you may also need zlib1g-dev. You can get this library and scons with:
        sudo su   # UBUNTU ONLY FOR INSTALLING zlib1g and scons
        apt-get install zlib1g-dev
        apt-get install scons
    
  6. In the scons command below the "-j2" means use 2 processors....adjust for your system. Takes about 1 hour with 2 processors. Please note: Do not move your Rosetta installation after compiling it. The compilation builds in path names, and if you move the binaries to some other place it will not run.
    cd rosetta_source
    python external/scons-local/scons.py -j2 bin mode=release
    cd ..
    
    If you get to "scons: done building targets." you are all set!
  7. Notice where you have installed rosetta. The directory you just set up, now containing "rosetta_source" and "rosetta_database" is to be called "PHENIX_ROSETTA_PATH". If this directory is... /net/sigma/raid1/rosetta-3.2 then you can now set a local environmental variable in your ".profile" (sh or bash shell) or ".cshrc" (c-shell) to mark where rosetta is located: if you are using the bash or sh shells:
    export PHENIX_ROSETTA_PATH=/your-path-to-rosetta-here/rosetta-3.2
    
    or sh (C-shell):
    setenv PHENIX_ROSETTA_PATH /your-path-to-rosetta-here/rosetta-3.2
    
  8. If your machine is behind a firewall and there is a proxy server you need to go through, then if you use a .hhr file to download files from the PDB then you will need to specify your proxy server. You can use the following command to specify the proxy server (replacing it with YOUR proxy server). If you are using the bash or sh shells:
    export HTTP_PROXY=proxyout.mydomain.edu:8080
    or sh (C-shell):
    setenv HTTP_PROXY proxyout.mydomain.edu:8080
    
  9. Now you are completely ready to go with Rosetta and with mr_rosetta.

Setting up for a run of mr_rosetta A. Fragment files from the Robetta server

To run mr_rosetta on your structure, you will need to use the Robetta fragment server at the Univ. of Washington to generate 9-mer and 3-mer fragments from the PDB that are compatible with your sequence file. This takes a few hours but is very easy to do.

To obtain the two required files:

  1. go to: http://robetta.bakerlab.org/fragmentsubmit.jsp
  2. register
  3. paste your sequence file into the form
  4. Receive an email from the server after a few hours that our files are ready
  5. Download the files (two files, with similar filenames, one containing a 9 and and one a 3 like: aat000_09_05.200_v1_3.gz and aat000_03_05.200_v1_3.gz)
  6. These are your fragment files. You will need to list them in your mr_rosetta parameters file
  7. NOTE1: if your chain has more than 650 residues, then you will need to split it up into pieces of 650 residues or fewer before submitting the sequence to the Robetta server. Then you will get several 3-mer and 9-mer fragments files, one for each piece that you submit. You can then simply paste these together after editing all but the first to fix the residue numbers. To edit the files just use
    phenix.phenix.adjust_robetta_resid <fragment_file_name> <new_fragment_file_name> <offset-for-residue numbers>
    
  8. NOTE2: if you have multiple chain types in your structure then you will want to have a separate set of fragments files for each chain type. You can specify these with: fragment_files_chain_list, fragment_files_3_mer_by_chain, and fragment_files_9_mer_by_chain instead of fragment_files. Use fragment_files_chain_list to define which chain ID each of your fragment_files_3_mer_by_chain and fragment_files_9_mer_by_chain go with.
  9. NOTE3: You only need one set of fragments files for each UNIQUE chain. So if chains A and C are the same, you just need to specify fragments for chain A. If you have two different chains A and B and fragment files frag_A_3 frag_A_9 frag_B_3 frag_B_9 then you should use: fragment_files_chain_list=A fragment_files_chain_list=B fragment_files_3_mer_by_chain=frag_A_3 fragment_files_9_mer_by_chain=frag_A_9 fragment_files_3_mer_by_chain=frag_B_3 fragment_files_9_mer_by_chain=frag_B_9

Setting up for a run of mr_rosetta B. Alignment files from the hhpred server

You will need to tell mr_rosetta what to use as search models and the alignment between the search models and your target structure. The easiest way is to use the hhpred server (Söding J. (2005) Protein homology detection by HMM-HMM comparison. Bioinformatics 21, 951-960.) Here is what to do:

  1. go to: http://toolkit.tuebingen.mpg.de/hhpred and paste in your sequence and hit submit job (using all defaults).
  2. In a few minutes there will be a new page with alignments in color. You want to click on the little Save button on the line above all the alignments. Save that .hhr file; this contains a list of all the PDB entries with similar sequences and the alignments.
  3. Repeat the run of hhpred (hit "Rerun job"), this time selecting Alignment mode as global in the middle of the page. Save the resulting .hhr file as well.
The HHR analysis file from hhpred contains PDB entries similar in sequence to your target and sequence alignments. It is used to create a list of search models and alignment files. If you supply this file you do not need to specify alignment files or search models time and enter them as your hhr_files.

Search models and alignment files

If you supply an hhr analysis file from hhpred, you do not need to worry (usually) about the details of your search models and alignment files. However you can supply mr_rosetta with your own list of search models and a corresponding list of alignment files. This section describes what the alignment files need to look like (two ways you can format these files.) Here are your options for supplying alignment information:

  • If you have a pre-edited PDB file (i.e., you ran something beforehand to make the sequence be just what you want), then you just supply the PDB file and the sequence file (which may be identical or the PDB file may have deletions relative to the sequence file) as in the sample scripts.
  • Otherwise if you have a .ali alignment file (see below) , you can supply that along with the PDB file and the sequence file, and then phenix will use sculptor to apply the alignment .
  • Otherwise, and commonly, you supply a .hhr file, and mr_rosetta downloads the pdb and applys the alignment in the hhr file (and you don't have to supply either sequence or hhr file).
  • If you want to apply an alignment yourself with an hhr file, you can use mr_model_preparation
  • If you want to apply an alignment yourself with an alignment file that just contains 4 lines (1) > (greater-than-symbol), then title for target sequence (2) target sequence with - for gaps (3) >the sequence of the target and (4) the sequence of the protein in the template PDB you are supplying, then you can use mr_model_preparation

You can generate an alignment file with phenix.muscle if you do not have one from another source. Use a command like this:

phenix.muscle -in my_two_sequences.dat -out my_alignment.ali
where my_two_sequences.dat looks like:
> title text for sequence of target (your structure) to follow
LVLKWVMSTKYVEAGELKEGSYVVIDGEPCRVVEIEKSKTGKHGSAKARIVAVGVFDGGKRTLSLPVDAQVEVPIIEKFT
AQILSVSGDVIQLMDMRDYKTIEVPMKYVEEEAKGRLAPGAEVEVWQILDRYKIIRVKG
> title text for sequence of template (supplied PDB) to follow
qlmdmrd AQILSVSGDVIQLMDMRDYKTIEVPMKYVEEEAKGRLAPGAEVEVWQILDRYKIIRVKG qlmdmrd
and my_alignment.ali (your .ali file) looks like:
> title text for sequence of target (your structure) to follow
LVLKWVMSTKYVEAGELKEGSYVVIDGEPCRVVEIEKSKTGKHGSAKARIVAVGVFDGGK
RTLSLPVDAQVEVPIIEKFTAQILSVSGDVIQLMDMRDYKTIEVPMKYVEEEAKGRLAPG
AEVEVWQILDRYKIIRVKG-------
> title text for sequence of template (supplied PDB) to follow
------------------------------------------------------------
-------------QLMDMRDAQILSVSGDVIQLMDMRDYKTIEVPMKYVEEEAKGRLAPG
AEVEVWQILDRYKIIRVKGQLMDMRD

You have two options for alignment files if you are going to use one.

  • You can use an alignment file that sculptor can recognize. This file looks like this (there must be exactly the same number of characters for the target and the template sequences (including dashes for gaps):
    > title text for sequence of target (your structure) to follow
    VDFNGYWKMLSNENFEEYLRALDVNVALRKIANLLKPDKEIVQDGDHMIIRTLSTFRNYIMDFQVGKEFEEDLTGIDD
    > title text for sequence of template (supplied PDB) to follow
    -AFSGTWQVYAQENYEEFLRAISLPEEVIKLAKDVKPVTEIQQNGSDFTITSKTPGKTVTNSFTIGKEAEIT--TMDG
    
  • Alternatively, you can use a second format for the alignment file for mr_rosetta (This file is different than the alignment file for sculptor or mr_model_preparation; it is a MODELLER-style .ali file). Here is a sample:
    ## 1CRB_ 2qo4_A
    # hhsearch
    scores_from_program: 0 1.00
    1 VDFNGYWKMLSNENFEEYLRALDVNVALRKIANLLKPDKEIVQDGDHMIIRTLSTFRNYIMDFQVGKEFEEDLTGIDD
    0 -AFSGTWQVYAQENYEEFLRAISLPEEVIKLAKDVKPVTEIQQNGSDFTITSKTPGKTVTNSFTIGKEAEIT--TMDG
    --
    

    Here is what has to be on each line:

    1. Line 1: two ## signs, then target PDB ID then template PDB ID. NOTE: the template PDB ID must match the starting characters of your input search model file names (the file names themselves, not including the path to them)
    2. Line 2 just has a # sign and the word hhsearch
    3. Line 3 just has some text like scores_from_program: 0 1.00
    4. Line 4 has a number, then the entire sequence of the structure to be solved (the target), all on one line. The number is how many residues at the N-terminus of this sequence are to be ignored in generating a model. Usually this is 0, but if you supply a sequence that is not what is in your crystal, it could have some other number. If you are supplying a template PDB file that has residues to be removed, indicate these positions with a dash (-) in your sequence. Note: the sequence on this line cannot start with a dash.
    5. Line 5 has a number, then the matching sequence of the template PDB, using dashes (-) to indicate residues that are not present in the template PDB There must be exactly the same number of characters in the sequence of your target and the sequence of your template. The number is how many residues at the N-terminus of your template PDB are to be ignored. If you have fully edited your template PDB to match the target sequence, the number will be 0.
    6. line 6 has two dashes: --

Output files from mr_rosetta

The output files from mr_rosetta are the same as those from .autobuild: a model and map coefficients. These will be in a subdirectory listed at the end of your log file. The files will be something like: MR_ROSETTA_1/..../AutoBuild_run_1_/overall_best.pdb and MR_ROSETTA_1/..../AutoBuild_run_1_/overall_best_denmod_map_coeffs.mtz.

Graphical interface

A GUI for MR-Rosetta is now available in the "Molecular replacement" category. Its function is essentially identical to that of the command-line version, but many of the details are not shown by default. In addition to the methods described above for configuring your system to use Rosetta from PHENIX, the GUI also includes a preferences setting in the "Wizards" section for defining the path to the Rosetta installation. If the GUI does not detect that you have the environment set up correctly, it will issue a warning when started. The configuration tab in the GUI includes a list into which any combination of input files may be added; the file types should be recognized (and any relevant data they contain extracted, such as space group and MTZ label information) automatically. For more complex inputs involving fragment files, click the button labeled "Other inputs" below the list of files.
The number of processors to use will be set to one fewer than the total the number of CPU cores PHENIX thinks are available, but if you are using a queueing system this number can be increased. You can change how MR-Rosetta runs child processes by clicking the "Job control" button in the lower left-hand corner of the configuration tab. Because it usually takes hours to run, MR-Rosetta will always be launched by the GUI as a "detached" job, meaning that you can close the GUI without killing the process, and resume it later. While MR-Rosetta is running, the current set of solutions will be continuously updated in a tab labeled "Current results", with the relevant score (LLG from Phaser, Rosetta score, or R-factor). You may view any of these solutions by clicking the buttons next to them.
Once the job is complete, a simply summary tab will be displayed, listing the output files and basic statistics such as R-factors. If the program was successful, the R-free will usually be below 50%, although this may vary depending on resolution and data quality. Buttons are provided to start additional programs or view the model and maps.

Adding a specific Rosetta command (disulfides to fix) to mr_rosetta

When you run mr_rosetta you can specify a command or commands to be added to the Rosetta scripts. For example, if your model has disulfide bonds between residues 12 and 15 and between 22 and 39 you can say:

rosetta_command="-MR::disulf 12:15 22:39"
In this command, each disulfide is colon-separated, and the numbering corresponds to the input fasta file. If you have multiple commands you can just give multiple rosetta_command statements. Note that any commands will be applied to all rosetta scripts in this mr_rosetta run. That means that you can't have different commands for different steps that use Rosetta. It also means that you cannot specify chain names or use different commands for different chains. At the moment this feature is most useful if you are supplying a single chain (or multiple chains with identical sequences).

Parameters files in mr_rosetta

When you run mr_rosetta it will write out a mr_rosetta_params.eff parameter file that can be used to re-run mr_rosetta (just as for essentially all PHENIX methods).

Examples

Standard run of mr_rosetta

Before you run mr_rosetta, you need to get fragment files from the Robetta server (see Setting up for a run of mr_rosetta, part A, above). Then you need an hhr alignment information file from the hhpred server (see Setting up for a run of mr_rosetta, part B, above), or else a search model and an alignment file to go with it. Once you have these files, running mr_rosetta is easy. If you have a search model (coords1.pdb) and an alignment file for it (coords1.ali), and fragment files test3.gz and test9.gz, and a data file fobs.mtz with FP SIGFP and FreeR_flag, you can type:

phenix.mr_rosetta \
  seq_file=seq.dat \
  data=coords1.mtz \
  alignment_files=coords1.ali \
  search_models=coords1.pdb \
  already_placed=False\
  fragment_files = test3.gz \
  fragment_files = test9.gz \
  rescore_mr.relax=False \
  rosetta_models=20 \
  ncs_copies=2 \
  space_group=p212121  \
  use_all_plausible_sg=False \
  nproc=200 \
  group_run_command=qsub
and mr_rosetta will run automatically, generating 20 rosetta models during structure determination. If you have an hhr alignment information file, you can specify that instead of search_models and alignment_files, with the command hhr_files=myhhpred.hhr. Then you can tell mr_rosetta how many of the PDB files to use with read_hhpred.number_of_models=1 (to use just the best one, for example).

Running mr_rosetta with a model that is already place in the unit cell

You can run mr_rosetta as a purely model-building tool as well. This is convenient if you have found a MR solution but cannot rebuild it successfully. Here is an example. The keyword to use is already_placed=True:

phenix.mr_rosetta \
  seq_file=seq.dat \
  data=coords1.mtz \
  search_models=coords1.pdb \
  already_placed=True \
  fragment_files = test3.gz \
  fragment_files = test9.gz \
  rescore_mr.relax=False \
  rosetta_models=20 \
  ncs_copies=2 \
  space_group=p212121  \
  use_all_plausible_sg=False \
  nproc=200 \
  group_run_command=qsub

Rebuilding your model with Rosetta before MR

If your search model is too distant to find a molecular replacement solution, you can prerefine your model with Rosetta before carrying out molecular replacement. Here is an example. The keyword to use is: run_prerefine=True. NOTE 1: It is best to specify the number of ncs_copies if you use run_prerefine. If you do not, then you may end up running several parallel jobs, each of which is independently carrying out prerefinement on the same input model (to be used later with different numbers of ncs copies). Once you have run your job with one value of ncs_copies, you can just use the best prerefined model from that job as a search model in your other runs.

phenix.mr_rosetta \
  seq_file=seq.dat \
  data=coords1.mtz \
  search_models=coords1.pdb \
  run_prerefine=True \
  number_of_prerefine_models=1000 \
  fragment_files = test3.gz \
  fragment_files = test9.gz \
  rescore_mr.relax=False \
  rosetta_models=20 \
  ncs_copies=2 \
  space_group=p212121  \
  use_all_plausible_sg=False \
  nproc=200 \
  group_run_command=qsub
NOTE 2: if you have a model and just want to run pre-refinement and not anything else...then you can do so without any data:
phenix.mr_rosetta \
  seq_file=seq.dat \
  search_models=coords1.pdb \
  run_prerefine=True \
  number_of_prerefine_models=1000
Your pre-refined model(s) will be listed in
MR_ROSETTA_1/GROUP_OF_PLACE_MODEL_1/RUN_FILE_1.log
and you can pick the best of these (most negative score, listed first).

Running mr_rosetta from a homology search (with an hhr file)

If you have run hhpred and obtained a .hhr file with a list of alignments of proteins in the PDB with your sequence, you can run starting from your sequence file and this .hhr file. Here is an example. The keyword to use is: hhr_files=my_hhr_file.hhr.

 phenix.mr_rosetta \
  seq_file=bfr258e.fasta \
  data=bfr258e_data.mtz \
  hhr_files=bfr258e.hhr \
  read_hhpred.number_of_models=1 \
  read_hhpred.number_of_models_to_skip=0 \
  fragment_files=aabfr__03_05.200_v1_3.gz \
  fragment_files=aabfr__09_05.200_v1_3.gz \
  rescore_mr.relax=False \
  rosetta_models=20 \
  ncs_copies=1 \
  nproc=200 \
  group_run_command=qsub 
NOTE: it is generally a good idea to run several separate mr_rosetta jobs, one for each homology model you want to extract from the PDB, and possibly also separately for each possible number of NCS copies. You can do this by adjusting the "read_hhpred.number_of_models_to_skip" from 0 to N and the value of "ncs_copies" in the script above. In this way, you can just pick the first job that gives you a good solution. If you run them all at once, then all jobs will wait for the slowest job to finish at each step. If there are multiple NCS copies and some search models are poor, this can sometimes take a very long time.

Getting a default parameters file for mr_rosetta

Usually you will want to edit a parameters file so that you can specify more details of the run. You can get a default parameters file with:

phenix.mr_rosetta 
and then just edit that file.

Testing mr_rosetta

You can do a test of mr_rosetta to make sure everything is ok with:

phenix_regression.wizards.test_command_line_rosetta_quick

Possible Problems

Environment problems when running mr_rosetta

If you get an error message something like ... /opt/rosetta3.4/rosetta_source/bin/mr_protocols.default.linuxgccrelease: error while loading shared libraries: libprotocols.7.so: cannot open shared object file: No such file or directory" this can mean that the LD_LIBRARY_PATH is not correctly interpreted by mr_rosetta. Try running this command just before running phenix, or put in your bash.bashrc file (if using sh/bash) or .cshrc file (if using csh): PHENIX_TRUST_OTHER_ENV="yes"

Debugging problems with running mr_rosetta

If mr_rosetta fails, the first thing (after just checking the commands you used) is to run the mr_rosetta regression tests to make sure that the installations of phenix and rosetta are both ok:

phenix_regression.wizards.test_command_line_rosetta_quick
That should take 10-20 minutes to run and say "OK" for all the tests. If one or more of these say instead "FAILED" ...you can go into the failed run (for example, test_autobuild/) and run the script there (e.g., ./test_autobuild.com) which should fail.. and you can track down what is not working.

NOTE: On some systems there may be some really minor (numerical) differences between the standard results and those on your system. These can cause the "FAILED" to be printed out but can safely be ignored. You can tell by looking at the file "diff.dat" that should be in the failed run directory and you'll see that the differences are very minor.

If the tests all are OK, then there is something specific to your data or script. The best way to debug this is to go to the last sub-process that has failed or hung and look at the log file, and possibly re-run that step from the terminal. Here is how to get there:

  1. In your main log file the last lines will be something like...
    Starting job 1...Log will be: /net/omega/raid1/scratch1/terwillMR_ROSETTA_2/GROUP_OF_PLACE_MODEL_1/RUN_FILE_1.log
    
  2. This log file in turn may say that further jobs were submitted...if so, go to the end of that log file...find the name of the next log file...etc... until you are at the very last thing done.
  3. Your last run is in the directory where RUN_FILE_1.log is located. There will be the following files (more if there are lots of runs in this directory of course):
    terwill@sigma> cd MR_ROSETTA_2/GROUP_OF_PLACE_MODEL_1/
    terwill@sigma> ls -tlr
    total 60
    -rwx------ 1 terwill lanl  1495 Feb  5 14:54 RUN_FILE_1.sh*
    -rwx------ 1 terwill lanl   282 Feb  5 14:54 RUN_FILE_1*
    -rw-r--r-- 1 terwill lanl  6431 Feb  5 14:54 PARAMS_1.eff
    -rw-r--r-- 1 terwill lanl  6564 Feb  5 14:54 mr_rosetta_params.eff
    -rw-r--r-- 1 terwill lanl   130 Feb  5 14:54 INFO_FILE_1
    drwxr-xr-x 6 terwill lanl  4096 Feb  5 16:44 RUN_1/
    -rw-r--r-- 1 terwill lanl 21575 Feb  5 16:45 RUN_FILE_1.log
    -rw-r--r-- 1 terwill lanl    51 Feb  5 16:46 JOBS_RUNNING
    
    Here:
    • PARAMS_1.eff are the parameters used in the run
    • RUN_FILE_1.sh actually runs the job (e.g., phenix.mr_rosetta PARAMS_1.eff) NOTE: usually this is mr_rosetta but it could also be another routine, so you do have to look at it or the first line of PARAMS_1.eff which will name the routine used.
    • RUN_FILE_1.log is the log file for this run. Look at the end of this file.
    • The job is run in RUN_1/
    The key here is that you can type
      phenix.mr_rosetta PARAMS_1.eff
    
    and the exact same job that failed or ran will be run again. You can use this to debug what is going on.
  4. Look at the log file RUN_FILE_1.log and the files in RUN_1/. Notice what the last file written in RUN_1/ is...this may give a clue as to when and where the problem occurred. Usually there will be an error message in RUN_FILE_1.log that may be informative.
  5. If the run in question is a Rosetta job, then the actual Rosetta job is run in a subdirectory of RUN_1/ This will be in a directory like:
    MR_ROSETTA_2/GROUP_OF_ROSETTA_REBUILD_1/RUN_1/REBUILD_IN_SETS_1/RUN_5/WORK_1
    
    Here this is in RUN_1 of a group of rosetta models, set 1, run 5, working directory. In this directory you will find something like:
    terwill@sigma> cd WORK_1/
    terwill@sigma> ls -tlr
    total 684
    -rw-r--r-- 1 terwill lanl   1475 Feb  5 16:48 rebuild.flags
    -rwxr-xr-x 1 terwill lanl    304 Feb  5 16:48 run_rebuild.sh*
    -rw-r--r-- 1 terwill lanl 422921 Feb  5 17:26 S_3DZB__0001.pdb
    -rw-r--r-- 1 terwill lanl    665 Feb  5 17:26 score.sc
    -rw-r--r-- 1 terwill lanl  97437 Feb  5 17:26 rebuild.log
    -rw-r--r-- 1 terwill lanl 158717 Feb  5 18:17 S_3DZB__0001_ed.pdb
    
    Here:
    • rebuild.flags are the commands to Rosetta
    • run_rebuild.sh is a command file to run Rosetta with rebuild.flags
    • rebuild.log is the log file
    You can look at the log file and see if there are any messages. Then you can rerun the Rosetta job in a scratch directory with:
    mkdir junk
    cd junk
    ../run_rebuild.sh
    
    With luck, you will get the same errors and you can debug from there by changing the parameters or input files in rebuild.flags to see what was causing the problems.

    Specific limitations and problems

    mr_rosetta does not have the full flexibility of autobuild, so you may want to get a nearly-complete model with mr_rosetta and then use autobuild to increase the completeness and quality. You may also want to take the output of mr_rosetta and then put it back in as input to mr_rosetta and re-run it to improve your model.

    File names of PDB files for mr_rosetta need to have at least 4 characters before the .pdb. So test.pdb is fine, but my.pdb is not.

    Literature

    • Frank DiMaio, Thomas C. Terwilliger, Randy J. Read, Alexander Wlodawer, Gustav Oberdorfer, Eugene Valkov, Assaf Alon, Deborah Fass, Herbert L. Axelrod, Debanu Das, Sergey M. Vorobiev, Hideo Iwai, P. Raj Pokkuluri & David Baker (2011) "Increasing the Radius of Convergence of Molecular Replacement by Density and Energy Guided Protein Structure Optimization" Nature, 473, 540-543.
    • Terwilliger TC, DiMaio F, Read RJ, Baker D, Bunkóci G, Adams PD, Grosse-Kunstleve RW, Afonine PV, Echols N. (2012) phenix.mr_rosetta: Molecular replacement and model rebuilding with Phenix and Rosetta. J. Struct. Funct. Genomics 13:81-90.
    • DiMaio, F., Tyka, M.D., Baker, M.L., Chiu, W., Baker, D. (2009). "Refinement of Protein Structures into Low-Resolution Density Maps Using Rosetta" J. Mol. Biol. 392, 181-190.

    Additional information

    List of all mr_rosetta keywords

    ------------------------------------------------------------------------------- 
    Legend: black bold - scope names
            black - parameter names
            red - parameter values
            blue - parameter help
            blue bold - scope help
            Parameter values:
              * means selected parameter (where multiple choices are available)
              False is No
              True is Yes
              None means not provided, not predefined, or left up to the program
              "%3d" is a Python style formatting descriptor
    ------------------------------------------------------------------------------- 
    mr_rosetta
       input_files
          seq_file= None File with 1-letter code sequence of molecule. Chains
                    separated by blank line or greater-than sign
          hhr_files= None Optional HHR analysis file from hhpred. This file
                     contains PDB entries similar in sequence to your target and
                     sequence alignments. It is used to create a list of search
                     models and alignment files. If you supply this file you do
                     not need to specify alignment files or search models. To
                     obtain this file go to:
                     http://toolkit.tuebingen.mpg.de/hhpred and paste in your
                     sequence. Run it twice, once with default parameters and once
                     with alignment mode=global. Download the '.hhr' output file
                     each time and enter them as your hhr_files. NOTE: If your
                     model has more than one chain type then you cannot use an hhr
                     file to start the analysis. Instead you will need to use
                     phenix.mr_model_preparation and phenix.automr to create your
                     model; then you can start phenix.mr_rosetta with
                     already_placed=True
          alignment_files= None Alignment file. Supply a list if you have a list
                           of search models, with alignment_files=model_1.ali
                           alignment_files=model_2.ali etc. NOTE 1: Not needed if
                           you supply an hhr alignment analysis file. NOTE 2: Not
                           needed if your search model has the same sequence as
                           your sequence file. NOTE 3: If your model has more than
                           one unique chain, your alignment file should just be
                           the contents of several single alignment files, one
                           after the other in a single file. NOTE 4: Alignment
                           file format: .ali Looks like: Line 1: target PDB ID
                           then template PDB ID. NOTE: the template PDB ID must
                           match the first 5 characters of your input search model
                           file names (the file names themselves, not including
                           the path to them) Lines 2, 3 keep as is Line 4: OFFSET,
                           then entire sequence of target PDB line5: OFFSET, then
                           matching sequence of template PDB line 6: as is --""
                           NOTE OFFSET is residue position, starting with ZERO,
                           where the alignment starts. For line 4 (target PDB
                           sequence) take number from hhpred output and subtract 1
                           For line 5 (template PDB sequence) should always be 0
                           ## 1CRB_ 2qo4_A # hhsearch scores_from_program: 0 1.00
                           1
                           VDFNGYWKMLSNENFEEYLRALDVNVALRKIANLLKPDKEIVQDGDHMIIRTLSTF
                          RNYIMDFQVGKEFEEDLTGIDDRKCMTTVSWDGDKLQCVQKGEKEGRGWTQWIEGDE
                          LHLEMRAEGVTCKQVFKKV 0
                           -AFSGTWQVYAQENYEEFLRAISLPEEVIKLAKDVKPVTEIQQNGSDFTITSKTPG
                          KTVTNSFTIGKEAEIT--TMDGKKLKCIVKLDGGKLVCRT----DRFSHIQEIKAGE
                          MVETLTVGGTTMIRKSKKI --
          model_info_file= None Pickled file containing information about starting
                           model
          data= None Data file with experimental data ( FP SIGFP or I SIGI ).
                NOTE: May optionally instead contain F SIGF FreeR_flag for
                backward compatibility
          data_labels= None Optional labels for experimental data Normally these
                       would be something like I,SIGI or F,SIGF
          free_r_data= None Optional data file with free_r flags. By default this
                       is the same file as used for experimental data.
          free_r_labels= None Optional labels for free_r flags. Normally these
                         would be something like FreeR_flags or R_free_flags
          labin= None Optional Labin line for file with data. This is present for
                 backward compatibility only. Normally use data_labels instead.
                 Only allowed if the data file contains myFP mySIGF and
                 myFreeR_flag: LABIN FP=myFP SIGFP=mySIGFP FreeR_flag=myFreeR_flag
          search_models= None Search model PDB file Not needed if you supply an
                         hhr alignment analysis file You can supply several with
                         search_models=model_1.pdb search_models=model_2.pdb (and
                         matching list of alignment files)... NOTE: If you supply
                         a search model that contains more than one chain, then
                         the entire search model (all chains) will be used. If
                         your search model has multiple chains and you specify
                         model_already_placed=False (i.e., run MR) then MR will be
                         run with your entire search model as a single search
                         model. If you need to run MR on parts of your search
                         model, or if you need to combine several search models,
                         then you will need to run automr first, then take the
                         resulting model and use it as a search_model for
                         mr_rosetta, specifying model_already_placed=True.
          copies_in_search_models= None You can specify how many ncs copies are in
                                   each search model (Not usually necessary, used
                                   to skip combinations of ncs_copies and search
                                   models that are implausible)
          mr_rosetta_solutions= None You can read in prior solutions (.pkl files)
                                Then you can skip steps and it will pick up where
                                it left off. You can load just some solutions with
                                the keyword ids_to_load
          ids_to_load= None You can restrict the load of mr_rosetta solutions to
                       just one or more id's
          map_coeffs= None Data file (mtz format) with map coeffs ( FP PHIB FOM )
                      for rosetta electron density Normally use None; this is used
                      in iterations of mr_rosetta to pass map coeffs from
                      autobuild to the next cycle where they are used instead of
                      refinement or phaser map coeffs. If used, also should set
                      run_refine_top_models=False Always used with
                      labin_map_coeffs and map
          labin_map_coeffs= None Labin line for map coeffs file Something like
                            FP=FP PHIB=PHIM FOM=FOMM Normally use None; used by
                            mr_rosetta in iteration
          map= None Map file (ccp4 format) with map coeffs for rosetta electron
               density. This is expected if map_coeffs is specified. Normally this
               map should not contain freeR reflection information. Normally use
               None; this is used in iterations of mr_rosetta to pass map from
               autobuild to the next cycle where it is used instead of refinement
               or phaser map
          refinement_params= None You can specify a parameters file for refinement
          display_solutions= False You can display any solutions in
                             mr_rosetta_solutions and select some of them with
                             ids_to_load
          fragment_files= None Note: Starting with Rosetta version 2013wk35 you
                          can specify generate_fragment_files=True and leave
                          fragment_files=None and Rosetta will generate the files
                          for you. Fragment files (normally required for Rosetta
                          rebuilding if your template has any gaps to fill) Enter
                          one at a time with fragment_files=myfragments3.gz
                          fragment_files=myfragments9.gz To obtain the two
                          required files...go to:
                          http://robetta.bakerlab.org/fragmentsubmit.jsp and
                          register, then submit your sequence file, and when the
                          server finishes, download the two files '...9...gz' and
                          '...3....gz' These are your fragment files of length 9
                          and 3 NOTE: if your molecule has multiple chains, use
                          instead fragment_files_chain_list,
                          fragment_files_3_mer_by_chain, and
                          fragment_files_9_mer_by_chain.
          fragment_files_chain_list= None If your molecule has multiple chains,
                                     use fragment_files_chain_list,
                                     fragment_files_3_mer_by_chain, and
                                     fragment_files_9_mer_by_chain instead of
                                     fragment_files. Use fragment_files_chain_list
                                     to define which chain ID each of your
                                     fragment_files_3_mer_by_chain and
                                     fragment_files_9_mer_by_chain go with. NOTE:
                                     You only need one set of fragments files for
                                     each UNIQUE chain. So if chains A and C are
                                     the same, you just need to specify fragments
                                     for chain A. If you have two different chains
                                     A and B and fragment files frag_A_3 frag_A_9
                                     frag_B_3 frag_B_9 then you should use:
                                     fragment_files_chain_list=A
                                     fragment_files_chain_list=B
                                     fragment_files_3_mer_by_chain=frag_A_3
                                     fragment_files_9_mer_by_chain=frag_A_9
                                     fragment_files_3_mer_by_chain=frag_B_3
                                     fragment_files_9_mer_by_chain=frag_B_9
          fragment_files_9_mer_by_chain= None See fragment_files_chain_list.
          fragment_files_3_mer_by_chain= None See fragment_files_chain_list.
          use_dummy_fragment_files= False You can use dummy fragment files (this
                                    is ok if your template matches your sequence
                                    file already). If True, then you do not need
                                    to supply fragment files
          sort_fragment_files= True Sort the fragment files by name so that 9 is
                               first then 3
       output_files
          log= mr_rosetta.log Output log file
          params_out= mr_rosetta_params.eff Parameters file to rerun mr_rosetta
       directories
          temp_dir= "" Optional temporary work directory
          workdir= "" Optional work directory. Base path for all work
          output_dir= "" Output directory where files are to be written
          gui_output_dir= None Output directory for PHENIX GUI. Not used when run
                          from the command line.
          top_output_dir= None Output directory for entire set of runs
          rosetta_path= "" Location of rosetta directories All rosetta files are
                        located relative to this path You can set the environment
                        variable 'PHENIX_ROSETTA_PATH' to indicate where rosetta
                        is to be found. In csh/tcsh use something like: setenv
                        PHENIX_ROSETTA_PATH /Users/Shared/unix/rosetta In bash/sh
                        use: export PHENIX_ROSETTA_PATH=/Users/Shared/unix/rosetta
          rosetta_binary_dir= "rosetta_source/bin" Directory with rosetta scripts
                              for mr_rosetta Path is relative to rosetta_path
          rosetta_binary_name= "mr_protocols.default" Name of rosetta binary Path
                               is relative to rosetta_path+rosetta_binary_dir
                               NOTE: any suffixes such as '.default',
                               '.macosgccrelease', '.linuxrelease' are ignored
          rosetta_script_dir= "rosetta_source/src/apps/public/electron_density" 
                             Directory with rosetta scripts for mr_rosetta Path is
                              relative to rosetta_path
          rosetta_pilot_script_dir= "rosetta_source/src/apps/pilot/frank/" 
                                   Directory with development rosetta scripts for
                                    mr_rosetta Path is relative to rosetta_path
          rosetta_database_dir= "rosetta_database" Location of rosetta database
                                Path is relative to rosetta_path
       read_hhpred
          number_of_models= 1 Take the first number_of_models models from the
                            hhpred similarity analysis that are specified with
                            hhr_files. (this will give you number_of_models models
                            for each hhr file)
          number_of_models_to_skip= 0 Skip the first number_of_models_to_skip
                                    models (most similar) in hhpred file (Useful
                                    along with number_of_models to pick any one or
                                    group of templates from your hhpred file
          copies_to_extract= None Number of copies of the unique chain defined in
                             your hhr_file to extract from the template PDB file
                             (if possible). You can specify more than one value:
                             copies_to_extract='1 2 4' will try to run MR with a
                             monomer, dimer, and tetramer from each template PDB
                             file (if available). If None, then the values used
                             will be: 1, ncs_copies, and all other divisors of
                             ncs_copies, so if ncs_copies=6, the values will be 1,
                             2, 3, and 6. Note: if ncs_copies is also None and the
                             number of copies that can fit in the cell is large,
                             then this can lead to a lot of different combinations
                             being tried.
          only_extract_proper_symmetry= False Only extract groups of copies from
                                        template that form proper symmetry (i.e.,
                                        do not extract 2 molecules from a trimer).
                                        Note: not implemented. All are currently
                                        extracted.
       place_model
          run_place_model= True Run place_model: use AutoMR or place existing
                           model Each model will be used to generate
                           number_of_prerefine_models. Note: this can take a lot
                           of CPU time. You might want to only do this on a single
                           input model
          model_already_placed= False Use model_already_placed to indicate that
                                your model is already placed in the correct
                                location
          model_already_aligned= False Use model_already_aligned to indicate that
                                 your model is already edited to match your
                                 sequence
          number_of_output_models= 5 Number of Phaser molecular replacement models
                                   to consider
          align_with_sculptor= True Use phenix.sculptor and
                               phenix.mr_model_preparation to apply alignments and
                               edit templates (alternative is to use Rosetta
                               scripts).
          identity= None Percent identity between search model and target Normally
                    set automatically based on your alignment file
          identity_for_scoring_only= 25 Percent identity between search model and
                                     target to be used for LLG scoring. This is
                                     normally a fixed value so that scores from
                                     different templates can be compared.
          use_all_plausible_sg= True Often you will want to search all space
                                groups with the same point group as you may not
                                know which is correct from your data.
          overlap_allowed= 10 Solutions will be accepted by default if fewer than
                           10 percent of residues are involved in clashes. You can
                           choose to increase the percent clashes if the packing
                           is tight and your search molecule is not exactly the
                           same as the molecule in the cell.
          selection_criteria_rot_value= 75 Choose a value for your criterion for
                                        keeping rotation solutions at each stage.
                                        Percent of Best Score: AutoMR looks down
                                        the list of LLG scores and only keeps the
                                        ones that differ from the mean by more
                                        than the chosen percentage, compared to
                                        the top solution.
          fast_search_mode= True Run phaser with selection_criteria_rot_value and
                            then if no obvious solution, repeat with cutoff
                            lowered by search_down_percent
          search_down_percent= 25 Used if fast_search_mode=True. Run phaser with
                               selection_criteria_rot_value and then if no obvious
                               solution, repeat with cutoff lowered by
                               search_down_percent
          mr_resolution= 3.0 Resolution for molecular replacement
          refine_after_mr= True Refine placed model for map calculation only
                           before rescoring and rebuilding. Required for
                           denmod_after_refine
          denmod_after_refine= True After refinement, density-modify map before
                               rosetta scoring and rebuilding Note:
                               denmod_after_refine appears separately in the
                               scopes place_model and refine_top_models so you
                               need to set it separately in each place
          ps_in_rebuild= False You can choose to use a prime-and-switch resolve
                         map in map calculation/density modification in the
                         place_model step.
          find_ncs_after_mr= True Find NCS in model after placing model if
                             ncs_copies is greater than 1
          min_length_ncs= 10 Minimum chain length for NCS search
          fixed_model= None A fixed model can be added. This will be added as a
                       fixed model in molecular replacement. The sequence for this
                       model should be included in your sequence file.
          fixed_model_identity= None Percent identity between fixed model and
                                target This is a required parameter
          sufficient_number_finished= None If specified and
                                      sufficient_number_finished place_model jobs
                                      have finished, then all other jobs are
                                      ignored (they become zombie jobs and finish
                                      on their own) and mr_rosetta goes on to the
                                      next step. This is a way to avoid the
                                      problem of a really long-running and
                                      ultimately unsuccessful MR job slowing
                                      everything down. Note: you can set
                                      sufficient_number_finished while mr_rosetta
                                      is running by putting the number you want in
                                      a file called GO_ON in the directory where
                                      the log file RUN_FILE_1.log is located
                                      (something like
                                      MR_ROSETTA_3/GROUP_OF_PLACE_MODEL_1/)
          copies_of_search_model_to_place= None (Optional) number of copies of
                                           search model to place with MR. This is
                                           how many new copies of search model to
                                           add to anything already present. By
                                           default, calculated from ncs_copies,
                                           copies in the search model, and number
                                           of already-placed copies. Note
                                           difference from ncs_copies which is the
                                           total copies in the asymmetric unit
          prerefine Used if you need to improve your models before MR
             run_prerefine= False Pre-refine models before MR
             number_of_prerefine_models= 1000 Number of models to generate in
                                         prerefinement
             number_of_models_in_ensemble= 1 Number of top-scoring models to use
                                           as an ensemble for MR NOTE: Not
                                           implemented: only one model used at
                                           this point
          fixed_ensembles If you already know the placement of one or more
                          molecules you can specify them as fixed ensembles. NOTE
                          1: you are specifying location and orientation of one or
                          more copies of the search model NOTE 2: you cannot
                          specify use_all_plausible_sg if you have fixed ensembles
             fixed_ensembleID_list= None Enter the word 'ensemble_1' to indicate
                                    that you want to specify a copy of your search
                                    model that is to be fixed. To specify more
                                    than one placement just say 'ensemble_1' more
                                    than once. For example if you specify
                                    fixed_ensembleID_list=ensemble_1 and do not
                                    specify fixed_euler_list or fixed_frac_list,
                                    it will be assumed that you have one copy of
                                    your search model already placed (with the
                                    input coordinates), and you are looking to
                                    place an additional
                                    copies_of_search_model_to_place copies of the
                                    search model.
             fixed_euler_list= 0.0 0.0 0.0 Enter Euler angles (from AutoMR or
                               Phaser) for fixed component. NOTE 2: you can enter
                               more than one fixed component if you want. If you
                               do, then enter fixed_euler_list in multiples of 3
                               numbers and also fixed_frac_list in multiples of 3
                               numbers.
             fixed_frac_list= 0.0 0.0 0.0 Enter fractional offset (location) for
                              fixed component (from AutoMR or Phaser) for fixed
                              component. NOTE 2: you can enter more than one fixed
                              component if you want. If you do, then enter
                              fixed_euler_list in multiples of 3 numbers and also
                              fixed_frac_list in multiples of 3 numbers.
             fixed_frac_list_is_fractional= True Normally fixed_frac_list is
                                            fractional coordinates. You can say
                                            fixed_frac_list_is_fractional=False to
                                            instead use orthogonal angstroms to
                                            specify the locations of your
                                            ensembles.
       rescore_mr
          run_rescore_mr= True Rescore MR solutions, optionally by rosetta modeling
          nstruct= 5 Number of models to build with rosetta in rescoring if
                   relax=True
          relax= False Relax solution with rosetta modeling before rescoring NOTE
                 1: if you only have one solution to rescore (as in the case where
                 you supplied a placed model) you might want to say relax=False to
                 not bother to relax the model. NOTE 2: if your model has multiple
                 chain types then you have to use relax=False.
          include_unrelaxed_in_scoring= False Include unrelaxed (original) model
                                        in scoring
          align= True Use alignment file in relax procedure
          edit_model= False Edit model before rescoring using model_info_file
          stage_to_rescore= mr_solution You can specify the stage of solutions to
                            consider for rescoring (i.e., mr_solution,
                            rosetta_solution) Default is mr_solution; during
                            scoring of rosetta solutions it is set automatically
                            to rosetta_solution
       rosetta_rebuild
          run_rosetta_rebuild= True Run rosetta modeling on best rescored MR
                               solutions
          stage_to_rebuild= rescored_mr_solution Normally set automatically. You
                            can specify the stage of solutions to consider for
                            rebuilding (i.e., mr_solution, rosetta_solution)
                            Default is rescored_mr_solution
          max_solutions_to_rebuild= 5 Keep all solutions with at least
                                    llg_percent_of_max_to_keep, up to
                                    max_solutions_to_rebuild, and at least
                                    min_solutions_to_rebuild
          min_solutions_to_rebuild= 1 Keep all solutions with at least
                                    llg_percent_of_max_to_keep, up to
                                    max_solutions_to_rebuild, and at least
                                    min_solutions_to_rebuild
          llg_percent_of_max_to_keep= 50 Keep all solutions with at least
                                      llg_percent_of_max_to_keep, up to
                                      max_solutions_to_rebuild, and at least
                                      min_solutions_to_rebuild
          rosetta_models= 100 Number of models to build with rosetta in rebuilding
          chunk_size= 1 If background=False, divide the nstruct models into chunks
                      of chunk_size or smaller to keep the length of individual
                      jobs shorter
          edit_model= True Edit model before use
          superpose_model= False Superpose the rebuilt model on the original
                           model. (Restore original location and orientation as
                           much as possible.)
       rosetta_rescore
          run_rosetta_rescore= True Run Phaser rescoring on top rosetta rebuilt
                               models
          percentage_to_rescore= 20 Rescore percentage_to_rescore of top rosetta
                                 solutions with Phaser RNP LLG scoring
          min_solutions_to_rescore= 2 Rescore at least percentage_to_rescore of
                                    the rosetta, models, and at least
                                    min_solutions_to_rescore Usually choose at
                                    least 2 so that they can be compared
       similarity
          run_similarity= False Identify similarity of top solutions
          required_cc= 0.20 Value of required_cc for number_of_required_cc top
                       solutions to carry on
          number_of_required_cc= 5 Number of top solutions with CC of required_cc
                                 or better to top solution required to carry on
       refine_top_models
          run_refine_top_models= True Refine models to get map before relaxing
                                 them to get new map coeffs. Use unrefined model
                                 in relaxation however
          stage_to_refine= None You can specify the stage of solutions to consider
                           for rescoring (i.e., mr_solution, rosetta_solution)
                           Default is rosetta_solution; during scoring of rosetta
                           solutions
          sort_score_type= None You can specify the scoring method for choosing
                           top models to refine
          percent_to_refine= 20 Percentage of top models to refine
          denmod_after_refine= True After refinement, density-modify map before
                               rosetta scoring and rebuilding. Note: this appears
                               separately in the scopes place_model and
                               refine_top_models so you need to set it separately
                               in each place
          remove_clashing_residues= None Remove clashing residues before
                                    refinement and autobuilding
          clash_cutoff= 1.5 Remove clashing residues before refinement and
                        autobuilding if remove_clashing_residues=True and clash is
                        worse than clash_cutoff.
       average_density_top_models
          run_average_density_top_models= True Average density from top models
          percent_to_average= 100 percentage of refined models to use in averaging
       relax_top_models
          run_relax_top_models= True Relax rosetta rebuilt solutions, scoring with
                                LLG
          stage_to_relax= None You can specify the stage of solutions to consider
                          for relaxing (i.e., mr_solution, rosetta_solution)
                          Default is rescored_rosetta_solution; during
                          relax_top_models
          number_to_relax= 2 Number of top models to relax
          nstruct= 5 Number of rosetta relaxed models to build for each starting
                   model in relaxation (best will be chosen)
       autobuild_top_models
          run_autobuild_top_models= True Autobuild top relaxed_rosetta_solutions
          number_to_autobuild= 2 Number of top models to autobuild
          quick= False Use fewer cycles
          phase_and_build= False Use phase_and_build to rebuild models instead of
                           autobuild (much faster, but not quite as good)
          macro_cycles= None Number of overall cycles for phase_and_build
                        (macro_cycles) or autobuild (n_cycle_rebuild_max) Set by
                        default if None (recommended)
          morph= False You can choose whether to distort your model in order to
                 match the current working map. This may be useful for MR models
                 that are quite distant from the correct structure. [See also
                 repeats_with_morph which will instead morph your model at the
                 beginning of each repeat cycle up to repeats_with_morph times.]
          edit_model= True Edit model before rescoring using model_info_file
          use_map_coeffs= True Use current best map as starting map coeffs in
                          autobuild (Only applies if phase_and_build=False)
       setup_repeat_mr_rosetta
          run_setup_repeat_mr_rosetta= True Set up for running mr_rosetta again
                                       using results from current run. Must be run
                                       before repeat_mr_rosetta
          repeats= 1 Maximum repeats of running mr_rosetta. (Runs one cycle if
                   repeats=0)
          template_repeats= 0 Number of repeat cycles in which to restart from the
                            template (the MR solution corresponding to best
                            current model) instead of continuing with best current
                            model. This may be useful for very poor starting
                            models. This is normally combined with morph_repeats
                            (i.e., morph the template at the end of one cycle and
                            use that in the next cycle
          morph_repeats= 0 Number of repeat cycles in which to morph the starting
                         model corresponding to best current model instead of
                         continuing as is with best current model. This may be
                         useful for very poor starting models. This is normally
                         combined with template_repeats (i.e., morph the template
                         at the end of one cycle and use that in the next cycle.
                         [See also morph which instead applies morphing during
                         autobuilding.]
          number_to_repeat= 1 Number of top models to re-run in MR rosetta Usually
                            this should be 1. If you are using condor, or set
                            one_subprocess_level=True, it must be 1
          acceptable_r= 0.25 Used to decide whether the model is acceptable enough
                        to quit if it is not improving much. A good value is 0.25
          minimum_delta_r= None Used to decide whether the model is improving.
                           Skip additional cycles if improvement in R since last
                           is less than minimum_delta_r
       repeat_mr_rosetta
          run_repeat_mr_rosetta= True Run mr_rosetta again using results from
                                 current run
          copies_in_new_search_group= 1 Number of copies of model to used to
                                      create a search model that is to be placed
                                      with MR on repeat cycles (if not all ncs
                                      copies are found on the first cycle). If you
                                      are searching with a dimer on the first
                                      cycle, you might want to consider
                                      copies_in_new_search_group=2.
          update_map_coeffs_with_autobuild= True Update map coeffs only during
                                            autobuild (not with refinement) on
                                            cycles of iteration
       rosetta_modeling
          map_resolution= 3. Map resolution in rosetta modeling
          map_grid_spacing= 1.5 Grid spacing in map in Rosetta rebuilding
          map_weight= 1. Weighting on map in Rosetta rebuilding. Ignored if
                      fast=True
          map_window= 5 Smoothing distance (residues) for map scoring. Ignored if
                      fast=True
          include_solvation_energy= True Include solvation energy term in Rosetta
                                    modeling If you are modeling a membrane
                                    protein you may want to turn this off. Note:
                                    if False, then a weights_file is created with
                                    the specification of fa_sol 0.0
          weights_file= None Optional weights file for Rosetta. If specified, this
                        will be used instead of the file
                        $PHENIX_ROSETTA_PATH/rosetta_database/scoring/weights/score
                       12_full.wts
       crystal_info
          resolution= 0. high-resolution limit for map calculation
          space_group= None You can specify the space group. If None then the
                       space group in your input data file or its inverse will be
                       used unless you specify use_all_plausible_sg=True
          chain_type= *PROTEIN DNA RNA Chain type (for identifying main-chain and
                      side-chain atoms)
          ncs_copies= Auto Number of copies of unique sequence defined in sequence
                      file expected in the a.u. This is how many molecules there
                      are in the asymmetric unit. Default is Auto, in which case
                      the value of ncs copies leading to solvent content closest
                      to 50% (based on unique chains in sequence file and volume
                      of asymmetric unit) will be chosen. NOTE: you can specify
                      more than one value with ncs_copies='1 2 7', in which case
                      each will be tried. You can also specify None in which case
                      all likely values (those leading to solvent content from
                      0.35 to 0.65) will be tried.
       control
          verbose= False Verbose output
          debug= False Debugging output
          raise_sorry= False Raise sorry if problems
          dry_run= False Just read in and check parameter names
          nproc= 1 Number of processors to use
          group_run_command= "sh " Command to use to run multiple jobs This may be
                             sh if you are using a single machine (where you might
                             set background=True) or something like 'qsub' or
                             'qsub -q all.q@theta' on a cluster (where you should
                             leave background=False)
          queue_commands= None You can add any commands that need to be run for
                          your queueing system. These are written before any other
                          commands in the file that is submitted to your queueing
                          system. For example on a PBS system you might say:
                          queue_commands='#PBS -N mr_rosetta' queue_commands='#PBS
                          -j oe' queue_commands='#PBS -l walltime=03:00:00'
                          queue_commands='#PBS -l nodes=1:ppn=1' NOTE: you can put
                          in the characters '' in any queue_commands line and this
                          will be replaced by a string of characters based on the
                          path to the run directory. The first character and last
                          two characters of each part of the path will be
                          included, separated by '_',up to 15 characters. For
                          example
                          'test_autobuild/WORK_5/AutoBuild_run_1_/TEMP0/RUN_1'
                          would be represented by: 'tld_W_5_A1__TP0_1'
          condor_universe= vanilla The universe for condor is usually vanilla.
                           However you might need to set it to local for your
                           cluster
          add_double_quotes_in_condor= True You might need to turn on or off
                                       double quotes in condor job submission
                                       scripts. These are already default
                                       elsewhere but may interfere with condor
                                       paths.
          condor= None Specifies if the group_run_command is submitting a job to a
                  condor cluster. Set by default to True if
                  group_run_command=condor_submit, otherwise False. For condor job
                  submission mr_rosetta uses a customized script with condor
                  commands. Also uses one_subprocess_level=True
          one_subprocess_level= None Specifies that a subprocess cannot submit a
                                job
          single_run_command= "sh " Command to use to run single jobs Normally
                              this is sh
          last_process_is_local= True If true, run the last process in a group in
                                 background with sh as part of the job that is
                                 submitting jobs. This prevents having the job
                                 that is submitting jobs sit and wait for all the
                                 others while doing nothing
          background= None Run in background. If None, automatically set to True
                      if nproc is greater than one and group_run_command is sh
          ignore_errors_in_subprocess= True Generally use
                                       ignore_errors_in_subprocess=True to ignore
                                       errors in sub-processes. This allows you to
                                       continue even if a few jobs crash. If all
                                       jobs in a group crash, the process will
                                       stop. NOTE: if a job hangs or never
                                       runs...this will not be detected and you
                                       will have to either put a file with the
                                       name FINISHED in the directory where the
                                       job was to run (e.g,
                                       MR_ROSETTA_3/GROUP_OF_PLACE_MODEL_1/RUN_1/FI
                                      NISHED) or stop the whole job by putting a
                                       file with the name STOPWIZARD in the main
                                       run directory (e.g.,
                                       MR_ROSETTA_3/STOPWIZARD)
          check_run_command= False Try out run command to make sure it works Use
                             False if your queue may not be available at the
                             beginning of your run. Use True if you want to check
                             things out
          max_wait_time= 100 Maximum time (sec) to wait for a file to be written
                         (Useful for queues or nfs-mounted systems)
          check_wait_time= 10 Time between checks for finishing jobs (sec)
          wait_between_submit_time= 1.0 You can specify the length of time
                                    (seconds) to wait between each job that is
                                    submitted when running sub-processes. This can
                                    be helpful on NFS-mounted systems when running
                                    with multiple processors to avoid file
                                    conflicts. The symptom of too short a
                                    wait_between_submit_time is File exists:....
          wizard_directory_number= None Directory number for MR_ROSETTA_xx.
                                   Normally None except if called from GUI
          n_dir_max= 100000 Maximum number of directories to create (must be as
                     big as nproc or nstruct/chunk)
          number_to_print= 5 Number of entries to print in long lists
          write_run_directory_to_file= None The working directory name is written
                                       to this file
          rosetta_command= None Command for Rosetta (like -MR::disulf 12:13 22:39)
          fast= None NOTE: Not tested. For Rosetta versions 2013wk35 and later you
                can speed up Rosetta calcalations (this sets -MR::fast flag in
                Rosetta)
          generate_fragment_files= None For Rosetta versions 2013wk35 and later
                                   you can generate fragment files automatically
                                   using the Rosetta database
          resolve_command_list= None You can supply any resolve command here for
                                autobuild NOTE: for command-line usage you need to
                                enclose the whole set of commands in double quotes
                                (") and each individual command in single
                                quotes (') like this:
                                resolve_command_list="'no_build' 'b_overall
                                23' "
          start_point= *place_model rescore_mr rosetta_rebuild rosetta_rescore
                       similarity refine_top_models average_density_top_models
                       relax_top_models autobuild_top_models
                       setup_repeat_mr_rosetta repeat_mr_rosetta You can specify
                       what point to start at by supplying a rosetta_solutions
                       .pkl file and specifying a place to start
          stop_point= place_model rescore_mr rosetta_rebuild rosetta_rescore
                      similarity refine_top_models average_density_top_models
                      relax_top_models autobuild_top_models
                      setup_repeat_mr_rosetta repeat_mr_rosetta You can specify a
                      step to stop at (after completing this step) For example, to
                      carry out just place_model, you can say
                      start_point=place_model stop_point=place_model.
          clean_up= None At the end of the autobuild runs the TEMP directories
                    will be removed if clean_up is True.
          add_id= True Add solution id to names of models
       non_user_params
          file_base= None String defining intermediate file names Normally set
                     automatically. If given, must match the 3rd word on the first
                     line of the alignment file
          print_citations= True Print citation information at end of run
          highest_id= 0 Start ID numbers with highest_id+1
          is_sub_process= False identifies if this is a sub-process or top-level
                          job
          dummy_autobuild= False Allows you to skip actual run of autobuild
          dummy_refinement= False Allows you to run refinements but not to change
                            coordinates
          dummy_rosetta= False Allows you to skip models from rosetta steps
          prerefine_only= False Set internally to allow pre-refinement without data
          skip_clash_guard= True Skip clash guard check in refinement
          correct_special_position_tolerance= None Adjust tolerance for special
                                              position check. If 0., then check
                                              for clashes near special positions
                                              is not carried out. This sometimes
                                              allows phenix.refine to continue
                                              even if an atom is near a special
                                              position. If 1., then checks within
                                              1 A of special positions. If None,
                                              then uses phenix.refine default. (1)
          ncs_in_refinement= *torsion cartesian None Use torsion_angle refinement
                             of NCS. Alternative is cartesian or None
          comparison_mtz= None Allows you to compare results with an existing map
                          file
          labin_comparison_mtz= None labin line for comparison mtz
          write_local_files= False Used to create test pickle files only with
                             phenix.mr_rosetta mr_rosetta_solutions=results.pkl
                             display_solutions=True write_local_files=true
          rosetta_fixed_seed= None Fixed seed for rosetta (so that the same answer
                              is always obtained. Use for regression tests only).