-------------------------------------------------------------------------------
There are several help documents in this distribution:

   README (this document, command line arguments, file descriptions, misc.)
   IntroductionToRosetta++.html
   Rosetta++CodingGuidelines.html
   Rosetta++CommentingGuidelines.html
   ObjexxFCL/ObjexxFCL.doc/ (user guide for the Objexx Fortran Class Library)

   Also, for more information see:
        http://www.rosettacommons.org/tiki/
-------------------------------------------------------------------------------

COMMAND LINE ARGUMENTS::

MODE:: 1 option allowed, searched for in order listed here
    most modes require 'code pdbname chain' as the first three arguments
    'modes' define the protocol that will be run
  -score     (add -fa_input for fullatom scoring)
  -refine
  -assemble
  -idealize  (add -fa_input for fullatom idealization)
  -relax
  -design
  -dock
  -interface
  -membrane
  -loops
  -pdbstats
  -pKa       (fullatom-only pH titrations)
  -abrelax   (abinitio followed by relax)
  -domain_insertion (uses an insertion file which lists the input proteins
  or domains using -l)
  -pose_looping (uses an insertion file with the loop locations)
  (none)       ab initio
  -antibody_modeler to create an antibody by assembling templates,
    cdrs and building H3 (requires pdb files for all loops that have
    to be assembled, required H3_CTERM & H3_NTERM special fragment
    files if h3 building is required)

-------------
MODE-SPECIFIC OPTIONS::  (not applicable in all modes)

  -s <start_file>            Starting structure, (overrides the -l options)
  -l <list>                  Use starting structures in the given list

-------------------------------------------------------------------------------
de novo folding (ab initio):
-------------------------------------------------------------------------------
  -increase_cycles <float>  Increase number of cycles at each stage of
                              fold_abinitio (or pose_abinitio) by this factor.
  -number_3mer_frags <int>  Number of top 3mer fragments to use in
                              fold_abinitio protocol (default is 200)
  -number_9mer_frags <int>  Number of top 9mer fragments to use in
                              fold_abinitio protocol (default is 25)
  -abinitio_temperature     Temperature used in fold_abinitio (default 2.0).
  -vdw_reweight <float>	    Reweight contribution of van der Waals score to
				     total score by this scale factor (default 1.0).
  -env_reweight <float>	    Reweight contribution of environment score to total score
				     by this scale factor (default 1.0).
  -pair_reweight <float>    Reweight contribution of pair score to
				     total score by this scale factor (default 1.0).
  -cb_reweight <float>	    Reweight contribution of C_beta (packing density) score to
				     total score by this scale factor (default 1.0).
  -sheet_reweight <float>   Reweight contribution of sheet score to
				     total score by this scale factor (default 1.0).
  -ss_reweight <float>	    Reweight contribution of strand-strand score to
				     total score by this scale factor (default 1.0).
  -hs_reweight <float>	    Reweight contribution of helix-strand score to
				     total score by this scale factor (default 1.0).
  -rsigma_reweight <float>  Reweight contribution of R-sigma score
				     (strand pair distance/register) to
				     total score by this scale factor (default 1.0).
  -rg_reweight <float>	    Reweight contribution of radius of gyration to
				     total score by this scale factor (default 1.0).
  -parallel_weight <float>  Reweight score for parallel strand pairing between residues
				whose strands are separated by more than 10 A.
  -antiparallel_weight <float>
			    Reweight score for antiparallel strand pairing between residues
				whose strands are separated by more than 10 A.
  -strand_dist_cutoff <float>Specify distance cutoff (in Angstroms) between strand dimers
			      within which they are called paired. Default is 6.5.
  -stretch_strand_dist_cutoff
			    Allow strand distance cutoff to change from 6.5 A
			    to a larger value (specified by "-max_strand_dist_cutoff <float>")
			    linearly scaled according to sequence separation
			    over a range specified by "-seq_sep_scale <float>"
  -rsd_wt_helix <float>	    Reweight env,pair,cb for helix residues by this factor.
  -rsd_wt_strand <float>    Reweight env,pair,cb for strand residues by this factor.
  -rsd_wt_loop <float>	    Reweight env,pair,cb for loop residues by this factor.
  -rand_envpair_res_wt      Reweight of env,pair,cb contributions by random factors
			    (between 0.5 and 1.2) for each residue.
  -rand_SS_wt		    Reweight helix-strand, strand-strand, sheet, and rsigma
			    scores by random factors between 0.5 and 1.5.
  -random_parallel_antiparallel
		            For each decoy, randomly choose whether to drastically
			    upweight long range parallel strand pairings (by a random
		            factor up to 10-fold) and downweight long range antiparallel
			    pairings, or vice versa.
  -optimize_rmsd	    Optimize a score function composed of van der waals score plus
			     a component proportional to -1/rmsd.
  -handedness_score         Evaluate whether any beta-alpha-beta connections are
			     left-handed during run; if so, adds a penalty to sheet score.


de novo folding w/ csts:
  -fast                      Runs protocol without minimization or gradients,
                              giving a significant speed advantage
                              For NOE data only, -fast yields essentially
                              the protocol published by Bowers et al., JBNMR, 2000.
                              For RDC data only, -fast omits the refinement step included
                              in examples published in Rohl&Baker, JACS, 2002.
                              without the -fast option.
 -use_fold_constraints_no_minimize
			     No minimization moves in fold_constraints protocol.
			      Useful for testing whether fragment moves alone can
			      recapitulate a given structure.

ab initio (score certain amino acid contacts):
  -score_contact_flag        To turn the contact scoring on.
  -score_contact_file        Name of a file  containing the probabilities.
			      Default filename is <5lettercode>.contact
                              The format is a line with the number of contacts, then:
                              aa1(integer) aa2(integer) probability(double)
                              one contact per line, everything after the
                              third word will be ignored.
  -score_contact_weight      To set the weight - default is 1
  -score_contact_threshold   Prediction probabilities above this threshold result
                              in a bonus for the decoy, probabilities below this
                              threshold result in a penalty - default is 0.5
  -score_contact_seq_sep     Only AA separated at least this number in sequence are
                              considered - default is 2
  -score_contact_calpha      Use distances between alpha carbons, not
                              centroids to assign bonuses.
  -score_contact_distance    Give distance under which contact is given bonus.
                              [Default is 8 angstroms  (centroid/centroid), or
                              11 angstroms (c_alpha/c_alpha).]
  -score_contact_readindist  Instead of using score_contact_distance, read in
                              distances from contact file as fourth column:
                              aa1(integer) aa2(integer) probability(double)
                              distance(double)
  -score_contact_fullatom    By default the "contact score" is off during
			      full atom; this option turns it on.

-------------------------------------------------------------------------------
loops mode:
-------------------------------------------------------------------------------
  -permute                   Permute library rather than building from it
  -screen                    Screen library and output new library
  -fast                      Fast protocols for screen and/or permute
  -fold                      Build loops (default if no protocol specified)
  -fa_refine                 Fullatom refinement
  -fold_with_dunbrack        An alternative loop modeling protocol
                              which combines frag insertion and dunbrack
                              loop closure protocol during each step
                              move. It is independent from -fold,
                              -permute or -fa_refine options and it
                              does not require a loop library.
                              Currently only ONE loop can be built.
  -idl_breaks                Idealize the final structure, removing breaks
  -sequential                Sequential building of loops
  -loop_library <ext>        Specify extension for loop library (def loops)
  -fix_natsc                 Use native rotamers for template
  -trim                      Trim template to include only residues within
                              a distance cutoff to a loop region
  -one_loop_file <file>      Specify a single file to use as the loop_library
                              path is relative to calling directory
  -score_all_loops           Scores each loop+template individually at startup
  -start_from_extend         Set loops in the starting structure in
                              extended conformation first and then
                              build.
  -grow                     Iterate through a loop library, generating a
                             structure with each loop inserted (with
                             minimization at anchor residues only).
			     Note: if the loop is internal
                             the C-term domain must be idealized
			     Note these are centroid level structures (def
			     scorefunction = score3L) and using the
			     -atom_vdw_set highres option is recommended.
			   Also note: You must increase max_loop_depth in
				loops_ns.cc to the size of your loop library.
			   Another note: this uses dump_pdb directly, so you are
			     looking at the dumped pdb's that are named after the
			     loop name in the loop library, not <your_protein>_0001.pdb
			   As when using loop libraries in other loopmode protocols, the
			   loop library must overlap by one residue with your protein.
     grow flags
     -vdw_max <value>       Specify a maximum value. Structures with vdw higher
			     than this value will not be output (clashes).
     -rg_max <value>	    Specify a maximum value. Structures with rg higher
			     than this value will not be output (extension not
			     interacting with protein very well).
     -wiggle_jxn	    Monte carlo minimize the phi/psi of the junction
			    (aka anchor) residue.

  -pose -fold_with_dunbrack  The pose version of the loop modeling
			     protocol using -fold_with_dunbrack. It
			     supports multiple loops and will fold
			     them in centroid in the order of
			     input. And then fullatom refinement is
			     followed on all the loops after each move
			     step. It works with -trim, -fix_natsc
			     options. And use -fast to speed up the
			     protocol by reducing the number of cycles
			     of trial.
  -pose_loops_file <file>    specify a single file to use as the loop
			     file. Path is relative to calling dir. If
			     no such a file is found, the second
			     option is to look in the starting dir for
			     "start_name.pose_loops". If failed, it
			     will try to read in a normal loop library
			     file as explained above.
  -refine_only               skip the centroid loop building and go to
			     the fullatom refinement directly. Only
			     works in -pose -fold_with_dunbrack mode.
  <pose_loops_file format>   four number separated by white space per
			     line, e.g, 120 134 128 1
			     which defines loop starts at residue 120,
			     ends at residue 134, is cut at residue
			     128 and should be modeled from extended
			     conformation( 0 otherwise ). Note that
			     start-1 <= cut <= end indicates a fixed
			     cutpoint within the loop region,
			     otherwise a cutpoint will be randomly
			     chosen. Multiple loops can be input and
			     they will be built by the order provided.

-------------------------------------------------------------------------------
idealize mode:
-------------------------------------------------------------------------------
  -local                     Valid in idealize mode only, local idealization
                              rather than global

-------------------------------------------------------------------------------
relax mode:
-------------------------------------------------------------------------------
  -cenrlx                    Run only the centroid-based protocol
  -farlx                     Run only the fullatom-based protocol
  -looprlx                   Run only the loop relax protocol
  -minimize                  Minimize backbone or sidechain
  -bb_only                   Minimize holding sidechain fixed
  -sc_only                   Minimize holding backbone fixed (fullatom
                             only)
  -use_input_bond            Minimize or refold using the bond lengths
                             and angles from the starting structure,
			     useful for minimizing a structure w/o
			     idealizing it first.
  -sim_aneal                 More intensive simulated annealing protocol
  -force_expand              Moves the structure greater than a rms_threshold from
                              starting structure before beginning relax.
                              Works only with cenrlx.
  -farlx_cycle_ratio <float> Modify the farlx cycle number by this ratio to
                             shorten or extend the relax runs.
  -no_farlx_rot_trials       Disable rotamer_trials in fullatom relax
  -farlx_rot_trials          Enable rotamer_trials in fullatom relax (defunct; now rot. trials on by default on all builds)

looprlx submode:
  -looprlx                   Run only the loop relax protocol to build loops in
                             centroid mode.
  -fullatom_loop             Build loops with fullatom energy function.
  -loop_file <file>          Specify the loop regions to be rebuilt.
  -loop_model                Use this flag when modeling loops with 0.00 at the coordinate
                              field of the starting pdb (i.e. de novo loop modeling case).
  -score_filter_cutoff <float>
                             Values from 0.0 to 1.0. Accept the
                              newly built loops with its centroid score percentile cutoff.
                              0.1 means only accept loops with score6 among the top 10%
                              built so far.
                              Default is 0.5.
  -rmsd_tol <float>          Tolerance for RMSD deviation from the original loop
                              conformation for the newly built loops. Default is 1000.0.
  -no_combine_if_fail        Don't combine consecutive loop regions if failed
                              to close a loop.
  -chain_break_tol <float>   Tolerance for accepting chain breaks in the loop region.
                              Default is 0.2.
  -looprlx_idealization      Idealize loops after rebuilding them.
  -coordcst <file>           Coordinate constraint file used for picking fragments which
                              will construct loops satisfying the coordinate constraints.
  -alter_seqs <file>         fasta format sequence alignment file, used to map the homologous
                              sequences to the target sequence loop region.
  -random_loop               Randomization of the loop taking-off stems, skip some loops,
                              or combine sequentially neighboring loops with the following two
                              parameters:
  -loop_combine_rate <float>
                             Use values from 0.0~1.0. The chance of a loop being
                              combined with a sequentially neighboring loop
                              Default is 0.0 (no combination).
  -loop_skip_rate <float>    Use values from 0.0~1.0. The chance of a loop region being skipped.
                              Default is 0.0 (No skipping).
  -looprlx_cycle_ratio <float> Use values from 0.5 ~ inf to gauge the looprlx
                              cycles.
  -output_loops_built        Write out a .loopout file for the rebuilt loops.
  -loop_farlx                Fullatom relax of the loops.
  -fast_loop_farlx           Reduced cycles in loop_farlx.
  -looprlx_fix_natsc         Fix sidechains in non-loop regions.
  -loop_farlx_only           Only does fullatom relax of the loop regions.
  -loopout_file <file>       Use with -loop_farlx_only to specify regions to be
                              full-atom refined as loops.
  -loop_farlx_random_cut     Use random cut-points when fullatom relax loops.
  -obligate_loops            Define loops to be built by obligation. Overrides
                              -loop_skip_rate.
  -loops_subset              Only does a subset of all the defined loops.
  -ccd_closure               ccd-close after fragment trials when build loops.
  -use_homolog_env_stats     Apply homolog structure based env potential during
                              loop relax
    -env_stats_file <string>  File which contains the homolog env stats
  -use_homolog_pair_stats    Apply homolog structure based pair potential during
                              loop relax
    -pair_stats_file <string> File which contains the homolog pair stats
  -use_homolog_env_stats_in_farlx  Apply homolog structure based env potential
                                    during fullatom relax
  -use_homolog_pair_stats_in_farlx Apply homolog structure based pair potential
                                    during fullatom relax
-------------------------------------------------------------------------------
design mode:
-------------------------------------------------------------------------------
  -onlypack                  Just pack rotamers, don't move backbone
  -fixbb                     Design new sequence, don't move backbone

  -sym_des_units <int>	     Enable symmetric design, specifying the number of subunits
                              in the system (eg. "3" for a homotrimer). Note that the backbones
                              must match EXACTLY. Energies are computed using only the first
                              subunit (by resnum), allowing modeling of periodic systems.

  -pack_in_parallel	     Using a fixed backbone design approach, optimize a single amino acid
                             sequence for multiple structures or sub-structures. If there are
                             distinct states, they must be included in the same pdb file separated
                             by >100 Angstroms.
                             See Ambroggio and Kuhlman JACS 2006 for more details.
  -dock_des_min_inter        Protocol for interface design: dock and then interface design using
                             the design_minimize_interface protocol.  Uses docking site
                             constraints if provided in .cst file.
  -prog_grid_dock        This flag works with -dock_des_min_inter, -design_loops dock, and -dock_des_min_inter
                             At the beginning of each run, the docking position is moved to the next position
                             defined by a .axes file (see -grid_dock below for description). To iterate through all defined
                             grid positions, set nstruct to be equal to the total possible number of positions.

  pack_in_parallel flags:
  =======================
  -equiv_resfile          pack_in_parallel requires that the user create a file in which the
                             residues that need to have the same amino acid type are given. The
                             file path must be supplied after the -equiv_resfile flag. An example
                             file looks like this:

                             A 1-32 B 1-32 C 1-32
                             A 1-29 D 1-29
                             A 1-5  E 5-1
                             A 7 20 9 F 2 10

                             In this file, residues 1 to 32 of chain A correspond to residues 1 to 32
                             of chains B and C. Residues 1 to 29 of chain A correspond to residues 1 to
                             29 of chain D (and therefore also 1 to 29 of chains A-C). Residues 1 to
			     5 of chain A correspond to residues 5 to 1 of chain E. Residues 7, 20, and
			     9 of chain A should have the same amino acids as each other and as reisdues
			     2 and 10 of chain F.
			     Numbers separated by dashes "-" are considered ranges. Numbers separated
			     by spaces are considered lists.
			     NOTE: If used in combination with the -chain_in_preferred_state described
                             below, the "state type" is defined here along with the resfile.
  -conv_limit_mod            This optional flag of pack_in_parallel must be followed by an integer
                             which will scale the number of iterations. If your results are not
			     converging, try higher numbers. The default is 3.
  -reverse_comp		     Design a gene in which one structure is encoded by the sense strand and the
			     other structure is encoded by the antisense strand.
  -chain_in_preferred_state  This flag must be followed by a chain ID (e.g. A). It indicates that
                             negative design will be used and sets a preferred state. In addition to
			     minimizing the energy of the preferred state, the probability of the
			     preferred state will be maximized according to a partition function
			     similar to that described in Havranek & Harbury 2003.
  -chain_in_ref_state        This flag must be followed by a chain ID (e.g. D). It indicates that
                             there is a reference state (e.g. wild type) and calculates the lowest
                             energy for this state for the probability calculations described above.
                             NOTE: The mutable positions for the designable states must be set to
                             NATAA for the wild type state in the resfile


  ========================
  -natrot                    Just score native structure
  -point_mutation <int>      Perform a single mutation to the input structure at indicated residue (pdb numbering).
                             The neighbors of this residue are relaxed in the process.
  -new_aa                    Used with -point_mutation.  1 letter AA code for new amino acid.
  -resfile                   Follow with file that specifies residues to design
                              *to design disulfides, resfile required to place cysteines using PIKAA
                              *to design disulfides, -fix_disulf also required (see below)
                             Resfile format and options described in sample_resfile
  -no_new_CGP                 Disallow Cys, Gly, and Pro everywhere in a design,
  			     unless the starting residue is Cys/Gly/Pro

  -output_design_movie       Write out a whole lot of output PDBs corresponding to a packer trajectory
  -num_movie_frames          Specify the number of movie frames to actually write (default is all)

  -pdbout                    Beginning of output file name
  -remark_output             Remark all the extra outputs from rosetta
  -ndruns                    How many design runs
  -rotamerize                Rather than calculating energies and repacking,
                              just select the rotamer from the library that
                              has the lowest heavy atom rmsd from the input
                              native
  -rot_opt                   Optimize the onebody energy of rotamers before calculating
                              twobody energies using rotamer_trials
  -design_trials             Optimize a structure generated by the packer by applying
                              rotamer_trials, allowing for changes in amino acid
                              identity as well as conformation
  -mcmin_trials              A rotamer/sequence optimization procedure in which following each rotamer
                              substitution the chi angles of the new rotamer and the neighboring
                              residues are minimized before evaluating the substitution with the
                              metropolis criterion.  This procedure is slow so it has been
                              implemented as a follow up to the standard monte_carlo rotamer search.
  -interface_electrostatic_complementarity_shift   Apply an offset to reference energies of
     	                      charged residues, with a different sign for each chain
 			      (ie. to get electrostatic complementarity for interface design)
  -favor_native_residue      Will favor the staring amino acid type by the energy amount you specify
                              after the flag. so -favor_native_residue -1.5 favors the native by 1.5kcal
                              per position. -favor_native_residue +1.5 dis-favors the native by the same
                              amount.

  -favor_PDB_sequence PDBfile  Treat the sequence in the given PDB as native when doing design

  -favor_polar               Will favor amino acids specified as POLAR in rosetta by the specified energy
                              amount (see above).
  -favor_nonpolar            Will favor amino acids not specified as POLAR in rosetta by the specified energy
                              amount (see above).
  -favor_charged             Will favor amino acids specified as CHARGED in rosetta by the specified energy
                              amount (see above).
  -favor_aromatic            Will favor amino acids specified as AROMATIC in rosetta by the specified energy
                              amount (see above).
  -profile                   Write out checkpoint style profile matrix and fasta
                              format file for designed sequences
  -use_bw                     Use optimized weights for beta sheet protein
  -use_aw                     Use optimized weights for all fold protein design
  -weightfile [file]          Use packer weights read from the specified file
  -use_conformer [file]     Use bbdep conformer library (design mode only for now).(currently defunc)
  -use_bbind_conformer [file]
                            Use bbind conformer library.  A file containing granularity scales for each type
                              of amino acids should be specified. currently only look for the file inside
                              rosetta_database/bda_bbind/.  If no file is given, the default is bbindConfLib1.txt,
                              which uses roughly the same number of rotamers as -ex1 flag with normal dunbrack rotamers.
                              User can generate this file by specifying the granularity for a specific amino acid
                              according to the example provided in bbindConfLib1.txt. (e.g. GLU 0.2)
                              Another scale file is also provided "bbindConfLib2.txt", and this file specifies the
                              scales that roughly give "-ex1 -ex2aro_only" equivalent number of rotamers.

                              Both use_conformer, use_bbind_conformer flags turn off trie (-no_trie), and
                              they use both his tautomers (-try_both_his_tautomers) by default. The granularity is
                              between 0.1 and 0.9 for bbdep libraries and between 0.4 and 1.8 for bbind libraries.
                              This defines the cluster RMSD distance used to generate the libraries, reflecting
                              the "granularity" of the conformers used. 0.1 is the biggest and 0.9 is the smallest library;
                              similarly for bbind libraries.
                              The libraries were generated and provided by the Mayo lab at Caltech.
                              ** if publishing using results with these libraries, you HAVE TO quote the Mayo lab paper **

  -directed_design 	On a fixed backbone, run a directed design protocol. During DirectedSimAnnealer::run,
			selected two-body interactions are upweighted during moves that change the amino acid type,
			but not during moves that change only the conformation. Therefore, sequences will be biased
			towards the weighted energy function, but conformations will not (other checks are in place to
			make sure that the conformation does not change upon repacking). Essentially trades
			overall energy available in sequence space for energy in specific interactions. No extra
			memory usage, ~3x runtime in simanneal.

			FILE FORMAT:
			weight 2
			residue 94
			residue 93
			respair 55 66
			respair 13 66

designing interfaces:
  -alter_spec                Design mutations predicted to create orthogonal
                              binding interfaces
  -mutate_cluster            Calculate ddg for clusters of mutations automatically
  -design_inter              Just redesign residues at a binding interface
                              Note: only the first two chains are considered
  -fix_target_seq [int]      Repack instead of redesign "target" of interface
                              Note: int refers to the chain number to be redesigned,
			      as per the order in the input PDB
  -repack_inter              Repack residues at a binding interface (see design_inter)
  -design_unbound            Choose interface residues as per design_inter/repack_inter,
                              but pull backbones apart and redesign/repack the unbound state

  -design_min_inter          Design with flexible backbone minimization of interface
                              residues
  -design_loops
	dock        		           Combine design, loop refinement, and small rigid body docking
                              movements to design an interface.  Run with -loops
                              option (the .loops file only needs to give the residue
                              ranges of loops, no backbone conformations are needed.)
                              Define what residues are to be designed with a resfile.
	hold        		           Combine design and loop refinement.No docking.Run with -loops option and
                              don't need the fragment file, but do need the .loops file to give the residue range
                              of loops.Can redesign with a resfile or not(automatically design the loop region and
				pack the contact neighbors)

  -desock                    Iteratively call design and dock_mcm
  -tail -begin <start res> -end <end res>
                             Allows for flexible backbone design of
                              protein terminal region. Primarily
                              developed for enhancing binding affinity.
  -tail_fix_helix            Same as -tail option but does not allow internal backbone
                              motions in helical regions.
  -set_interface_cutoff      Resets the cutoff for defining residues as "interface" (default 5.5A)

--------------------------------------------------------------------------------
designing with DNA:
--------------------------------------------------------------------------------
 -design_by_base            DNA-specific option that turns on base-specific dna-
                             interface detection.

 -dna_interface             Option for designing protein-DNA interfaces.
                             Specifically, this sets the weights to DNA weights,
                             changes the radii of protons, and deselects any
                             amino acid positions not at the DNA interface from
                             being designed.

 -enable_dna                Indicates that rosetta should assign slightly larger
                             values to MAX_AA and MAX_ATOM, to allow for nucleic
                             acids in fullatom mode.  The options -dna_interface
                             and -dna_minimize imply -enable_dna, so use of
                             -enable_dna should be rare.

 -force_bp_muts             Force compliant mutation of basepaired nucleotides.

 -dna_minimize              Continuous minimization of the protein-DNA
                             interface

 -all_stats                 Increased output info in the PDB
--------------------------------------------------------------------------------

designing with ligands:
  -design_dock               Allowing the rigid body movement during design.
                              For use with ligand option only
  -ligand_filter_score <float>		Output decoys only that score better <float>
  -ligand_filter_count		Number of poses to test before reducing ligand_filter_score

cluster_design submode:
  -cluster_design            Based on the resfile, the repack and design regions are
                              defined. For design region, do all possible designs with
                              the allowed  mutation number, and then output the energy difference
                              between the designed structure and the repacked starting structure.
  -protein_complex           If invoke the protein interface analysis, the input pdb file should
                              have "TER" between two partners, and the binding energy difference upon
                              the design will be computed. Default is monomeric protein analysis.
  -cluster_size <>           If identify the mutations with the allowed mutation number:
                              1-single, 2-double, 3-triple, and etc; the default value is 1;
                              otherwise the allowed mutation number take the total number of
                              designed positions from the resfile.
  -mutout <>                 Name of an output file containing the difference of all energy terms
                              between the designed structure and the repacked starting structure.
  -use_spatial_cluster i j k
                             Only consider the designs which is spatially close.
                              i,j,k are the three distance values: i  The default is 5.0 8.0 12.0.
  -n_mutatpos <>             How many mutants is allowed to create at each position. The default value is 1.
  -fix_mut                    if this flag is used to recalculate the design run based on your mutin file
  -mutin <>                  Name of an input file containing the mutations you analyzed
                              (the same format of mutout)
  -output_structures         Output all the designed structures and repacked wt structures based
                              on the mutout file
  -check_point <>            If set up the check point which allow you to continue the design run
                              after you stop the job, or allow you run the multiple runs at the
                              same time on the cluster. The default value of the check point size is 1.
  -minimize_structures       If minimize all the structures after design
  -design_neighbors i j      If design neighbors around the cluster. The i j are the two distance
                              parameters to define the repacked regions around the cluster. Actually
                              they defines two shells around the given designed regions
                              (the default is 5.0 8.0): the distance between two Cb atoms within
                              the first shell, all positions are neighbors; the distances between
                              the first shell and second shell, only two residues point into same
                              direction are neighbor;otherwise, they are not neighbors.
  -repack_neighbors i j      If repack neighbors during design. The i j are the two distance
                              parameters to define the repacked regions around the designed regions.
                              The default is 5.0 8.0. And see the above.
  -debug_output              If output the debug information

------------------------------------------------------------------------------
  Annealer Debugging in the Packer
------------------------------------------------------------------------------
  -record_annealer_trajectory <filename >        Writes the sequence of
                                 rotamer substitutions by the FixbbSimAnnealer
                                 to a file.  This file can then serve as input
                                 to the DebuggingAnnealer, which performs the
                                 same sequence of rotamer substitutions.  Each
                                 line of the file holds: 1) the node that
                                 considers an alternate state, 2) the alternate
                                 state on that node, 3) whether to 'A'ccept or
                                 'R'eject that state substitution.
  -design_debugging_annealer     During design, read a sequence of state
                                 substitutions from an input file.  The annealer
                                 sends the change in energy induced by each
                                 state subsitution to standard out.
  -db_annealer_file <filename>   For use with -design_debugging_annealer.
                                 Specifies the input file.

-------------------------------------------------------------------------------
interface mode:
-------------------------------------------------------------------------------
  -ddg_bind_only             Calculate binding energy of input structure ONLY
  -mutlist                   Name of a list specifying all mutations
  -intout <filename>         Name of an output file containing all binding energy data
  -inout_by_pdb              Name the output file <pdb>.intout; useful when running interface mode over
                             a list of input pdbs (-l <filename> as opposed to -s <filename>).
  -Wpack_only                Use packer weights for both packing and scoring
  -Wint_only                 Use int weights for both packing and scoring
  -output_structure          Output all the structures during ddG calculation
  -monomeric_protein         Calculate the DDG for monomeric protein
  -ala_scan_only             Calculate the alanine scanning energy change
  -pmut_scan                 Tries all possible point mutations at a protein interface
  -repack_neighbors          Repack residues at the interface before and after
                              a mutation

min_interface submode:
  -min_interface             Relax structure before and after mutation with gradient
                              based minimization. The default is to vary all torsion
                              angles at the interface (side chain and backbone) as
                              well as perform rigid body optimization.  Also
                              default is to restrain the Calpha positions
                              to be similar to the starting pdb.
  -no_cst                    Turn off constraints which are on by default
  -cstW                      Set the constraint weight, if not specified the
                              default is 2.0
move flags:                  If none are specified -int_bb,-int_chi and -rb are set
                              true
  -bb                        Relax all backbone torsion angles
  -int_bb                    Relax backbone torsion angles at the interface
  -chi                       Relax all chi angles
  -int_chi                   Relax chi angles at the interface
  -rb                        Rigid body optimization
  -relax_unbound             When repacking (repack_neighbors = T) or minimizing
                              (min_interface = T) also relax the unbound state.

-------------------------------------------------------------------------------
pdbstats mode:
-------------------------------------------------------------------------------
  -pdbstats [charid]         Follow pdbstats flag with an option that tells
                              rosetta what type of statistics to compute.

    the current options can be found in options.cc
    in the get_pdbstats_options subroutine.  For
    instructions on how to create a new option
    see the header of pdbstats.cc.  This mode is
    generally run with a list of starting structures
    and it is often useful to have the chain id
    as part of the pdbname, to do this use
    the -chain_inc flag.


-------------------------------------------------------------------------------
docking mode:
-------------------------------------------------------------------------------
input/output/scoring flags:
  -silent                    docking silent output
  -docking_silent_input      docking silent input
  -docking_silent_input_file <filename>
			     if no file name specified, the default
			     name is used as "start_path / code +
			     protein.out"
  -l < list >                extract the subset entries from
			     docking_silent_input_file defined as
			     above. Each line has to at least contain
			     the tag of that enntry. Note that docking
			     silent input only supports one single
			     starting structure as -s option. So -l
			     option can not be used to specify
			     multiple starting structure under this mode.
  -norepack1                 Don't repack partner 1
  -norepack2                 Don't repack partner 2
  -fab1                      Partner 1 is an antibody fragment
  -fab2                      Partner 2 is an antibody fragment
  -unboundrot                Save rotamers from native structures to
                              be included when packing (now only under
                              docking mode). The structures can
                              be either bound or unbound and the pdb
                              file should be named "xxxx.unbound.pdb"
                              noted in "pdb1" line (or "pdb2" line) in
                              paths.txt.  These rotamers are _always_
                              included in packing, whether they are on
                              the current structure or not;
                              WARNING!!::rotamers rebuilt from
                              chi angles
  -dock_rtmin                Apply rotamer_trial_minimization in dock_mcm.
  -unbound_start             Starting structure has a different
                              sequence than the native (native is
                              always the bound, and starting may be
                              the unbound)
  -dock_score_norepack       score mode flag for docking, just score
                              the native/input without further repacking.
  -fake_native               Native is just a reference position;
                              disables filtering
  -output_position_hetatm    Include docking centroid info as HETATMs in output PDBs
  -output_centroids          In centroid mode (not fullatom), output
			      residue side-chain centroids as "CEN" atoms.
  -simple_elec               A simple Coloumbic potential with distance-dependent dielectric.
                             Only aromatic-aromatic, aromatic-charged, and charged-charged
                              interacations are considered.
                             Can also be used outside the dock mode.
  -strip_native_rotatmers    In prepacking, removes the native rotamers from the starting
                             structure so that in packing information on native rotamers is
                             not present.
                             By default, this option is false, but in testing docking functions
                             it should be turned to true.
  -ensemble1 <n> 	     initiates ensemble mode.  Sets partner 1 as an ensemble of n structures
			     a file named 'pdblist1' is required to list the pdbfiles that make up the ensemble
  -ensemble2 <n> 	     initiates ensemble mode.  Sets partner 2 as an ensemble of n structures
			     a file named 'pdblist2' is required to list the pdbfiles that make up the ensemble
  -ensemble_prepack	     conformers in each ensemble are prepacked, their structures are stored in the starting
			     directory (defined in paths.txt), and unbound centroid and FA scores are added to
			     pdblist1 and pdblist2.  Note, both pdblist1 and pdblist2 are required for all
			     ensemble docking.

start condition options:
  -randomize1                Randomize orientation of partner 1
  -randomize2                Randomize orientation of partner 2
  -spin                      Spin the partners randomly around the
                              line of centers  (automatically on if
                              randomize1 or 2 is on)
  -dock_pert n p r           Perturbation size for the starting structure
                              (n)ormal perturbation in Angstroms
                              (p)arallel perturbation in Angstroms
                              (r)otational perturbation in degrees
                              this flag also forces a perturbation
                              [default is to perturb only when
                              randomize1 and randomize2 are off]
  -docking_local_refine      Skip any initial rigid-body
                              randomization/perturbation and centroid
                              monte-carlo search. enter fullatom refine
                              directly.

protocol options:
  -dockFA                    Dock with a full-atom second-stage
  -dock_min                  Minimize the full-atom decoy (implies -dockFA)
  -dock_mcm                  Monte-carlo minimize the full-atom decoy
                              (implies -dockFA)
  -dock_mcm_loopmin          Allow loops to minimize during -dock_mcm
                              requires .loops file to defile loop ranges
                              call with -dock_mcm and -loops flags
  -prepack_full              Separate components, repack separately,
                              put them back, and write PDB (to create
                              starting positions)
  -prepack_rtmin             Separate components, one cycle of rotamer_trial
                              with minimization on all the side chains,
                              put them back and write PDB (to create
                              starting positions)

  note that if -prepack_full and -prepack_rtmin both on,
  repacking will go first and then rotamer_trial with
  minimization. -prepack is not a command-line flag any more and
  instead becomes a sub-mode in docking turned on by either of
  those two flags above.

  -FAsearch                  Do a Monte Carlo search in fullatom mode
                              (as opposed to simply scoring fullatom at
                              the end)
  -loop                      Active dock_loops mode which allows loops
                              to be built and moved
  -loop_trials               Approximate flexible loops docking by iterating
                              through closed loop structures from a .loops
                              file during centroid docking (call with -loop)
  -pivot_residues f          Mode for a flexible terminal segment of
                              one docking partner.  file f defines
                              flexible segments
  -jumpout                   Jump out of monte carlo search as soon as
                              minimal criteria are met

  -scorefilter x             Only write out pdbs with scores under x
  -score_delta0
  -score_delta1 x
  -score_delta5 x            Define the scorefilter buffering cutoff
                              values on command-line. They are used to
                              skip models with very bad scores in the
                              early stages. The default values are
                              still 500, 10 and 5.
  -smart_scorefilter y       Write out the top fraction y of decoys.
                              Uses an external script to compile scores from
                              multiple processors.

   pose docking subset
   several methods are invoked requiring the -pose flag:

   -grid_dock                Writes out PDBs of all configurations defined by a given
                              set of rigid-body motions and ranges.  The movements are in a
                              file <protein>.axes with the following format (note indentations):
FILE FORMAT:

number of motions: [n]
move type: [translation|rotation]
 axis: [X1 Y1 Z1 X2 Y2 Z2]
 center: [X Y Z] (note: only if rotation)
 fixed axis: [true|false]
 step size: [value in Ang or degrees]
 min displacement: [value]
 max displacement: [value]

for example:

number of motions: 2
move type: rotation
 axis: 15.728 56.757 10.733 23.210 34.081 6.500
 fixed axis: true
 step size: 45
 min displacement: -90
 max displacement: 90
move type: rotation
 axis: 31.451  24.739 -11.827 15.099  56.647  24.910
 center: 16.549 48.454 14.536
 fixed axis: false
 step size: 90
 min displacement: -180
 max displacement: 180

                              You can have up to 6 dergees of freedom. If "fixed axis: false", the
                              rotation axis will rotate with the mobile partner.  If it is true, the
                              rotation axis will stay fixed with the coords of the target. Either way,
                              rotation centers will move with the
                              moble partner.

dock submode to dock whilst swapping through an ensemble of loops.
The submode builds/clusters/refines loops and these are separate
rosetta runs. Finally after all these steps they are run in dock_loop
mode for swapping in and out whilst making docking type moves

  -dock_flex                  submode that can be reached only when
                              -pose option is also set. Carries out
                              various operations that enables one to
                              dock proteins by simultaneously swapping
                              in from a loop ensemble
  -dock_keyres filename       specifies the loop/s to be built/
                              docked/ clustered. Default filename is
                              "loopfile". The format is as follows:
															Format:
															4      < which is the	total number of residues>
															101 A  < start of loop 1 >
															121 A  < end of loop 1 >
															90 B   < start of loop 2 >
															95 B   < end of loop 2 >
                              NB: Do not include stuff inbetween the
                              <>. They are for explanation only
  -dock_neighbor							specifies if neighboring(centdist<8A)
															residues of the loop are repacked
															during repacking
  -dock_relax                 Relax all loops defined in loop_file
                              after repacking sidechains and before
                              docking_mcm runs. Small/shear moves
  -flex_nofilter              sets a flag that enables output_decoy
															to accept the decoy irrespective it
															failing any filters
  -l_chain <char>             optional option. The default antibody
															light chain identifier is L. If it is
															different, it has to be specified here
  -build_loop                 build loops for as defined
  -cluster_loop               prepares rms and score tables for
															clustering loops contained in loop
															file for use by R for hierarchial
															clustering.Loop filename has to be:
															xxxx_loop_library_01 where xxxx stands
															for the four letter pdb code and 01
                              correspnds to the first loop and so on.
   -refine_loop               Refines the clustered loops. Only does
                              one round of refinement. Extensive
                              refinement is carried out by dock_relax.
                              In addition to the loop library in
                              default file xxxx_loop_library_01 there
                              should be a centers file from R
                              hierarchial clustering
   -H3_filter                 accepts loops which pass the
															H3_filter, where the loop sequence
															matches with the pseudo dihedral
															described above
   -dock_cter <number>        If the c-terminal region has to be
                              modeled prior to docking. The number
                              specifies the number of c-terminal
                              residues to be modeled. Default is no
                              modeling, zero residues
   -dock_loop                 docking by swapping from a refined loop
                              library. The input file should be named:
                              xxxx_refined_loop_library_01
   -insert_all                Submode of dock_loop, it carries out
                              only docking local refine and inserts
                              ALL the loops. Each decoy corresponds to
                              each loop in the refined loop library.

   -docking_pose_symmetry     Symmetrical docking in the pose mode.

   -docking_pose_symm_full    Specifies that symmetrical packing and
			      rotamer trials should be used in symmetrical
			      docking.

   -pose_symm_n_monomers      Number of subunits in symmetrical systems during
                              pose symmetrical docking.

   -docking_pose_symm_subsystem    Indicate that a smaller subset of symmetrical
				   subunits should be used to simulate the system
                                   in pose symmetrical docking. For cyclical and
                                   helical symmetry this means 3 subunits and for
				   icosahedral symmetry 6. The starting structure
                                   should then have 3 monomers with a TER between
                                   first and second subunit.

   -symm_type                  Sets the symmetry type in symmetrical docking.
                               Currently cn (cyclical), helix (helical),
                               dn (dihedral) and virus (icosahedral).

-------------------------------------------------------------------------------
SnugDock mode: a sub mode of docking

applicable only for antibody-antigen docking. The antibody should be
processed as follows:
1. Only the Fv region should be present
2. The light and heavy chains should be named L and H respectively
3. They should be re-numbered using the Chothia numbering scheme
4. The pdbs should be so arranged that the first chain is the light
chain, followed by a heavy chain, then a TER and then the antigen chain.
Note: SnugDock is especially useful during local docking and hence if
possible the antigen's epitope should be pointed towards the antibody
CDRs. The protocol is pose based, so you will have to use the -pose
flag. The -fab1 flag is also needed.
-------------------------------------------------------------------------------
   -snugdock Enables optimization of the relative orientations of the light
             and heavy chains during antigen docking

   -snugloop Enables backbone minimization of the CDRs

   -snugh3   Enables explicit perturbation and minimization of the CDR H3
             loop during docking (small/shear/CCD moves - no frag moves)

	 -snugh2   Similar as snugh3 above, but for CDR H2

   Note: It is possible to use an ensemble of antibodies using EnsembleDock
         in conjuction with SnugDock. Please add the following flag:

         -ensemlbe1 <Number of antibody in the ensemble>

-------------------------------------------------------------------------------
ligand mode:
-------------------------------------------------------------------------------
  -ligand		Turns protein-ligand energy evaluation in fullatom mode
				on for fullatom energy, design, and docking. protein ligand
				docking is performed instead of protein protein docking

  -fix_ligand_HO	Turns off optimization hydrogen position of Hydroxyl groups
  				by fixing the position of the hydrogen to the input position

  -flexible_ligand	Turns on evaluation of internal energy and generation of rotamer
				library for ligand. Benchmark is not complete yet. Highly
				recommended that you use in combination with -ligand_mdlfile
				option as this option requires detection of bonds for proper
				function.

  -pose_ligand_docking	This is a pose1 protocol or ligand docking with a ligand as an amino
				acid it should be used in combination with the following flags
				-ligand -ligand_mdlfile <mdlfile> -enable_ligand_aa -flexible_ligand

  -ligand_dock_pert <float> <float>	This is the dock_pert equivalent for the
				pose_ligand_docking protocol

  -ligand_dock_pert_cycles <int> This sets the number of monte carlo cycles to try in the dock_pert
			session see pose_ligand.cc in the pose_ligand_docking

  -perturb_ligand_rotamers <float> <float> this sets the parameters for perturbing the ligand rigid body
			position inside the packer. The first float is this translation in Angstroms.
			The maximum recommend value 1.0 due to the definition the binding site. The
			second float defines the rotatotion ranging from 0-180 degrees with 180 degrees
			defining complete orientation on a sphere. this must use the pose_ligand_docking
			protocol.

  -ligand_mdlfile <file>	if enabled the ligand_mdlfile flag then the input_pdb function in
			input_pdb.cc will call read_mdl. The default value is the
			<inputfile>.mol. The mdlfile file provides the information
			on the atomic positions and connectivity in the ligand.
			For a complete description on the required format see the
			function header for the read_mdl function in ligand.cc
			Multiple ligands can be read by splitting the definitions
			with "$$$$" record. Several protocol options are available
			on a ligand by ligand basis. These are set by including the
			appropriate strings, as listed below, after the bond records
			in the mdlfile. In the lines after the bond records the
			first five characters are used as flags to indicate a
			protocol option. The characters after that are used to
			define the parameters for the protocol option.

	*********************************************************************
	The options in this section are to be included in the mdlfile after the bonds
	sections

	M CHGaaacccc.cccc	This protocol flag defines the total formal charge of the molecule
				the cccc.cccc field is read as a float.

	MACHGaaacccc.cccc	This protocol flag allows the user to assign a partial charge to an
				atom. aaa is an int indicating the atom to assign the partial charge
				cccc.cccc to. NOTE that all the atoms must be assigned partial
				charges otherwise they will be ignored. If partial charges are
				assigned for each atom then the sum of those charge becomes the total
				charge of the molecule regardless of the M CHG value given.

	MROOT root_atom		This flag allow the user to specify the root atom as an int in the ligand bond
				directed graph

	MBNDC atom1 atom2 N <X Y>*N 	This protocol option allows the user to add a bond to be
					sampled in the ligand conformational search protocol. atom1
					and atom2 define the bond, N defines the number of minima
					for this bond. X in the angle from -180 to 180 as and int
					Y in the max deviation from the minimum as an int. X and Y
					are supplied for each minimum (i.e. N times )

	MSAMP angular_density <int>	This flag defines the number of degrees that the iterative
					search increments in each interatiion going from minimum-
					max_deviation to minimum+max_deviation. default is 5

	MSAMP minimal_rms <float>	This flag defines the minimum allowed rms between to accepted
					conformation. ( provides control on the diversity of the
					ligand ensemble ). default is 0.5

	MSAMP maximum_number_of_conformations <size_t> This flags controls the maximum number of
					conformations to allow in the ligand ensemble

	MSAMP rotamerize <float lower bound> <float upper bound >	This flag provides the
					parameters for the rotamerize_input_ligand MPROT flag
					the rotamer must have a conformation that is at least
					lower bound rmsd from the input conformation and no more
					than upper from the input conformation

	MPROT fix_ligand_HO		This flag holds all the OH bond vectors constant for the
					ligand in the ligand.cc hydrogen bonding function

	MPROT use_input_ligand		This flag adds the input ligand conformation to the
					ligand ensemble.

	MPROT use_input_ligand_only	This flag means the input ligand will be the only conformation
					available.

	MPROT make_rotamer_nearest_start  Generates an additional ligand conformation with dihedrals
					as similar as possible to the input, but using dihedral minima from MBNDC
					or the internal database of minima derived from crystal structures.
					Use with rotamerize_input_ligand to get ONLY this conformer.

	MPROT rotamerize_input_ligand  Instead of using the full ensemble generated or read in, uses
					only the one conformation with the smallest RMSD to the input conformation.
					Note that this happens *after* the conformer(s) are written to SD file.

	MPROT onlydefinedbonds		this flag means that only bonds and minima defined using
					the MBNDC flag will be sampled in the conformational search.

	MPROT output_rotamers <filename> This flag cause the ligand ensemble generated to be output
					into filename as an sd file.

	MPROT superimpose_output_rotamers  Causes the ligand ensemble to be superimposed on the
					input conformation before being written to the SD file.

	MPROT read_ligand_conformations <filename> reads conformations for a ligand stored in
					filename sd file. (an sd file is a mdl format file with
					multiple molecule records in the file.)

	MPROT use_iterative_conformational_search This flag tells rosetta to iterate through all
					conbinations of minima in its conformational search.
					(NOTE this is not recommended for molecules with greater than
					4 bonds. It is an exhaustive search and takes a long time for
					molecules with greater then 4 bonds.)
	MPROT attach_by_jump <int N>
		<int atom1> <float x>  <float y> <float z>
		<int atom2> <float x>  <float y> <float z>
		<int atom3> <float x>  <float y> <float z>
		<int atom4> <float x>  <float y> <float z>
			This flag with associated defines the rotation translation matrix of an
			additional copy of the ligand. This option can only be used with the -pose1
			-pose_ligand_docking -enable_ligand_aa -ligand -ligand_mdlfile options. The
			coordinates are used to find the rotation translation matrix for the transform
			input ligand position to the initial placement of the ligand copy.

	*********************************************************


The following flag is for enzyme_design option only:
  -enzyme_vrot               Build up the inverse rotamer tree based on the
                              function group of key residue
  -vrot_perc                 Percentage cutoff for pick up the bbind rotamer library
  -vrot_repmaxE              The cutoff for repulsive energy between inverse rotamer
                              tree and ligand
  -Wlig_vir                  The total weight of virtual energy term
  -exact_match_vatom         Use the additional energy term for virtual energy evaluation

-------------------------------------------------------------------------------
pKa mode:
-------------------------------------------------------------------------------
  -pH_titrate <start_pH> <end_pH> <step_pH>
                             Titrates a pdb from <start_pH> to <end_pH> at
                              intervals of <step_pH>
  -full_repack               Repacks the entire protein with pH flag set to true
  -neighbor_repack <int>    Repacks only the neighbors of the residue
  -site_repack <int>        Repacks only the residue given
  -full_rt                   Rotamer Trials on the entire protein
  -neighbor_rt <int>        Rotamer Trials only the neighbors of the residues
                              given in the file (based on constraints file input)
  -site_rt <int>            Rotamer Trials only the residues given in the file
  -use_monte_carlo           Use an outer loop of monte carlo and repack 3 times
  -output_ensemble_stats <file>
                             Output an ensemble file containing
                              rotamer frequencies
  -output_sum_ensemble_stats <file>
                             Average the ensemble statistics from
                              nstruct number of runs per pH
                              step instead of outputting every
                              individual ensemble.
-------------------------------------------------------------------------------
pose_looping mode:
-------------------------------------------------------------------------------
  -pose_looping -loop_file <loop_file>
  -loop_file                  A file with the location of the loop to be
                               inserted.

-------------------------------------------------------------------------------
remodel mode: (blueprint interface to rebuilding/remodeling proteins)
-- covers fragment insertion, loop building and design with sequence unbiased fragments
-- requires vall in rosetta_database
-------------------------------------------------------------------------------
  mode is triggered by:  -pose1 -remodel -s [input.pdb] -blueprint [blueprintfile]
  for details and explanation of remodel related flags: -pose1 -remodel -help

-------------------------------------------------------------------------------
cst_mode ( new version of enzyme design ):
-------------------------------------------------------------------------------
-cst_mode                       use input constraints to do design
				and pose minimization ( new version of enzyme design )

   -enable_ligand_aa            turn on the ligaa which treat ligand as a new
                                amino acid type as a replacement of ligand mode,
                                indicating that rosetta should assign slightly larger
                                values to MAX_AA and MAX_ATOM.
                                Therefor, nothing is special for ligand during
                                the energy calculation, expect the initial setup for
                                new amino acid type.
      -Wligaa <>                weight for protein-ligand interface energy,
				default is 1.0
      -number_of_ligands <int>	allocate space in aapproperties_pack arrays for int arrays. default is two
      -use_atom_weights         if enable_ligaa, read the atomic weight from occ
      -read_input_charge        if enalbe_ligaa, read the atomic charge from bfactor
      -attach_by_bond           if enable_ligaa, attach ligand by bond
      -mdlfile                  if enable_ligaa, read ligand from mdl format
      -use_mdl_connect          if enable_ligaa, use mdl connectivity from mdl file
      -lig2_file <file>         read the second ligand as aa
      -fix_lig2                 fix the second ligand during minimization
				and the coordinates from pdb file
   -multi_chain                 treat the protein complex

   -s <file>                    input pdb file
   -l <file>                    input pdb list
				creat "CHECKPOINT" file into output path,
				and output "***:BEGIN" if cst_mode begin to process the current str
				    output "***:END" if cst_mode end to process the current str
   -read_patches                read the subset structures which can patch to the orginal scaffold
      -ps <file>                   input patch file
      -pl <file>                   input patch list

   -nstruct <n>                 how many runs
   -ndruns  <n>                 how many design (packer) runs, and only final model output
   -iterative_run               keep the last run structure as the initial structures
				default is to always use the input structure as the starting structures

   -check_finish		if check "***:END" before process the current str
				default is to check "***:BEGIN" before process the current str
   -overwrite			ignore "CHECKPOINT" file and the overwrite the pdb
   -pdbout <name>               the output name, the default <name> is "des"
   -log_file <file>             redirect the std::cout to log_file
				if file == "auto", redirect to ***.log

   -debug_output                If output the debug information
   -dump_structures             If dump out all structures in the different stages

   -cst_from_file <file>        input constraint from single line format
   -cstfile <file>              input constraint from complicate mapping format
   -read_enzyme_cst <file>      input constraint from the input pdb file and using
                                old enzyme constraint format
				in the above three options,
				   if file is empty, read from the starting structure
				   if file == "auto", read from the ***.cst
   -read_old_header             use the old header format to define the catalytic map
				default is to use the new format compatiable with cst

   -detect_covalent_bond        if !read_enzyme_cst, detect the atom pair is covalent
				otherwise take the covalent bond info from
				cst file "is_covalent"
   -covalent_from_cstfile       if read_enzyme_cst, take the covalent bond info
				from cst file "is_covalent"

   -resfile <file>              if define design and repack residues by resfile
				if file == "auto", read the ***.resfile
   -short_interface             define the interface by ca->cb vector ( if not resfile )
        -cut1 <i> -cut2 <j> -cut3 <k> -cut4 <l>
                                The i j k l are the distance parameters to define the
                                redesigned and repacked regions around the cluster.
                                Actually they defines four shells around the ligand
                                ( the default is 5.0 7.0 11.0 12.0 ):  if the distance
                                between protein CB atoms and close ligand atom within
                                the first shell, all positions are redesigned neighbors;
                                if the distances between the first shell and second shell,
                                only protein ca->cb vector points into ligand are
                                redesigned neighbor; if the distances within third shell,
                                all positions are repacked neighbors; if the distances
                                between the first shell and second shell, only protein
                                ca->cb vector points into ligand are repacked neighbors;
                                otherwise, they are not neighbors.
   -loop_file                   use the loop file to guide the pose fold tree, and it is
				useful for allowing backbone movement

   -cst_score                   score the input structure with input constraint
   -cst_conformer               generate the conformer by cst
   -cst_design                  design the interface with input constraints
   -cst_loop                    loop refinement with input cst and ligand
   -cst_dockpert n r            small docking perturbation
				n, r are Perturbation size
                                (n)ormal perturbation in Angstroms
                                (r)otational perturbation in degrees

   -cst_opt                     minimize the catalytic site
				take the augument from the following "cst_min" flag
   -cst_min                     pose type minimization with input constraints
                                minimize all constraints in input file plus:
      -rb_move                  allow ligand rigid body movement
      -chi_move                 allow protein sc torsional movement
      -bb_move                  allow protein bb torsional movement
      -vary_cb_bond             allow protein ca->cb bond movement
      -bonds                    allow minimizing ALL ligand bonds
      -angles                   allow minimizing ALL ligand bond angles
      -torsions                 allow minimizing ALL ligand torsional angles
                                (for -bonds, -angles, and -torsions, ligand
                                 target values are taken from input struct.)

   -poly_ala                    crop pocket to poly ala
                                default is to crop pocket to poly gly
   -limit_cstopt                only output the good structures after cst_opt
      -repE_limit               default is 10.0
      -cstE_limit               default is 50.0
      -chainbreakE_limit        default is 3.0
   -zero_constraint_sd          zero the cst sd when cst_min and cst_opt
   -cst_min_cycles <n>          how many minimization cycles when cst_min and cst_opt

   -score_wtsfile <file>        specify score weight set from file
   -packer_wtsfile <file>       specify packer weight set from file

   -fix_catalytic_aa		fix the aa in the catalytic positions

-------------------------------------------------------------------------------
domain_insertion mode:
-------------------------------------------------------------------------------
  -domain_insertion -insertion_file <insertion_file> -l
  -create_fasta              If this options is set to true, Rosetta only runs
                                up until insertion_start, where it copies the
                                information on the two proteins into a final
                                protein for output.  In this process it inserts
                                the coordinates of the insert protein into the
                                host protein so that the numbering is set up
                                and the pdb that is output is in the correct
                                order to create a fasta file and fragments for
                                the protein
  -insertion_file             A file with the location of the loops to be
                               inserted.  Also contains the names of the two
                               proteins that are going to be used to create the
                               final protein
      example:
      hostp                 1OMP.pdb  // this is the filename of the host domain
      insertp               1N3W.pdb  // this is the filename of the insertion domain
      hostp_start_res       1         // this is the number in the pdb file of
                                the first residue
      hostp_end_res         632       // this is the number in the pdb file of
                                the last residue
      hostp_begin           316       // this is the number of the start location
                                for the insertion of the insertion domain
      hostp_end             318       // this is the number of the end location for
                                the insertion of the insertion domain
      insertp_start_res     26        // this is the number in the pdb file of the
                                first residue
      insertp_end_res       270       // this is the number in the pdb file of the
                                last residue
      insertp_begin         226       // this is the number of the starting location of
                                the circular permutation of the insertion domain
      insertp_end           227       // this is the number of the ending locatino of
                                the circular permutation of the insertion domain
      loop_size             10        // this is the loop size, if it's not defined, it
                                defaults to 10
  -chain_break_tol <double>   Tolerance for the chain break, default is 0.2
  -loop_only                  Takes the starting structures and only rebuilds the loops
                                between them
  -repack                     Sets relax_mode to repak only and doesn't do refinement
  -repack_only                Same as above, but without running the insertion protocol
                                This requires fa_input or fa_output
  -fast_relax                 Runs the full fast_relax protocol
  -fast_relax_only            Same as above, but without running the insertion protocol
                                This requires fa_input or fa_output
  -no_loop                    Only rebuilds the loop once (quick and dirty)
  -small_perturbations        Small perturbations of 3 8 without randomly orienting the
                                location of the insertion domain at the start
  -fa_output                  Fullatom mode, will run fast_relax protocol
                                must be specified for the use with fast_relax or repack
  -fa_input                   Sets fa_output to true, uses sidechains from the input pdb
                                instead of from the separate input domains
                                To be used only if doing a fast_relax_only or repack_only

-------------------------------------------------------------------------------
antibody modeling mode:
-------------------------------------------------------------------------------
-antibody_modeler								assemble cdrs from blast matched cdr-s
																and model H3 if requested

Input Files:
		FR02.pdb										A pdb file containing the correct sequence of
																the antibodyFv region. The co-ordinates of the
																CDR regions do not matter	as long as some
																numbers are present.
		l1.pdb, l2.pdb, l3.pdb,
		h1.pdb, h2.pdb	  					CDRs L1-H2 which has been identified by blast.
																These might or might not have the same
																sequence as the query	sequence. Each of the
																CDRs are of the same length as the
																corresponding cdr in the .pdb file.	The
																l1-h2.pdb files	have four flanking residues on
																either side of the actual CDR
		hfr.pdb											The heavy chain from which the heavy chain
																framework of FR02.pdb was obtained.
		lfr.pdb											The light chain from which the light chain
																framework of FR02.pdb was obtained.
		aaFR02_03_05.200_v1_3				Standard Rosetta 3-mer fragment file
    aaFR02_09_05.200_v1_3				Standard Rosetta 9-mer fragment file
																( fragment files are based on CDR H3 sequence
																with one flanking residue on either side )
    H3_CTERM										Fragment file containing fragments for
																the fairly conserved H3 base.
    xxxx.pdb										If native pdb is present and -native command
																line is used.

Command Line options for -antibody_modeler mode:

Grafting command line:
======================
rosetta.gcc aa FR02 _ -antibody_modeler -nstruct 1 -quiet -l1 -l2 -l3
-h1 -h2 -superimpose -deep 2 -use_pdb_numbering -ccd_closure -s FR02
-native 1bql -find_disulf -norepack_disulf

   -l1/l2/l3/h1/h2							CDRs to be grafted in read in from
																l1/l2/l3/h1/h2.pdb
   -superimpose									grafting by superimposition of flanking stem
																cdr residues
   -deep 2											the number of flanking residues to be	used
																during grafting
   -native											optional argument only if native is present

nstruct should be 1 in this mode because grafting results only in an
unique grafted solution.

Loop Building Command Line:
===========================
rosetta.gcc aa FR02 _  -s FR02 -nstruct 2000 -antibody_modeler -quiet
-h3 -H3_filter -ex1aro -ex2aro_only -find_disulf -norepack_disulf
-norepack_antibody -unboundrot -use_pdb_numbering -ccd_closure
-loop_frags -build_loop -compute_hbond -max_frags 350 -snug_fit
-relax_dock -freeze_h3 -flank_relax 2 -native 1bql

   -h3													enables modeling (building) of CDR H3
   -H3_filter										enables Shirai H3 rules to bias modeling
   -loop_frags									if present then the fragment files can
																be built using only the CDR H3 sequence with
																one flanking reside on either side
   -build_loop									build H3 loop
	 -snug_fit										allow perturbation to relative light and heavy
																chain orientation
	 -relax_dock									enables all cdr minimization whilst L-H
																refinement. Even without this h3 is still
																minimized during docking.
	 -flank_relax N								Enabling this option results in backbone
																minimization of flanking regions. The default
																flanking region is 2 residues on either side of
																the h3. However, one can change this at the
																command prompt by providing an optional option,
																eg -flank_relax 5. Do note that	more than 2
																residues on the N terminal of H3 will result
																CYS double bond perturbations which might not
																be desirable.
																Note: The flanking regions do not undergo
																			small/shear/ccd moves

Other flags:
   -freeze_h3										prevents h3 from being optimized during
																relax_cdrs as well as during relax_dock
	 -l_chain											light chain identifier ( default 'L')
   -unboundrot									allows selection of rotamer from grafted loops
																& framework
   -flex_nofilter								do not impose any filters while outputting
																decoys
	 -cluster_loop                cluster H3 loop
   -refine_loop									refine clustered H3 loops
   -insert_loop									insert all loops from a loop library
   -refine_input								refine the input loop by relaxation
   -norepack_antibody						do not repack the whole antibody
   -snug_fit										allow perturbation to relative light and
																heavy chain orientation
	 -lfr xxxx.pdb								to change default value of filename lfr.pdb
	 -hfr xxxx.pdb								to change default value of filename hrf.pdb
	 -relax_cdrs									minimize cdrs in the absence of snug_fit
	 -nter												use H3 nter fragment file ( H3_NTERM )
	 -no_cter											do not used H3_CTERM file and modeling of
																entire H3 using standard fragments
   -h3_random_cut								cutpoint of h3 is randomly chosen for
																each decoy
   -base_relax									relax base with minimal perturbations
																as compared to apex
   -bias_frags									takes an optional float argument which
																decides the bias weight for antibody fragment
																selection, default is 3.00 bias. Choosing to
																antibody frags occuring after 200
																normal rosetta frags
   -base_strand									mark the base as having strand
																secondary structure
   -all_kink										this options results in all kink/extended base
																match to be picked irrespective of the
																fact the sequence matches or not.
   -idealize_native							This enables idealization & repack of the h3
	 															and outputing scores in	scorefiles. This
																generates decoys as well. In case the	loop does
																not close a fast_ccd closed idealized native
																is also generated. This is repacked as
																well. So in	effect this	adds four new	entries
																in the scorefile ( idealized,	idealized+ccd,
																idealized_repacked, idealized+ccd+repacked).
																Corresponding decoys are also	generated. This
																flag takes considerable amount of time to
																execute. Best runseparately	in a pre step.
   -s														four letter pdb code (without .pdb
																extension) This represents the
															  template into which other cdrs will be
															  grafted into
   -dock_neighbor               specifies if neighboring(centdist<8A)
																residues of the loop are repacked
																during repacking
   -fv_linker                   Build linker for Fv only. This is a
																submode and does not require H3_CTERM
																& H3_NTERM files
   -flex_nofilter               sets a flag that enables output_decoy
																to accept the decoy irrespective it
																failing any filters
   -base                        is used only when option -h3 is
																enabled. Computes the dihedral angle
																formed by residues n-2,n-1,n & n+1 of
																CDR-H3 and suggests if it is kinked or
																extended

nstruct 2000 was found to sample CDR H3 lengths of 8 fairly well. 5000
decoys might be considered for 11 res H3s.

-------------------------------------------------------------------------------
commands specific to Rosetta@home screensaver (BOINC) builds:
-------------------------------------------------------------------------------
  -watchdog		     Turns on a new thread that shuts down rosetta
			       if it goes 4 times over user run time preference or
			       if score doesn't change for one hour.
  -watchdog_time	     Time between watchdog checks (default: one hour).
  -cpu_run_time_factor       Factor over cpu tun time preference after which
			       watchdog kills job. (Default: 4).
  -infinite_loop             Activates an infinite loop in relax_structure to
			       test watchdog.


-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
GENERAL OPTIONS:
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------

-------------------------------------------------------------------------------
options that can be set ONLY by command line flag:
-------------------------------------------------------------------------------
  -version              write out CVS version info
  -benchmark            run special protocol versions for benchmarking
                         (ie non-scientific, code operation)
  -timer                write out time per decoy in minutes in scorefile

  -series <code>        alternate way to specify the code name chain
  -protein <pdbcode>    these options override the first three args
  -chain   <chain_id>

  -silent_input         read start structures from compressed format
                         requires -refold -s <.out file> -l <label/index list file>
                         or use -all in place of -l <list> to use all files
  -by_index             read compressed start structures by index #
                         (by label is the default)
  -new_reader           use new silent-reader, single read-through.
  -output_all           output pdb files for structures that fail
                         filters (default false)
  -accept_all           accept all pdb files (default false) -- use with "-output_all".
  -chain_inc            use last char in start file name (before extension)
                         as the pdb chain
  -skip_missing_residues   skip missing residues in pdb file (ie they are not part
                            of the query sequence)

  -decoystats           calculate values of a series of additional structural
                         properties, including counting unsatisfied buried
                         Hbond donors and acceptors, SASApack, etc. Additional
                         output associated with this flag is written both to
                         stdout and to output PDB files.
  -interface_ds         calculate values of a series of additional structural
                         properties for interfaces
  -ds_outpdb_only       suppress decoystats output written to stdout, while
                         maintaining availability of this information in the
                         output PDBs
  -output_hbond_info    print hydrogen bond info in the stats section of written
						 out PDB files
  -tight_core_analysis  carry out an analysis of how many buried atoms
                         are "tightly packed" (based on SASA to a 0.5 A probe)
  -tight_core_threshold The maximum SASA to a 0.5 A probe an atom can have while
       			             still qualifying as "tightly packed"
  -measure_changed_environment Color B-factors based on difference in distances to
       			             neighboring atoms compared with native

  -status               Generate a status file
  -constant_seed        Use a constant seed (1111111 unless specified)
  -jran <value>         Specify seed (requires -constant_seed)
  -seed_offset <integer> This value will be added to the random
                          number seed.  Useful when submitting many jobs
                          to clusters.  Using the condor job id will force
                          jobs that are started in the same second to still
                          have different initial seeds.
  -delay_at_start       Wait "seed_offset" seconds before starting the job,
                          so that multiple jobs don't all start in sync.
  -run_level <runlevel> Specify runlevel by integer

  -verbose              Keyword runlevels (decreasing verbosity):
  -gush
  -yap
  -chat
  -inform
  -quiet
  -silent

  -silent               use compressed output (also a runlevel)
  -regions              specify regions of the protein allowed to move
  -regionfile <ext>     Specify extension for region file (default=region)
                         (region file root must be same as start structure)
  -ssblocks             require blocks of sequence to follow ss prediction
  -check_homs           Stop execution if homologs detected in fragment files;
                         otherwise no checking occurs
  -find_disulf          Make disulf bonds if connectivity not known
  -fix_disulf <infile>  Make disulf bonds with known connectivity, read connectivity from a file
                         infile format: i2,1x,i2
                         cysteine pairs listed as ith cysteine, not by residue #
                         find_disulf/fix_disulfide activate both disulfide evaluation
                         and filtering by disulfide patterns
  -use_disulf_logfile <outfile>  output physical parameters of disulf bonds
  -disulf_filter        turn on disulfide filter. The default is off.
                        require -find_disulf or -fix_disulf is on first.
  -movie                Update  _movie.pdb file for rasmol_rt
  -trajectory           Write a pdb file of each accepted structure
  -ise_movie            Write a pdb of every move (accept or reject)
  -IUPAC                Use IUPAC hydrogen conventions in place of PDB conventions
  -repeatout <outfile>  Will write log of RNG state for each structure generated
                         so that any trajectory can be repeated. Should work with
                         any mode, but only tested with ab-initio.
  -repeatin <infile>    Will repeat runs with RNG states from <infile>. RNG state
                         is defined as ran3 seed and # of times ran3 has been
                         called. File format is as generated by -repeatout:
                         one line per trajectory as follows:
                         <name/id> <ran3 seed> <ran3 iters>
  -preserve_header      Maintain header info from input PDB when writing output PDBs
  -output_silent_gz     Use gzipped compressed output (silent run level)
  -output_pdb_gz        write gzipped output pdbs
  -output_scorefile_gz  write gzipped scorefiles
  -map_sequence <alignment file>      allows the reading of starting
                         structures whose sequence differs from the query sequence
                         defined by the fasta file. The structure will be mapped
                         back to the query sequence by a fast loop modeling
                         protocol. Requires: query defined (3 args), fasta file,
                         and fragments. The alignment file format is either aligned
                         fasta, or single line: "ALIGN <alignment> <tag>", with . or -
                         for gaps. See map_sequence.cc
  -unix_paths           Reads unix path format (forward slashes) in paths.txt for running Windows version on Cygwin
  -termini              Invoke the modeling of both N and C termini
  -Nterminus            Invoke the modeling of N termini residue only
  -Cterminus            Invoke the modeling of C termini residue only
  -max_frags <integer>  Max number of fragments to read from fragment files (default is 200)
  -new_centroid_packing Add term to centroid-level energy function that
			                   promotes correct (sequence-independent)
			                   pairwise correlation between centroid positions.
  -separate_centroid_pack_score
			   Puts new centroid packing score (see above) in a separate column
			   in scorefile, rather than adding onto cb score.
  -use_native_centroid  place centroids at actual centers of mass
        (relative to backbone) as read in from native state, rather
        than the average position observed for each
        amino acid in PDB.
  -evolution  evolutionary algorithm applied to fullatom refinement of
              structure models
  -evol_recomb evolutionary algorithm applied to centroid level recombinations
               of deocys.
  -sasapack_bvalues  bvalues reflect sasapack scores and unsatisfied buried hbonds
  -cenlist_values        Output values of cen6 and cen10 for each residue as the 2 last
			 columns in the "complete" lines of the output pdb file.
  -no_clean              Don't tinker with PDB coordinates or fill in missing atom positions
                         This is for development testing, not for production runs
  -no_option_display     Turn off reporting of truefalseoptions, realafteroptions, and intafteroptions.
  -concatenate_pdbs  output all of the decoys into one concatenated file
  -concatenate_pdbs_filename   specifies the filename of the concatenated output. If it isn't specified
                               a default name based on the code + protein_name + protein_chain is given.
  -concatenate_pdbs_listname   specifies the filename of the concatenated output list to be stored.
  			       If it isn't specified a standard default name is used.
  -single_silent_writer	in silent mode specifies that a static output stream will be opened and maintained
                  throughout the process. The stream is written to a .gz file. Useful for reducing the
						number of file writes. Multiple processors cannot write to the same silent out files.

----------
options to change default values of variables determined from query or starting structure
----------
  -moviefile <filename> explicitly specify a moviefile name

  -scorefile <filename> explicitly specify a scorefile name
  -cst <extension>      specify extension for a constraint file (def cst)
       -dpl <extension>      specify extension for an rdc file (default dpl)
       -paths <file>         specify paths file (default ./paths.txt)
  -co  <cutoff>         set cutoff for (and use) contact order filter, overrides
                               determination of cutoff from jones file
  -rms <cutoff>         set cutoff for (and use) rms filter

----------
options to override the default behavior of a mode:
----------
       -loops                if a mode other than loops is defined, the -loops
                             flag will still setup for loop-modeling, but the
                             protocols run are determined by the mode flag
  -overwrite           overwrite pdb files; useful for debugging/testing
  -repack              repack input pdb files and score
                            (mostly useful for score mode)
       -nstruct             number of decoys per starting conformation
  -fa_output           output fullatom scorefiles and pdbfiles
  -fa_input            input fullatom coordinates (implies -fa_output)

  -no_optH             Skip optimization of hydrogens (including amide and
                         HIS flips) on input structure.  By default hydrogens
                         on input structure are optimized.  This has no effect
                         on hydrogen optimization elsewhere in the code.
                         Only takes effect if '-fa_input' is set.

       -scorefxn <integer>  set the default scorefxn to be evaluated at output
                            integer keys to scorefxns are defined in score.h
       -multi_chain         force use of multi_chain flag, to get interface
                            output in cases for which this would not normally
                            be used (eg. design mode other than design_inter)
       -prevent_multi_chain   disable multi_chain flag for cases when it would
       			      normally be used, to suppress interface output
  -no_filters          turn off all filters; NOTE if you use another
                            command line that enables a filter, that filter
                            WILL still be used
       -knot_filter         use the knot_filter
       -poke_filter         identify threaded chain topologies
       -use_pdbseq          force reading of sequences from PDB files
                               (rather than fasta/dat)
   -atom_vdw_set        select radii set for centroid bumps (vdw_compute)
  -fa_lj_rep_slope     select fa_lj_linear_sigma_ratio for fullatom
                               etable (bk_rep/lj_rep)
	-geometric_sol       use a geometry-based solvation model instead of LK
	-geometric_sol_weight  set the weight of the geometry-based
			       solvation model relative to the Hbond weight
 -gen_born		    Use generalized born electrostatics
 -use_simple_elec	    Merge partial charges for baseatom +
                            hydrogens to speed up generalzied born electrostatics
 -no_intra_res		    Disable intra-residue electrostatics for
                            generalized born electrostatics.

	-HS_DEBUG      relax hotspot criteria, to visit all parts of the code more often

----------
options for packing (applicable only for fullatom scoring):
----------
  -ex1 <int>           use extra chi1 sub-rotamers for all residues that pass the extrachi_cutoff
  -ex1aro              use more chi1 rotamers for aromatic residues that pass the extrachi_cutoff
                       (-ex1aro implies -ex1).  Uses EX_THREE_THIRD_STEP_STDDEVS sampling.
  -ex1cys              use more chi1 rotamers for cystine.  Uses EX_SIX_QUARTER_STEP_STDDEVS
                       sampling.
  -exOH                use extra chi samples for hydroxyl hydrogens in ST&Y
  -ex2 <int>           use extra chi2 sub-rotamers for all residues that pass the extrachi_cutoff
  -ex2aro_only         use extra chi2 rotamers selectively for aromatic residues that pass the
                       extrachi_cutoff.  Uses EX_ONE_STDDEV sampling.
  -ex3 <int>           use extra chi3 sub-rotamers for all residues that pass the extrachi_cutoff
  -ex4 <int>           use extra chi4 sub-rotamers for all residues that pass the extrachi_cutoff

  The integers that follow the ex flags specify the pattern for chi dihedral angle sampling
  There are currently 8 options; they all include the original chi dihedral angle.
  If no integer is given, Rosetta defaults to the EX_ONE_STDDEV pattern.

  NO_EXTRA_CHI_SAMPLES          0          original dihedral only; same as using no flag at all
  EX_ONE_STDDEV                 1 Default  +/- one standard deviation (sd); 3 samples
  EX_ONE_HALF_STEP_STDDEV       2          +/- 0.5 sd; 3 samples
  EX_TWO_FULL_STEP_STDDEVS      3          +/- 1 & 2 sd; 5 samples
  EX_TWO_HALF_STEP_STDDEVS      4          +/- 0.5 & 1 sd; 5 samples
  EX_FOUR_HALF_STEP_STDDEVS     5          +/- 0.5, 1, 1.5 & 2 sd; 9 samples
  EX_THREE_THIRD_STEP_STDDEVS   6          +/- 0.33, 0.67, 1 sd; 7 samples
  EX_SIX_QUARTER_STEP_STDDEVS   7          +/- 0.25, 0.5, 0.75, 1, 1.25 & 1.5 sd; 13 samples

       -exdb <file>         specify any extra chi angle combination using
                            an input file following the -exdb flag. Example file
                            is rundata.exdb.example. This method is an alternative
                            to the other -ex[1234] flags; you cannot specify extra
                            rotamers using both types of flags.
       -extrachi_cutoff     number of neighbors a residue must have
           before extra rotamers are used.  default:
           18 except in docking mode where the
           default is 0

    -rotamer_explosion  screen through an expanded rotamer set, filtering out
                        rotamers based upon some particular quality threshold

       -rot_pert            add "perturbed rotamers" by changing base rotamers
           chi angles by "pert_size" degrees (below)
       -rot_pert_input      add "perturbed rotamers" for the starting sidechains
           (analogous to rot_pert flag)
       -pert_acc_prob       fraction of potential "perturbed rotamers" to include
       -pert_size           number of degrees each perturbation should entail

  -explicit_h2o        use rotamers with explicit waters
  -water_on_fixed_chain     use explicit water only on the chain of fixed sequence
  -solvate             add explicit water, but don't try to place water
           such that it bridges Hbonds, just put it on every
           available Hbond donor/acceptor where there's no
           clash (implies explicit_h2o)

  -use_input_sc        use rotamers from input structure in packing
           By default, input sidechain coords are NOT
                            included in rotamer set but are discarded
                            before the initial pack; with this flag, the
                            the input rotamers will NOT be discarded.
                            Note that once the starting rotamers are
                            replaced by any mechanism, they are no longer
                            included in the rotamer set
                            (rotamers included by coordinates)

  -use_input_cb       when building rotamer coordinates, use c-beta conformation from input coordinates
                     instead of replacing with rotamer template c-beta.

  -soft_rep           use a "softer" LJ repulsive term (note: changes weights as well)
  -soft_rep_design    use a "softer" LJ repulsive term, along with weights specific for design

  -use_packing_etables_always   rather than just using soft_rep / use_aw / use_bw within repacking steps,
  				apply it always (ie. for scoring, minimizations, writing output PDBs, etc.)

  -norepack_disulf     do not change disulfides in pack or
                       rotamer trials or sidechain minimize
  -minimize_disulf_chi default is false. Used along with norepack_disulf.
                       When both is true, disulf is fixed in packer, but not in
                       sidechain minimization.
       -minimize_rot        minimize each rotamer in rotamer_trials.
  -try_both_his_tautomers
                            Turns on a variant for histidine with the
                            side chain polar hydrogen moved from NE2 to
                            ND1.
  -pH <float>               Turns on dynamic pH-sensitive protonation
                            for ASP, GLU, HIS, TYR, LYS and ARG.
  -no_his_his_pairE         Set pair term for His-His to zero.
  -use_trie                 Calculate rotamer pair energies using trie-vs-trie algorithm.
                            On by default in relax and design modes.
  -no_trie                  Do not use trie-vs-trie algorithm for computing rotamer pair energies.
  -use_trials_trie          Calculate rotamer/background energies using trie-vs-background alg.
                            On by default in relax mode.
  -no_trials_trie           Do not use trie-vs-background alg.
  -write_interaction_graph  Write binary file of rotamer pair energies.
                            Must be in design mode.
  -read_interaction_graph   Read binary file of rotamer pair energies; must use same
                            coordinates for backbone used to produce the interaction graph file.
                            Simple translation and rotation of a pdb will
                            introduce enough numerical noise to invalidate the energies in the file.
                            Must be in design mode.
  -ig_file <name>           The name of the interaction graph file.  I suggest the extension ".igf"
                            for interaction graph file.  This flag/input is necessary if either
                            -write_interaction_graph or -read_interaction_graph are set.

  -dump_rotamers_pdb #      for residue # (rosetta numbering -- see resfile)
                            output a file containing the set of rotamers used
                            during design, with their one-body energies printed
                            in the b-factor column.
                            If you want multiple residues at once, you can edit
                            the code to do so.
  -pack_half_bump_cutoff    discard rotamers with poor interactions with the background using
                            a cutoff of one half of the standard bump-check cutoff
                            (ie. 2.5 instead of 5.0)

  On-The-Fly rotamer pair energy (RPE) calculation flags:
  -lazy_ig                              Packer always allocates pair energy storage but procrastinates
                                        energy caclulation until each RPE is needed; each RPE is
                                        computed at most once.
                                        Memory use is quadratic in rotamers per residue

  -linmem_ig <int>                      Packer always uses the linear memory interaction graph; each
                                        RPE may be computed more than once, but recently-computed RPEs
                                        are reused.  The optional integer parameter specifies the number
                                        of recent rotamers to store RPEs for -- default of 20 if no
                                        integer given.  Memory use scales linearly with the number of
                                        rotamers at about 200 bytes per rotamer per recent rotamers to
                                        store RPEs for (~4 KB per rotamer by default).

  -minimalist_ig                        Packer always uses the minimalist interaction graph.  The minimalist
                                        interaction graph allocates no space for RPE storage.  It is
                                        somewhat slow.  Memory use scales linearly with the number of
                                        rotamers.

  -packer_precompute_only               force the packer to precompute rotamer pair energies; by default
                                        the packer will either precompute RPEs or use the Lazy interaction
                                        graph after predicting which is faster.

  -tight_memory_restrictions            decide between precomputing pair energies and using the linmem IG
                                        depending on whether pair energy storage would exceed the MB limit
                                        indicated  (default 256 MB);
                                        Caution: it is possible for the linmem IG to use more memory
                                        than the given limit.

  -MB_limit_for_RPEs <int>              for use with the -tight_memory_restrictions flag

--------
options for setting packer weight
--------
  -Wint_repack_only    set weights to int weights (use environment
                            dependent H-bond energy) when repacking
           (calling subroutine "pack_rotamer")
           default weight is current packer weights
           (no environment dependent weight for hb)
           No longer be used. If you are in ddg mode,
           use -Wpack_only
  -Wint_score_only     set weights to int weights (use environment
                            dependent H-bond energy) when scoring
           (calling subroutine "fullatom_energy")
           default weight is current packer weights
           (no environment dependent weight for hb)
           No longer be used. If you are in ddg mode,
           use -Wint_only
--------
options for native water
--------
  -read_hetero_h2o     read native water from pdbfile
           calculate the energy between native water
           and protein atoms
           output native water information
  -int_score           set up for reading and scoring protein complex

-------------------------------------------------------------------------------
options for the barcode (affects several modes)
-------------------------------------------------------------------------------
/// Barcode is a way to parse the conformational space into discrete bins.
/// Currently we only use torsion angle barcodes to describe protein
/// conformation space. For example, if we bin psi angles into 10 degree
/// bins, then for each residue psi angle we have 36 possible codes. The list
/// of such codes for all or a subset of residues in a protein is called the
/// barcode of that protein.
///
/// barcode classes contain an array of torsion angle barcodes, including
/// backbone torsion angle codes, sidechain chi angle codes, rotamer number
/// codes, etc.
///
/// The main usage of barcodes in rosetta are:
/// 1, Defining conformational space used in taboo search, where the barcodes
///    of previously visited conformations are remembered and used to modify
///    the behavior of minimization process.
/// 2, Used as constraints to restrict the sampling of torsion angles to
///    specified regions of values.
/// 3, Used as constraints or penalties on strand pairings.
///
/// Format of file is:
///
/// <feature1-tag> <flavor1-freq> <constraint1> {<constraint2> <constraint3> ... }
/// <feature1-tag> <flavor2-freq> <constraint1> {<constraint2> <constraint3> ... }
/// ...
/// <feature2-tag> <flavor1-freq> <constraint1> {<constraint2> <constraint3> ... }
/// <feature2-tag> <flavor2-freq> <constraint1> {<constraint2> <constraint3> ... }
/// ...
///
/// here each feature-tag is just a unique, non-white-space string that uniquely
/// identifies a common set of flavors
///
/// <constraint1> means insert the relevant info for constraint1, eg
/// <constraint1> could be "PHI 12 1.0 46.7" or "SS 24 1.0 E"
///
/// Other examples of constraints:
///
/// PHI <rsd> <weight> <fvalue>
/// PSI <rsd> <weight> <fvalue>
/// OMEGA <rsd> <weight> <fvalue>
/// CHI1 <rsd> <weight> <fvalue>
/// ROT1 <rsd> <weight> <ivalue>
/// BB_BIG_BIN <rsd> <weight> <cvalue>
/// SS <rsd> <weight> <cvalue>
/// BB_SMALL_BIN <RSD> <weight> <fvalue> <fvalue> <fvalue> <fvalue> ***1
/// SC_BIN <RSD> <weight> <fvalue> <fvalue> <fvalue> <fvalue> ***2
/// BB_CLUSTER <RSD> <weight> <fvalue> <fvalue> <fvalue> <fvalue> ***3
/// SSPAIR <weight> <orientation> <strand1_begin> <s1_end> <s2_begin> <s2_end>

/// CHI1 could be replaced with CHI2,CHI3,CHI4, same with ROT1
/// fvalue means floating point, ivalue means int, cvalue means char

  -barcode_file <file> Specify file name with format described above.
  -barcode_mode <int>  0 = use only value[0],
		       1 = full combinatorics,
		       2 = vary one at a time,
		       3 = randomly choose according to <flavor-freq>. The most common mode.
  -output_flavor       Output flavor used for each decoy in a flavor column in score file.
  -sheet_from_barcode  Choose sheet pairings in jumping mode based on
		         chosen barcode.
  -ignore_sspair_barcode_in_score
		       SSPAIR barcodes are ignored in scoring (they are used elsewhere in Rosetta
		       to set topology filters or pairings from jumping).

--------------------------------------------------
--------------------------------------------------
--------------------------------------------------
TO ADD A NEW MODE:

1. define a command line tag
2. define options in options.cc as appropriate
3. check the setting of domain_map and insert_map in reset_insert_map
  in maps.cc These arrays determine what angles can change
  and allow speedups in scoring routines and packing
4. add a mode-dependent call to the new protocol in main.cc
5. any changes to common subroutines (monte_carlo,refold and vdw_compute
  in particular) must be made mode-dependent!  If such changes are
  absolutely necessary, define a flag which can be retrieved by function
  so that any subroutine can check to determine its behavior. See 'fullatom'
  global flag management in 'fullatom.cc' for an example.
6. document the new mode in this file

--------------------------------------------------
--------------------------------------------------
--------------------------------------------------
INPUT/OUTPUT:

all paths set in paths.txt file
all data files common to all rosetta runs are on the data path and can
be checked out from the cvs rosetta_database repository

INPUT FILES:
query:
.dat                          sequence, native ss if present
.fasta                        sequence if .dat not available
.jones                        predicted ss (ab initio mode only)
aa*****03_06.200_v1_1         fragments  (files and names depend on paths.txt)
aa*****09_06.200_v1_1         fragments
.cst                          distance constraints (optional)
.dpl                          dipolar coupling constraints (optional)
.loops                        loop definitions/conformations (reqd in loopmode)

native (optional):
.pdb
.dssp                 secondary structure
.ssa                  alternate source of secondary structure information
.prm                  for use with pose_looping and protein_insertion.
                      contains the information used to create loops and
                      protein insertion parameters.

starting structures (modes other than ab initio):
.pdb                 starting structure
.dssp or .ssa        secondary structure (optional)

OUTPUT FILES
<logfile>            most output written to std error

.pdb                 decoy pdb files
_movie.pdb           continuously updated pdbfile for rasmol_rt
T.pdb                pdb file comprising a trajectory
.sc   (.fasc)        scores of all decoys built  (fasc if fullatom)
.status (.fastatus)  scores of all accepted moves (fastatus is fullatom)

silent mode output (in place of usual output):
  .out               scores, ca coords, torsion angles
  .pdb               temporary output files with coords and torsion angles
  .last_pdb          current decoy number being made (DO NOT REMOVE)
                      this file is updated periodically and is a checkpoint
                      mechanism for coordinating multiple jobs

additional docking output:
  moves.dat          scores after each rigid-body move
  lows.dat           final (low) scores for each decoy
  rms.dat            final (low) rms for each decoy
  xx_start.pdb       structure xx after starting perturbation
  xx_backbone.pdb    structure xx after all backbone moves
  xx_fullatom.pdb    structure xx after all fullatom moves

----------------------------------------------------------
----------------------------------------------------------
----------------------------------------------------------
POSE miscellany:

modes: (under construction)

-close_chainbreaks: close chainbreaks in input silent file
  requires 3 args, frags, fasta file, silent file given by "-s"

----------------------------------------------------------
----------------------------------------------------------
----------------------------------------------------------
NOTES ON CODE:

1. input/output:
   input  initialize.cc
          options.cc
          after_opts.cc
               dipolar.cc
               constraints.cc
               input_pdb.cc           coordinates, angles,hetero etc
               loops.cc               loop libraries
          prepare_struct.cc      SS HS  scoring terms
               read_aa_ss.cc          dat,fasta,ssa,dssp
               read_paths.cc          paths.txt
               read_rama.cc           ramachandran table
               fragments.cc           fragments
    maps.cc                regions

   output  make_pdb.cc
               output_decoy.cc
    diagnostics_rosetta.cc

2. folding protocols:

     fold_abinitio.cc             std ab initio protocol
     fold_constraints.cc          folding w/ constraints, in development
     refine_structure.cc          refining via wobble moves, in development
     fold_loops.cc                loop_modeling
     assemble_domains.cc          fixed domains connected by variable regions
     fold_membrane.cc             js - folding protocol for membrane proteins
     design_structure.cc          bk - sequence design w/ bb movement
     dock_structure.cc            jjg - docking

3. mode-specific files,flags:
     loopmode:
        loops.cc,loops.h
        get_loopmode_flag()
     experimental constraints:
   get_constraints_exist()
   get_dipolar_exist()
        constraints.cc,
   dipolar.cc, dipolar.h
     membrane folding:
        membranes.cc
     docking:
        get_docking_mode()
   get_docking_fullatom_mode()
   docking.h             core data used in docking
   docking.cc         public-access routines like get_docking_mode()
   dock_structure.cc     the main protocol subroutine
   docking_db.cc, .h      block data for interface env, pair scores
   docking_init.cc         initialization for docking
   docking_movement.cc   rigid body moves
   docking_scoring.cc    interface scoring routines
   interface.h         details of the interface (residues present)

4. building structures:
subroutines titled 'main_XXX' are generally safe to call from high level
protocols. 'main' type subroutines must take care to leave all the lower
level data structures in a consistent and updated state
(ie monte_carlo, refold, and scoring routines)

   fragment move trials
     torsion_bbmove_trials.cc:             (normal fragment moves)
  main_trial_wobble          chuck move, end residue minimized
    main_trial_gunn_wobble     smooth move, end residue minimized
       main_small_trial           single residue random angle move
       main_chuck_trial           minimal change in MSD of rest of chain
       main_frag_smooth_trial     small change from current, gunn method
       main_frag_trial     simple frag insertion
       main_double_trial          two frag insertions, with wobble
     min_torsion_bbmove_trials.cc:    (monte carlo minimization moves)
  main_minimize_trial        straight minimization, forced accept
  torsion_bbmove_trials_min_trial
  main_double_min_trial
  main_frag_smooth_min_trial
   main_small_min_trial
  main_trial_wobble_min
     constraints.cc
  torsion_bbmove_trials_cst       prescreen frags by cst score

   folding:
     angles.cc
        refold                   generate coordinates from angles

   repacking:
     fullatom.cc
  main_repack                repack followed by forced accept
  main_repack_trial          repack trial (ie accept by score)

   restoring saved structures
     recover.cc:
       resetphipsi               return to last accepted angles
  retrieve_best_pose        restore last accepted structure
  retrieve_low_pose         restore low scoring structure
       recover_LOW               return MC to low scoring structure

5.  fragment picking/insertion (updating in torsion space):
        fragments.cc
        gunn.cc
        wobble.cc
        smallmove.cc
        minimize.cc
        chuck.cc
        elliptic_msd.cc

6.  generating/updating cartesian space structures:
        angles.cc             torsion->cartesian conversion
   rotamer_trials.cc     rotamer_trials
        loops.cc              loop splicing
   input_pdb.    f       centroids, cbetas, torsion angles etc
   fullatom.cc           packing
        docking.cc            rigid body transformations

7.  scoring:
A. high-level score functions
      scorefxns.cc  complete scoring functions
        score0 -score13    set weights for scorefxn

  scorefxn  above score functions set weights, scorefxn actually
                 evaluates terms and totals; scorefxn is also called
                 from routines (like func_minimize) which use the
                 scoring weights last set.

      individual terms in scoring functions
         vdw.cc       LJ bump check (no attractive) vdw, cbeta
         structure.cc
        evaluate_SS         HS,SS,sheet
             evaluate_envpair    env,pair
             radius_gyration     rg
         dipolar.cc              dipolar_score
         constraints.cc          pc_score
    fullatom_energy.cc      calculate sc energies
         fullatom.cc             retrieve atr,rep,solv,totalE,hbbb,hbside,dun,
                                 pair,prob1b,ref
    fullatom_sasa.cc        gsolt (SASA * ASP)
    fullatom_ljvdw.cc       explicit lj calc of full & cutoff at 10
    disulfides.cc      centroid and fullatom disulfide scores

8.  diagnostics:
       orient_rms.cc     rms,dme
       rms.cc                  rms to native structure, Ca's only
  diagnostics_rosetta.cc  reset/output trial counters
                               output loop stats
       fullatom.cc, scorefxn.cc assorted

9.  bookkeeping:
       monte_carlo.cc            maintain best, low variables, update scoring
       vdw.cc         vdw_compute_reset, internal bookkeeping
       maps.cc     frag insertion points
       fullatom_energy.cc        new_rotamer array for sc changes
  scorefxns.cc              prescore updating, score_set_new_pose

10.  math
     bystroff.cc           adding vectors, rotating, etc
     orient_rms.cc         rapid rms, alignment of coordinates
     minimize_recipies.cc  numerical recipes for minimization
     elliptic_msd.cc        ellipitic rms (used for wobble, chuck, double moves
     pack.cc               duplicates some of bystroff.cc
     angles.cc
     random_numbers.cc
     input_pdb.cc          dihedrals,sc centroids
     chain_centroid.cc      calculate the centroid of an entire chain

11. selected flags:
      fullatom            working with fullatom representation,
                          not just centroids, maintain fullatom coord.
      fullatom_packall    complete repacking required/desired, otherwise
                          fixed/fixed pairs not repacked
      refold_hijack       refold being used for something other than the
                          structure we're building, ie fragments,
                          turn off fullatom mode, loopmode, etc
      refold_set_direction  force refold direction, on 'till reset
                             1--fold N->C (ie N-term coord don't change)
                             0--Automatic: choose fastest,  default
                            -1--fold C->N  (Cterm coord don't change)
      monte_carlo_set_simmannealing  turns off temperature ramping in mc
                                       strict simulated annealing
      score_set_try_rotamers   default true, do rotamer trials inside
                               the scoring functions

      score_set_evaluate_all_terms   evaluate all scoring function terms
                                   even those not included in the total score

      score_enable_rotamer_trials    allow/disallow rotamer trials according
                                     to the try_rotamers flag;  this option
                                     makes sure you don't do rotamer trials
                                     when you shouldn't; don't use this
                                     flag unless you know what you're doing


      score_set_use_mc_prescore  default true, use centroid-based scoring
                                 terms to predict whether score is likely
                                 to be accepted by monte_carlo before
                                 evaluating fullatom terms

      score_set_use_subset_energy   default false; only calculated energy
                                    between pairs of residues that have
                                    moved relative to one another
                                    this mode is used during minimization

      minimize_set_vary_omega    default false;  should omega angles be
                               varied during minimization;  used in
                               idealize mode

      set_use_nblist          turn the nblist on/off  default false

11b.  options set by function/subroutine

    minimize_set_local_min     set the window size for minimization
                               residues +/- of frag insert site


    minimize_set_tolerance     set the tolerance for minimization

    minimize_set_rama_weight       set weights for function/derivative
                _idl_weight        terms used by idealize; don't use these
                _tether_weight     for calls to minimize or min moves
                _angle_weight
                _local_bump_weight

    score_set_dpl_weight     set weights for scoring function terms in
              cst_weight     some scorefxns (not in all!)
              lj_weight

    set_max_seqSep            determine long-rangeness of constraints to
                             include

    score_set_cst_mode       set function type for constraint score


    score_set_loop_weight     set weight for loop closure term in all
                              scorefxns

    set_smallmove_size       set max angle change for small moves in
                             different ss types

    monte_carlo_set_temp     set temperature for monte carlo boltzmann check


12.  *.h files,databases

include files:
aaproperties_pack.h           fullatom
analyze_interface_ddg.h       flags, max_sizes, complex coords and files for interface mode
brent_imap.h                  wobble
cenlist.h                     vdw_compute, list of neighbors
maps_ns.h                     allow_insert,domain_map, frag_begin,size
counters.h                    diagnostics
int_fullatom_energies.h       binding energy terms
design.h
dipolar.h                     dipolar
constraints.h              constraints
disulfides.h          disulfides
dock_fab.h
docking_db.h          docking environment and pair score
docking.h                     docking core data  (geometry, scores...)
dunbrack_pack.h               fullatom
etable.h                      setup for LJ and Lazaridis fullatom terms
files_paths.h                 input/output fileunits, paths, files, options
flexibility.h                 fragment  diversity
fragments.h                   fragment (nearest neighbors) information
fullatom_energies.h           fullatom
fullatom_extra_props.h        atom typing, radii, well depths
fullatom_ljvdw.h              lj 12-6 & linear cutoff at to 10
fullatom_sasa.h               surface-area  - gsolt, ponpf
hbonds.h
interface.h                   docking
loops.h                       loopmode
minimize.h                    debumping/idealization
misc.h                        query (seq-dependent) and decoy (structure-
                             dependent) variables
native.h                      native structure
nblist.h                      neighborlist
param.h                       max values, previously in misc.h
param_pack.h                  fullatom
pdb.h                         info about the input pdb file (for docking)
pdbstatistics_pack.h          fullatom
pdbstats.h                    variables for computing pdb statistics
randm.h                       random numbers
rotamers_pack.h               fullatom
rotamer_trial_energies.h      fullatom, scoring
runlevel.h                    runlevel for output verbosity
score.h                       scorefxn weights,flags
secstruct.h                   SS and HS data
sheet_filter.h                ingo sheet filter
splint.h                      wobble
start.h                       starting structure
structure.h                   vdw, rsigma, secstructure data
template_pack.h               fullatom

compiled databases:
pack_db.cc                    fullatom data
structure_db.cc               HS SS scoring data
fullatom_extra_props.cc       atom typing, radii, well depths, some distance calculations
docking_db.cc          docking environment and pair scores

text databases:
(see README in rosetta_database for more information)
DunbrackBBDepRots12.dat       dunbrack rotamers (fullatom)
dunsd                         dunbrack standard deviations (fullatom)
Paa                           P(aa)         (fullatom)
Paa_n                         P(aa|n)       (fullatom)
paircutoffs                   distance cutoffs  (fullatom)
Paa_pp                        P(aa|phi,psi) (fullatom)
phi.theta.36.HS.resmooth      HS scoring data
phi.theta.36.SS.resmooth      SS scoring data
Rama_smooth_dyn.dat           Ramachandran table
SASA-masks.dat          bit masks for approximate SASA calculations
SASA-angles.dat         angle for approximate SASA calculations
bb_hbW                        hbond weights
sc_hbW                        sidechain hb weights
pdbpairstats_fine             pair term     (fullatom)
template.pdb                  amino acid structures

13.  Rosetta oddities
   a.  backbone coordinates: position arrays
       atom order: N,CA,CB,C,O

  fullatom coordinates: fullcoord arrays
       atom order: N,CA,C,O,CB, .....(sidchain atoms +HN)

       refold attempts to keep these coordinates always synchronized
       also, copy_position_to_fullcoord is used before packing

       generally arrays dimensioned with max_atom use the fullcoord
       numbering scheme. Arrays dimension for five atoms use the position
       array numbering scheme.

  CB coordinates are calculated slightly different in fullcoord and
       position arrays

    b  BEST arrays are the last accepted structure
       LOW  arrays are the lowest scoring structure encountered
  rms_min is the minimum rms encountered by monte_carlo

    c  rotamer_trials argument fullcoord is for output only!!
       input is taken from the last call to fullatom_energy_*
       must call fullatom_energy before calling rotamer trials

    d  rotamer_trials leaves the fullatom_energy common block values
       updated; pack does not

    e  rotamer_trials is called from the score functions and consequently
       the score functions can change the coordinates.  If this is NOT
       the behavior you desire, set 'score_set_try_rotamers(.false.)'
-----------------------------------------------------------------------------

14.  Identifying large arrays

The command "nm --size-sort -t d .*.o | sort -n -r | uniq" will
generate a list of all variables, common blocks, and subroutines
sorted by size.  The list contains three columns:  the size of the
object, a single character descriptor of the object (defined in the
manpage for nm), and the name of the object.  Because there are ~3500
lines in the list, redirect to a file or view with more/less.


