<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE pise PUBLIC "pise2.dtd" "pise2.dtd" >
<pise>
	<head>
		<title>RAxML-HPC2 on XSEDE</title>
		<version>8.2.12</version>
		<description>Phylogenetic tree inference using maximum likelihood/rapid bootstrapping run on XSEDE</description>
		<authors>Alexandros Stamatakis</authors>
		<reference>Stamatakis A. RAxML-VI-HPC: maximum likelihood-based phylogenetic analyses with thousands of taxa and mixed models.Bioinformatics. 2006 Nov 1;22(21):2688-90</reference>
		<category>Phylogeny / Alignment</category>
		<doclink>http://icwww.epfl.ch/~stamatak/index-Dateien/countManual7.0.0.php</doclink>
	</head>
	<command>raxmlhpc2_tgb</command>
<!--  test
	This file was originally created to   permit a complete configuration of RAXML using all command line parameters. 
	Where doing an ML analysis after the bootstrap was optional and default settings will run the program under its "black box" settings.

	Note: values must be passed in for invariable, empirical, dna, and matrix, even if the precond prevents them from being set, even when the default value is the empty
	string.  For example, if we're passed invariable = empty string, then the format code for the model parameter is OK, but if we are passed a parameter map that doesn't include 
	invariable, when PiseCommandRenderer. restituteFormat tries to replace variables for model's code and it finds a reference to a parameter that doesn't exist it clobbers
	the whole code string.
-->
<!-- The file has since been updated, most recently 1/1/2010 by mamiller to include new raxml options.

This is the output of -h command for raxml 7.2.3

	raxmlHPC[-SSE3|-PTHREADS|-PTHREADS-SSE3]

##############################################################################################################################
Option Changes for 7.2.3 compared to 7.2.0
	
New options in 7.2.3:

	[-C]      (will not support) Conduct model parameter optimization on gappy, partitioned multi-gene alignments with per-partition
              branch length estimates (-M enabled) using the fast method with pointer meshes described in:
              Stamatakis and Ott: "Efficient computation of the phylogenetic likelihood function on multi-gene alignments and multi-core processors"
              WARNING: We can not conduct any tree searches using this method yet! Does not work with Pthreads version.
	
	[-f A]    (will not support) (usage not recommended) classify a bunch of environmental sequences into a reference tree with dynamic alignment under MP
              you will need to start RAxML with a non-comprehensive reference tree and an alignment containing all sequences (reference + query)

	[-f u]    (not yet supported) execute morphological weight calibration algorithm, this will return a weight vector. you need to provide a morphological alignment and a reference tree via "-t" 

	[-G placementThreshold]  (not yet suported) enable the ML-based evolutionary placement algorithm heuristics
              by specifiyng a threshold value (fraction of insertion branches to be evaluated
              using slow insertions under ML).
	
	[-H placementThreshold]  (not yet supported) enable the MP-based evolutionary placement algorithm heuristics
              by specifiyng a threshold value (fraction of insertion branches to be evaluated
              using slow insertions under ML).

	[-I autoFC|autoMR|autoMRE|autoMRE_IGN] a posteriori bootstopping analysis. Use:
             "-I autoFC" for the frequency-based criterion
             "-I autoMR" for the majority-rule consensus tree criterion
             "-I autoMRE" for the extended majority-rule consensus tree criterion
             "-I autoMRE_IGN" for metrics similar to MRE, but include bipartitions under the threshold whether they are compatible
                              or not. This emulates MRE but is faster to compute.
              You also need to pass a tree file containing several bootstrap replicates via "-z" 

	[-J MR|MRE] Compute majority rule consensus tree with "-J MR" or extended majority rule consensus tree with "-J MRE"
                You will need to provide a tree file containing several trees via "-z"

	[-K] syntax?(not yet supported)Specify one of the multi-state substitution models (max 32 states) implemented in RAxML.
                Available models are: ORDERED, MK, GTR
                DEFAULT: GTR model 
	
	[-#|-NnumberOfRuns|autoFC|autoMR|autoMRE|autoMRE_IGN] Specify the number of alternative runs on distinct starting trees
              In combination with the "-b" option, this will invoke a multiple bootstrap analysis
              Note that "-N" has been added as an alternative since "-#" sometimes caused problems
              with certain MPI job submission systems, since "-#" is often used to start comments.
              If you want to use the bootstopping criteria specify "-# autoMR" or "-# autoMRE" or "-# autoMRE_IGN"
              for the majority-rule tree based criteria (see -I option) or "-# autoFC" for the frequency-based criterion.
              Bootstopping will only work in combination with "-x" or "-b"
              DEFAULT: 1 single analysis

Removed options in 7.2.3:

    [-f k]: a posteriori bootstopping analysis using the FC criterion for a tree file containg several bootstrap replicates passed via "-z" 
              
	[-f l]: a posteriori bootstopping analysis using the WC criterion for a tree file containg several bootstrap replicates passed via "-z" 
	
    [-l sequenceSimilarityThreshold]		Specify a threshold for sequence similarity clustering. RAxML will then print out an alignment to a file called sequenceFileName.reducedBy.threshold that only contains sequences <= the specified threshold that must be between  0.0 and 1.0. RAxML uses the QT-clustering algorithm  to perform this task.In addition, a file called RAxML_reducedList.outputFileName will be written that contains clustering information.DEFAULT: OFF
	
	[-L]      Same functionality as "-l" above, but uses a less exhasutive and thus faster clustering algorithm
              This is intended for very large datasets with more than 20,000-30,000 sequences. DEFAULT: OFF

	
	[-N autoWC]  Specify the number of alternative runs on distinct starting trees, or let Raxml stop it automatically.
                 In combination with the "-b" option, this will invoke a multiple bootstrap analysis
                 Note that "-N" has been added as an alternative since "-#" sometimes caused problems
                 with certain MPI job submission systems, since "-#" is often used to start comments
                 If you want to use the bootstopping criteria specify "-# autoWC" for the weighted criterion
                 or "-# autoFC" for the frequency-based criterion. This will only work in combination with "-x"
                 or "-b"

	[-B wcCriterionThreshold] Specify a floating point number between 0.0 and 1.0 that will be used as cutoff threshold for the WC 
				bootstopping criterion.The recommended setting is 0.03. 7.2.0 DEFAULT: 0.03 (recommended empirically determined setting) 
	

###############################################################################################################################

All options, 7.2.3
	
	[-s]      		(required)							Specify the name of the alignment data file in PHYLIP format (we manage this)
	[-n]		    (required)						    Specify the outputFileName (we manage this) 
	[-m]            (required)                          substitutionModel
	
       [-a weightFileName] [-A secondaryStructureSubstModel]
       [-b bootstrapRandomNumberSeed]
       [-c numberOfCategories] [-C] [-d] [-D]
       [-e likelihoodEpsilon] [-E excludeFileName]
       [-f a|A|b|c|d|e|g|h|j|m|n|o|p|q|r|s|t|u|v|w|x|y|X] [-F]
       [-g groupingFileName] [-G placementThreshold] [-h] [-H placementThreshold]
       [-i initialRearrangementSetting] [-I autoFC|autoMR|autoMRE|autoMRE_IGN]
       [-j] [-J MR|MRE] [-k] [-K] [-M]
       [-o outGroupName1[,outGroupName2[,...]]]
       [-p parsimonyRandomSeed] [-P proteinModel]
       [-q multipleModelFileName] [-r binaryConstraintTree]
       [-S secondaryStructureFile] [-t userStartingTree]
       [-T numberOfThreads] [-w workingDirectory]
       [-x rapidBootstrapRandomNumberSeed] [-y] [-Y]
       [-z multipleTreesFile] [-#|-N numberOfRuns|autoFC|autoMR|autoMRE|autoMRE_IGN]
	
Here is a list of options we will support; below it a list options we will not support:
	
    [-A secondaryStructureSubstModel] 	Specify one of the RNA secondary structure substitution models implemented in RAxML.
		7.2.0							The same nomenclature as in the PHASE manual is used, available models: 
										S6A, S6B, S6C, S6D, S6E, S7A, S7B, S7C, S7D, S7E, S7F, S16, S16A, S16B
										DEFAULT: 16-state GTR model (S16)
										6 state model nomenclature: http://www.cs.manchester.ac.uk/ai/Software/phase/manual/node101.html 
										7 state model nomenclature http://www.cs.manchester.ac.uk/ai/Software/phase/manual/node107.html
										16 state model nomenclature http://www.cs.manchester.ac.uk/ai/Software/phase/manual/node114.html

    [-b bootstrapRandomNumberSeed]		Specify an integer number (random seed) and turn on bootstrapping 
		7.0.4							DEFAULT: OFF
	
	[-B wcCriterionThreshold]		    Specify a floating point number between 0.0 and 1.0 that will be used as cutoff threshold for the WC bootstopping criterion. The recommended setting is 0.03.
		7.2.0							DEFAULT: 0.03 (recommended empirically determined setting)

    [-c numberOfCategories]				Specify number of distinct rate categories for RAxML when modelOfEvolution is set to GTRCAT
		7.0.4						    Individual per-site rates are categorized into numberOfCategories rate categories to accelerate computations. 						
										DEFAULT: 25

	[-D]							    ML search convergence criterion. This will break off ML searches if the relative Robinson-Foulds distance
										large trees between the trees obtained from two consecutive lazy SPR cycles is smaller or equal to 1%. Usage recommended
										in progress	for very large datasets in terms of taxa. On trees with more than 500 taxa this will yield execution time improvements
										of approximately 50% while yielding only slightly worse trees.
										DEFAULT: OFF

	[-E excludeFileName]				specify an exclude file name, that contains a specification of alignment positions you wish to exclude.
		7.0.4							Format is similar to Nexus, the file shall contain entries like "100-200 300-400", to exclude a
										single column write, e.g., "100-100", if you use a mixed model, an appropriately adapted model file will be written.

    [-f a|b|d|e|g|h|j|m|n|r|u|v|w|x|y]

		7.0.4			"-f a":	rapid Bootstrap analysis and search for best-scoring ML tree in one program run
		7.0.4			"-f b":	draw bipartition information on a tree provided with "-t" based on multiple trees (e.g., from a bootstrap) in a file specified by "-z"
		7.0.4			"-f d":	new rapid hill-climbing  (DEFAULT: ON) 
		7.0.4			"-f h":    compute log likelihood test (SH-test) between best tree passed via "-t"
                                    and a bunch of other trees passed via "-z"
		7.0.4			"-f s":	option can be used to split a multi-gene alignment into individual genes, provided a model file with -q. This might be useful to select best fitting models for individual partitions of an AA multi-gene alignment or to infer per-partition trees in order to analyze tree compatibility. Example: raxmlHPC -f s -q part -s alg -m GTRCAT -n TEST.
		not yet		   "-f m":	compare bipartitions between two bunches of trees passed via "-t" and "-z"  respectively. This will return the Pearson correlation 
					            between all partitions found in the two tree files. A file called RAxML_bipartitionFrequencies.outpuFileName will be printed that 
					            contains the pair-wise bipartition frequencies of the two sets
		not yet		   "-f n":	compute the log likelihood score of all trees contained in a tree file provided by "-z" under GAMMA or GAMMA+P-Invar
		not yet		   "-f r":	compute pairwise Robinson-Foulds (RF) distances between all pairs of trees in a tree file passed via "-z"  if the trees have node 
					            labels represented as integer support values the program will also compute two flavors of the weighted Robinson-Foulds (WRF) distance
		not yet		   "-f v":	classify a bunch of environmental sequences into a reference tree using the slow heuristics without dynamic alignment you will need
					            to start RAxML with a non-comprehensive reference tree and an alignment containing all sequences (reference + query)
		not yet		   "-f w":	compute ELW test on a bunch of trees passed via "-z" 
				   "-f x":	compute pair-wise ML distances, ML model parameters will be estimated on an MP starting tree or a user-defined tree passed via "-t",
					            only allowed for GAMMA-based models of rate heterogeneity
		not yet		   "-f y":	classify a bunch of environmental sequences into a reference tree using the fast heuristics without dynamic alignment you will need 
					            to start RAxML with a non-comprehensive reference tree and an alignment containing all sequences (reference + query)
	    not yet        "-f e":  optimize model+branch lengths for given input tree under GAMMA/GAMMAI only
	    not yet        "-f g":  compute per site log Likelihoods for one ore more trees passed via "-z" and write them to a file that can be read by CONSEL
                                WARNING: does not print likelihoods in the original column order
	    not yet        "-f j":  generate a bunch of bootstrapped alignment files from an original alignment file.
                                You need to specify a seed with "-b" and the number of replicates with "-#"
	    not yet        "-f u":  execute morphological weight calibration algorithm, this will return a weight vector.
                                you need to provide a morphological alignment and a reference tree via "-t"

	[-F]			   enable ML tree searches under CAT model for very large trees without switching to GAMMA in the end (saves memory) and print out some additional files
					   large trees)with intermediate trees from the search. This option can also be used with the GAMMA models in
					   order to avoid the thorough optimization  of the best-scoring in progress ML tree in the end.
					   DEFAULT: OFF

	[-g groupingFileName] specify the file name of a multifurcating constraint tree this tree does not need to be comprehensive, i.e. must not contain all taxa
			7.0.4

    [-G]                enable the ML-based evolutionary placement algorithm heuristics by specifiyng a threshold value 
                       (fraction of insertion branches to be evaluated using slow insertions under ML).

    [-H]                enable the MP-based evolutionary placement algorithm heuristics by specifiyng a threshold value 
                       (fraction of insertion branches to be evaluated using slow insertions under ML).

	[-i initialRearrangementSetting]			Initial rearrangement setting for the subsequent application of topological changes phase.
			7.0.4								DEFAULT: determined by program; integer input; if selected, default value of 10 is provided.

	[-I]      a posteriori bootstopping analysis. Use:
              "-I autoFC" for the frequency-based criterion
              "-I autoMR" for the majority-rule consensus tree criterion
              "-I autoMRE" for the extended majority-rule consensus tree criterion
              "-I autoMRE_IGN" for metrics similar to MRE, but include bipartitions under the threshold whether they are compatible
              or not. This emulates MRE but is faster to compute. You also need to pass a tree file containing several bootstrap replicates via "-z"

	[-J]      Compute majority rule consensus tree with "-J MR" or extended majority rule consensus tree with "-J MRE"
              You will need to provide a tree file containing several trees via "-z"
	
	[-K] Specify one of the multi-state substitution models (max 32 states) implemented in RAxML.
              Available models are: ORDERED, MK, GTR
              DEFAULT: GTR model 

    [ -m      Model of Binary (Morphological), Nucleotide or Amino Acid Substitution]: 

            BINARY: (NEW for 7.2.0)
			(now implemented)
                "-m BINCAT"         : Optimization of site-specific evolutionary rates which are categorized into numberOfCategories distinct rate categories for greater computational efficiency. Final tree
											 might be evaluated automatically under BINGAMMA, depending on the tree search option
                "-m BINCATI"        : Optimization of site-specific evolutionary rates which are categorized into numberOfCategories distinct 
                                      rate categories for greater computational efficiency. Final tree might be evaluated
                                      automatically under BINGAMMAI, depending on the tree search option 
                "-m BINGAMMA"       : GAMMA model of rate heterogeneity (alpha parameter will be estimated)
                "-m BINGAMMAI"      : Same as BINGAMMA, but with estimate of proportion of invariable sites
	
	

              NUCLEOTIDES:

                "-m GTRCAT"         : GTR + Optimization of substitution rates + Optimization of site-specific
                                      evolutionary rates which are categorized into numberOfCategories distinct 
                                      rate categories for greater computational efficiency.  Final tree might be evaluated
                                      under GTRGAMMA, depending on the tree search option
                "-m GTRCAT_FLOAT"   : Same as above but uses single-precision floating point arithmetics instead of double-precision
                                      Usage only recommend for testing, the code will run slower, but can save almost 50% of memory.
                                      If you have problems with phylogenomic datasets and large memory requirements you may give it a shot.
                                      Keep in mind that numerical stability seems to be okay but needs further testing.
                "-m GTRCATI"        : GTR + Optimization of substitution rates + Optimization of site-specific
                                      evolutionary rates which are categorized into numberOfCategories distinct 
                                      rate categories for greater computational efficiency.  Final tree might be evaluated
                                      under GTRGAMMAI, depending on the tree search option
                "-m GTRGAMMA"       : GTR + Optimization of substitution rates + GAMMA model of rate 
                                      heterogeneity (alpha parameter will be estimated)
                "-m GTRGAMMA_FLOAT" : Same as GTRGAMMA, but also with single-precision arithmetics, same cautionary notes as for  
                                      GTRCAT_FLOAT apply.
                "-m GTRGAMMAI"      : Same as GTRGAMMA, but with estimate of proportion of invariable sites 

	
            MULTI-STATE:

                 "-m MULTICAT"         : Optimization of site-specific evolutionary rates which are categorized into numberOfCategories distinct
                                       rate categories for greater computational efficiency. Final tree might be evaluated automatically under MULTIGAMMA,
	                                   depending on the tree search option
                 "-m MULTICATI"        : Optimization of site-specific evolutionary rates which are categorized into numberOfCategories distinct
                                       rate categories for greater computational efficiency. Final tree might be evaluated automatically under MULTIGAMMAI, depending on the 
	                                   tree search option
                 "-m MULTIGAMMA"       : GAMMA model of rate heterogeneity (alpha parameter will be estimated)
                 "-m MULTIGAMMAI"      : Same as MULTIGAMMA, but with estimate of proportion of invariable sites
	                                     You can use up to 32 distinct characters to encode multi-state regions, they must be used in the following 
	                                     order:0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V
                                         i.e., if you have 6 distinct characters you would use 0, 1, 2, 3, 4, 5 to encode these.
                                         The substitution model for the multi-state regions can be selected via the "-K" option

           AMINO ACIDS:
	            "-m PROTCATmatrixName[F]" : specified AA matrix + Optimization of substitution rates + Optimization of site-specific
	                                        evolutionary rates which are categorized into numberOfCategories distinct rate categories for greater computational 
	                                        efficiency.   Final tree might be evaluated automatically under PROTGAMMAmatrixName[f], 
                                            depending on the tree search option
                "-m PROTCATmatrixName[F]_FLOAT" : PROTCAT with single precision arithmetics, same cautionary notes as for GTRCAT_FLOAT apply
                "-m PROTCATImatrixName[F]"      : specified AA matrix + Optimization of substitution rates + Optimization of site-specific
                                                  evolutionary rates which are categorized into numberOfCategories distinct rate categories for greater computational 
	                                              efficiency.   Final tree might be evaluated automatically under PROTGAMMAImatrixName[f], 
                                                  depending on the tree search option
                 "-m PROTGAMMAmatrixName[F]"    : specified AA matrix + Optimization of substitution rates + GAMMA model of rate heterogeneity (alpha parameter will be estimated)
                 "-m PROTGAMMAmatrixName[F]_FLOAT" : PROTGAMMA with single precision arithmetics, same cautionary notes as for GTRCAT_FLOAT apply
                 "-m PROTGAMMAImatrixName[F]" : Same as PROTGAMMAmatrixName[F], but with estimate of proportion of invariable sites
           Available AA substitution models: DAYHOFF, DCMUT, JTT, MTREV, WAG, RTREV, CPREV, VT, BLOSUM62, MTMAM, LG, GTR
           With the optional "F" appendix you can specify if you want to use empirical base frequencies
           Please note that for mixed models you can in addition specify the per-gene AA model in the mixed model file (see manual 
           for details). Also note that if you estimate AA GTR parameters on a partitioned dataset, they will be linked
	       estimated jointly) across all partitions to avoid over-parametrization

	
      [-o outGroupName1[,outGroupName2[,...]]] Specify the name of a single outgroup or a comma-separated list of outgroups, eg "-o Rat"
               or "-o Rat,Mouse", in case that multiple outgroups are not monophyletic the first name in the list will be selected as 
               outgroup, don't leave spaces between taxon names!


      [-P proteinModel]      Specify the file name of a user-defined AA (Protein) substitution model. This file must contain
               420 entries, the first 400 being the AA substitution rates (this must be a symmetric matrix) and the
               last 20 are the empirical base frequencies

      [-q multipleModelFileName]      Specify the file name which contains the assignment of models to alignment
               partitions for multiple models of substitution. For the syntax of this file
               please consult the manual.

      [-r binaryConstraintTree]      Specify the file name of a binary constraint tree.
               this tree does not need to be comprehensive, i.e. must not contain all taxa

      [-S secondaryStructureFile] Specify the name of a secondary structure file. The file can contain "." for
               alignment columns that do not form part of a stem and characters "()<>[]{}" to define
               stem regions and pseudoknots

	  [-t userStartingTree] Specify a user starting tree file name in Newick format

      [-T numberOfThreads] PTHREADS VERSION ONLY! Specify the number of threads you want to run.
               Make sure to set "-T" to at most the number of CPUs you have on your machine,
               otherwise, there will be a huge performance decrease!

      [-x rapidBootstrapRandomNumberSeed] Specify an integer number (random seed) and turn on rapid bootstrapping
               CAUTION: unlike in version 7.0.4 RAxML will conduct rapid BS replicates under
               the model of rate heterogeneity you specified via "-m" and not by default under CAT

	  [-y]  If you want to only compute a parsimony starting tree with RAxML specify "-y",
             the program will exit after computation of the starting tree
             DEFAULT: OFF
	   
	  [-Y] Do a more thorough parsimony tree search using a parsimony ratchet and exit.
               specify the number of ratchet searches via "-#" or "-N"
               This has just been implemented for completeness, if you want a fast MP implementation use TNT
               DEFAULT: OFF

      [-z multipleTreesFile] Specify the file name of a file containing multiple trees e.g. from a bootstrap
               that shall be used to draw bipartition values onto a tree provided with "-t",
               It can also be used to compute per site log likelihoods in combination with "-f g"
               and to read a bunch of trees for a couple of other options ("-f h", "-f m", "-f n").
	
	  [-#|-NnumberOfRuns|autoFC|autoMR|autoMRE|autoMRE_IGN] Specify the number of alternative runs on distinct starting trees
              In combination with the "-b" option, this will invoke a multiple bootstrap analysis
              Note that "-N" has been added as an alternative since "-#" sometimes caused problems
              with certain MPI job submission systems, since "-#" is often used to start comments.
              If you want to use the bootstopping criteria specify "-# autoMR" or "-# autoMRE" or "-# autoMRE_IGN"
              for the majority-rule tree based criteria (see -I option) or "-# autoFC" for the frequency-based criterion.
              Bootstopping will only work in combination with "-x" or "-b"
              DEFAULT: 1 single analysis
	
		##########################################not supported #########################################
	
	[-a weightFileName]  	Specify a column weight file name to assign individual weights to each column of 
									the alignment. Those weights must be integers separated by any type and number 
									of whitespaces within a separate file, see file "example_weights" for an example.

	[-C]      Conduct model parameter optimization on gappy, partitioned multi-gene alignments with per-partition
              branch length estimates (-M enabled) using the fast method with pointer meshes described in:
              Stamatakis and Ott: "Efficient computation of the phylogenetic likelihood function on multi-gene alignments and multi-core processors"
              WARNING: We can not conduct any tree searches using this method yet! Does not work with Pthreads version.

	[-d]													Start ML optimization from random starting tree 
															DEFAULT: OFF

    [-e likelihoodEpsilon] 							 set model optimization precision in log likelihood units for final optimization of tree topology under MIX/MIXI or GAMMA/GAMMAI
															DEFAULT: 	0.1   for models not using proportion of invariant sites estimate
																				0.001 for models using proportion of invariant sites estimate

    [-f      select algorithm]:
			"-f A":(usage not recommended) classify a bunch of environmental sequences into a reference tree with dynamic alignment under MP
              you will need to start RAxML with a non-comprehensive reference tree and an alignment containing all sequences (reference + query)
            "-f c":	check if the alignment can be properly read by RAxML
            "-f e":	optimize model+branch lengths for given input tree under GAMMA/GAMMAI only
            "-f g":	compute per site log Likelihoods for one or more trees passed via "-z" and write them to a file that can be read by CONSEL
            "-f i":		perform a really thorough bootstrap, refinement of final BS tree under GAMMA and a more exhaustive algorithm
            "-f j":		generate a bunch of bootstrapped alignment files
            "-f o":	(will not implement) old and slower rapid hill-climbing 
            "-f p":	perform pure stepwise MP addition of new sequences to an incomplete starting tree
            "-f t":		do randomized tree searches on one fixed starting tree
			"-f X":	(usage not recommended) classify a bunch of environmental sequences into a reference tree using the slow heuristics with dynamic alignment
						you will need to start RAxML with a non-comprehensive reference tree and an alignment containing all sequences (reference + query)
			"-f q":	(usage not recommended) classify a bunch of environmental sequences into a reference tree using the fast heuristics with 
						dynamic alignment you will need to start RAxML with a non-comprehensive reference tree and an alignment containing all
						sequences (reference + query)

	[-h]				Display this help message

    [ -j]    			Specifies if checkpoints will be written by the program. If checkpoints 
						(intermediate tree topologies) shall be written by the program specify "-j". 
						DEFAULT: OFF

	[-k] 				Specifies that bootstrapped trees should be printed with branch lengths. The bootstraps will run a bit longer, because model parameters will be optimized at 
						the end of each run under GAMMA or GAMMA+P-Invar respectively.
						DEFAULT: OFF (old version said Use with CATMIX/PROTMIX or GAMMA/GAMMAI., check on this)

    [-l sequenceSimilarityThreshold]		Specify a threshold for sequence similarity clustering. RAxML will then print out an alignment to a file called sequenceFileName.reducedBy.threshold that only contains sequences <= the specified threshold that must be between  0.0 and 1.0. RAxML uses the QT-clustering algorithm  to perform this task.	In addition, a file called RAxML_reducedList.outputFileName will be written that contains clustering information. DEFAULT: OFF
	
	[-M]				Switch on estimation of individual per-partition branch lengths. Only has effect when used in combination with "-q". Branch lengths for individual partitions will be printed to separate files
						A weighted average of the branch lengths is computed by using the respective partition lengths
						DEFAULT: OFF

    [-p]      Specify a random number seed for the parsimony inferences. This allows you to reproduce your results
               and will help me debug the program. This option HAS NO EFFECT in the parallel MPI version
	
    [-u]				Specify the number of multiple BS searches per replicate to obtain better ML trees for each replicate. 
						DEFAULT: One ML search per BS replicate. Absent from raxml 7.2.0??

	[-v]				Display version information


	[-w workingDirectory]		Name of the working directory where RAxML will write its output files
										DEFAULT: current directory
 -->
<!-- 
##################################(added on 5/5/2009)#########################################################################

mamiller made some changes top grouping, so parameters are written on the command line in the order specified by the manual

	-E 	excludefile specify a range of characters to exclude

###################################(modified 8/3/2009)########################################################################

mamiller made the parsimony seed option invalid when the -y option is in force. 

###########################################################################################################################
	
##################################(added on 9/1/2009)########################################################################

mamiller exposed the -f h option in response to a user request	

##################################(added on 10/31/2009)######################################################################

mamiller repaired the -p option;
	removed the superfluous -f d option and its preconds.
Also, the preconds all had &amp; where they should have had &amp;&amp; this was repaired
Some ctrl features were broken. I cant seem to fix them and made the best workarounds I could with other tools and trext.

##################################(added on 12/31/2009)######################################################################
	
	
we must remove some of the model  options that are no longer used (as of 7.1.0).
this includes 

         "-m GTRMIX"                      : Inference of the tree under GTRCAT
                                            and thereafter evaluation of the final tree topology under GTRGAMMA	
	     "-m GTRMIXI"                     : Same as GTRMIX, but with estimate of proportion of invariable sites 
	     
		 "-m GTRCAT_GAMMA"                : Inference of the tree with site-specific evolutionary rates.
                                            However, here rates are categorized using the 4 discrete GAMMA rates.
                                            Evaluation of the final tree topology under GTRGAMMA 
	
         "-m GTRCAT_GAMMAI"               : Same as GTRCAT_GAMMA, but with estimate of proportion of invariable sites 
	
these options are not supported:
	     "-m GTRCAT_FLOAT"   : Same as above but uses single-precision floating point arithmetics instead of double-precision
                                      Usage only recommend for testing, the code will run slower, but can save almost 50% of memory.
                                      If you have problems with phylogenomic datasets and large memory requirements you may give it a shot.
                                      Keep in mind that numerical stability seems to be okay but needs further testing.
	
	     "-m GTRCATI"               : Same as GTRCAT_GAMMA, but with estimate of proportion of invariable sites 
	
	     "-m GTRGAMMA_FLOAT" : Same as GTRGAMMA, but also with single-precision arithmetics, same cautionary notes as for  
                                      GTRCAT_FLOAT apply.
	
	     "-m GTRGAMMAI"               : Same as GTRCAT_GAMMA, but with estimate of proportion of invariable sites 

	change vdef to GTRCAT
	
from alexis:
> 
> Specifically, here is what I think is true (and I plan to write on our interface):
> 
> For RAxML versions 7.1.0 and later, the same flag GTRGAMMA (which 
> creates the command line -m GTRGAMMA -x -f a) causes GTRGAMMA to be 
> used both during the rapid bootstrapping AND inference of the best 
> tree. This takes much longer than the previous method,

Correct.

> where GTRCAT is used to conduct the bootstrapping phase. In other 
> words, if you want to run a bootstrapping experiment, choosing the model GTRCAT (-m GTRCAT -x -f a) is identical to 
	choosing GTRGAMMA in RAxML 7.0.4 and below.

Exactly.

> In other words, the GTRCAT switch causes GTRCAT to be used during the rapid bootstrapping, but the program then 
switches to GTRGAMMA for the ML search.

Yes, but only in the very end, where an attempt is made to further improve the current ML tree using a 
	more thorough version of SPR moves.

> (BUT: I don't know what this means: 
	"Final tree might be evaluated under GTRGAMMA, depending on the tree search option."

For rapid bootstrapping the final ML tree will always be evaluated under GAMMA.

> The GTRMIX option (which conducted inference under GRTCAT and calculated best tree under GTRGAMMA) is no longer offered for RAxML 7.1.0 and above. 

Exactly.

> (was gtrmix the same as bootstrapping with gtrgamma in the past? 

Yes.

> how should people who used that option accomplish the same analysis?
> Was this not a useful option?)

It was a useful option, GTRCAT now essentially does was GTRMIX used to do, I just designed the program like that, to keep users from inappropriately using CAT.

############################################################################################################################
User request for -f x

I have been using raxml a fair bit recently and was wondering if you might be able to add a feature please?
I'd like to be able to export a distance matrix.  I don't know the exact syntax for that, but the 7.0.4 manual has -f x: at the bottom of page 9.

Also, it might avoid some confusion if there is some comment in the section on using a starting tree (Supply a starting tree (-t))that this is not available when doing rapid bootstrapping as raxml just gives an error message without really saying why it gave an error.

#############################################################################################################################
1/19/2010
	mamiller added logic to help the program run well using the hybrid option
	
##############################################################################################################################
	
##############################################################################################################################
9/25/2010
	mamiller added new commands to update the interface for 7.2.7
	the big change in this code is that bootstopping, automatic stopping of bootstraps, is not supported in the hybrid parallel code.
	this new interface reflects the rules created by Wayne Pfeiffer for picking the number of nodes, MPI processes, and threads to use 
	for  -N nnn, where nnn is not a number, but a bootstopping command. All of these bootstopping cases should use the same rules as for nnn >= 50.
   
	
	   [-f c|E|F|i|I|J|o|p|R|s|S|t|U|v|] [-F]
       [-g groupingFileName] [-G placementThreshold] [-h] [-H 
placementThreshold]
       [-i initialRearrangementSetting] [-I autoFC|autoMR|autoMRE|autoMRE_IGN]
       [-j] [-J MR|MR_DROP|MRE|STRICT|STRICT_DROP] [-k] [-K] [-M]
       [-o outGroupName1[,outGroupName2[,...]]] [-O checkPointInterval]
       [-p parsimonyRandomSeed] [-P proteinModel]
       [-q multipleModelFileName] [-r binaryConstraintTree]
       [-R binaryModelParamFile] [-S secondaryStructureFile] [-t 
userStartingTree]
       [-T numberOfThreads] [-U] [-v] [-w outputDirectory] [-W 
slidingWindowSize]
       [-x rapidBootstrapRandomNumberSeed] [-y] [-Y]
       [-z multipleTreesFile] [-#|-N 
numberOfRuns|autoFC|autoMR|autoMRE|autoMRE_IGN]

       -a      Specify a column weight file name to assign individual 
weights to each column of
               the alignment. Those weights must be integers separated 
by any type and number
               of whitespaces whithin a separate file, see file 
"example_weights" for an example.

       -A      Specify one of the secondary structure substitution 
models implemented in RAxML.
               The same nomenclature as in the PHASE manual is used, 
available models:
               S6A, S6B, S6C, S6D, S6E, S7A, S7B, S7C, S7D, S7E, S7F, 
S16, S16A, S16B

               DEFAULT: 16-state GTR model (S16)

       -E      specify an exclude file name, that contains a 
specification of alignment positions you wish to exclude.
               Format is similar to Nexus, the file shall contain 
entries like "100-200 300-400", to exclude a
               single column write, e.g., "100-100", if you use a 
mixed model, an appropriatly adapted model file
               will be written.

       -f      select algorithm:
	   [-f J|p|R|S|U|v|] [-F]

(not sure)     "-f J": Compute SH-like support values on a given tree passed via "-t".
(not sure)     "-f p": perform pure stepwise MP addition of new sequences to an incomplete starting tree and exit
(not sure)      "-f R": compute rogue taxa using new statistical method based on the evolutionary placement algorithm WARNING: this is experimental code
(not sure)     "-f S": compute site-specific placement bias using a leave one out test inspired by the evolutionary placement algorithm
(not sure)     "-f U": execute morphological wieght calibration using parsimony, this will return a weight vector.
                       you need to provide a morphological alignment and a reference tree via "-t"
(not sure)     "-f v": classify a bunch of environmental sequences into a reference tree using the slow heuristics without dynamic alignment
                       you will need to start RAxML with a non-comprehensive reference tree and an alignment containing all sequences (reference + query)

               DEFAULT for "-f": new rapid hill climbing

(not supported)       -O      Enable checkpointing using the dmtcp library available at http://dmtcp.sourceforge.net/
               This only works if you call the program by preceded by the command "dmtcp_checkpoint"
               and if you compile a dedicated binary using the appropriate Makefile.
               With "-O" you can specify the interval between checkpoints in seconds. DEFAULT: 3600.0 seconds

(not supported)       -R      Specify the file name of a binary model parameter file that has previously been generated
               with RAxML using the -f e tree evaluation option. The file name should be:
               RAxML_binaryModelParameters.runID

(not supported)      -U      Try to save memory by using SEV-based implementation for gap columns on large gappy alignments
               WARNING: this will only work for DNA under GTRGAMMA and is still in an experimental state.

(not sure) -W      Sliding window size for leave-one-out site-specific placement bias algorithm
               only effective when used in combination with "-f S" DEFAULT: 100 sites
-->
<!-- 1/11/11 -->
<!-- the interface was modified by mamiller to accomodate submission of jobs to both Comet and abe -->
<!-- later shifted to Comet only -->
<!-- 3/15/2011 upgrade to raxml 7.3.0, eliminates constraint issue -->
<!--
	mamiller added this text in to give the most current command line options.
This is RAxML version 7.3.1 released by Alexandros Stamatakis in May 2012.

raxmlHPC[-SSE3|-PTHREADS|-PTHREADS-SSE3|-HYBRID|-HYBRID-SSE3]
      -s sequenceFileName -n outputFileName -m substitutionModel
      [-a weightFileName] [-A secondaryStructureSubstModel]
      [-b bootstrapRandomNumberSeed] [-B wcCriterionThreshold]
      [-c numberOfCategories] [-C] [-d] [-D]
      [-e likelihoodEpsilon] [-E excludeFileName]
      [-f a|A|b|c|d|e|E|F|g|h|i|I|j|J|m|n|o|p|r|s|S|t|u|v|w|x|y] [-F]
      [-g groupingFileName] [-G placementThreshold] [-h]
      [-i initialRearrangementSetting] [-I autoFC|autoMR|autoMRE|autoMRE_IGN]
      [-j] [-J MR|MR_DROP|MRE|STRICT|STRICT_DROP] [-k] [-K] [-M]
      [-o outGroupName1[,outGroupName2[,...]]][-O]
      [-p parsimonyRandomSeed] [-P proteinModel]
      [-q multipleModelFileName] [-r binaryConstraintTree]
      [-R binaryModelParamFile] [-S secondaryStructureFile] [-t userStartingTree]
      [-T numberOfThreads] [-u] [-U] [-v] [-V] [-w outputDirectory] [-W slidingWindowSize]
      [-x rapidBootstrapRandomNumberSeed] [-X] [-y]
      [-z multipleTreesFile] [-#|-N numberOfRuns|autoFC|autoMR|autoMRE|autoMRE_IGN]

      -a      Specify a column weight file name to assign individual weights to each column of 
              the alignment. Those weights must be integers separated by any type and number 
              of whitespaces whithin a separate file, see file "example_weights" for an example.

      -A      Specify one of the secondary structure substitution models implemented in RAxML.
              The same nomenclature as in the PHASE manual is used, available models: 
              S6A, S6B, S6C, S6D, S6E, S7A, S7B, S7C, S7D, S7E, S7F, S16, S16A, S16B

              DEFAULT: 16-state GTR model (S16)

      -b      Specify an integer number (random seed) and turn on bootstrapping

              DEFAULT: OFF

      -B      specify a floating point number between 0.0 and 1.0 that will be used as cutoff threshold 
              for the MR-based bootstopping criteria. The recommended setting is 0.03.

              DEFAULT: 0.03 (recommended empirically determined setting)

      -c      Specify number of distinct rate catgories for RAxML when modelOfEvolution
              is set to GTRCAT or GTRMIX
              Individual per-site rates are categorized into numberOfCategories rate 
              categories to accelerate computations. 

              DEFAULT: 25

      -C      Conduct model parameter optimization on gappy, partitioned multi-gene alignments with per-partition
              branch length estimates (-M enabled) using the fast method with pointer meshes described in:
              Stamatakis and Ott: "Efficient computation of the phylogenetic likelihood function on multi-gene alignments and multi-core processors"
              WARNING: We can not conduct useful tree searches using this method yet! Does not work with Pthreads version.

      -d      start ML optimization from random starting tree 

              DEFAULT: OFF

      -D      ML search convergence criterion. This will break off ML searches if the relative 
              Robinson-Foulds distance between the trees obtained from two consecutive lazy SPR cycles
              is smaller or equal to 1%. Usage recommended for very large datasets in terms of taxa.
              On trees with more than 500 taxa this will yield execution time improvements of approximately 50%
              While yielding only slightly worse trees.

              DEFAULT: OFF

      -e      set model optimization precision in log likelihood units for final
              optimization of tree topology under MIX/MIXI or GAMMA/GAMMAI

              DEFAULT: 0.1   for models not using proportion of invariant sites estimate
                       0.001 for models using proportion of invariant sites estimate

      -E      specify an exclude file name, that contains a specification of alignment positions you wish to exclude.
              Format is similar to Nexus, the file shall contain entries like "100-200 300-400", to exclude a
              single column write, e.g., "100-100", if you use a mixed model, an appropriatly adapted model file
              will be written.

      -f      select algorithm:

              "-f a": rapid Bootstrap analysis and search for best-scoring ML tree in one program run
              "-f A": compute marginal ancestral states on a ROOTED reference tree provided with "t"
              "-f b": draw bipartition information on a tree provided with "-t" based on multiple trees
                      (e.g., from a bootstrap) in a file specifed by "-z"
              "-f c": check if the alignment can be properly read by RAxML
              "-f d": new rapid hill-climbing 
                      DEFAULT: ON
              "-f e": optimize model+branch lengths for given input tree under GAMMA/GAMMAI only
              "-f E": execute very fast experimental tree search, at present only for testing
              "-f F": execute fast experimental tree search, at present only for testing
              "-f g": compute per site log Likelihoods for one ore more trees passed via
                      "-z" and write them to a file that can be read by CONSEL
              "-f h": compute log likelihood test (SH-test) between best tree passed via "-t"
                      and a bunch of other trees passed via "-z" 
              "-f i": EXPERIMENTAL do not use for real tree inferences: conducts a single cycle of fast lazy SPR moves
                      on a given input tree, to be used in combination with -C and -M 
              "-f I": EXPERIMENTAL do not use for real tree inferences: conducts a single cycle of thorough lazy SPR moves
                      on a given input tree, to be used in combination with -C and -M 
              "-f j": generate a bunch of bootstrapped alignment files from an original alignemnt file.
                      You need to specify a seed with "-b" and the number of replicates with "-#" 
              "-f J": Compute SH-like support values on a given tree passed via "-t".
              "-f m": compare bipartitions between two bunches of trees passed via "-t" and "-z" 
                      respectively. This will return the Pearson correlation between all bipartitions found
                      in the two tree files. A file called RAxML_bipartitionFrequencies.outpuFileName
                      will be printed that contains the pair-wise bipartition frequencies of the two sets
              "-f n": compute the log likelihood score of all trees contained in a tree file provided by
                      "-z" under GAMMA or GAMMA+P-Invar
              "-f o": old and slower rapid hill-climbing without heuristic cutoff
              "-f p": perform pure stepwise MP addition of new sequences to an incomplete starting tree and exit
              "-f r": compute pairwise Robinson-Foulds (RF) distances between all pairs of trees in a tree file passed via "-z" 
                      if the trees have node labales represented as integer support values the program will also compute two flavors of
                      the weighted Robinson-Foulds (WRF) distance
              "-f s": split up a multi-gene partitioned alignment into the respective subalignments 
              "-f S": compute site-specific placement bias using a leave one out test inspired by the evolutionary placement algorithm
              "-f t": do randomized tree searches on one fixed starting tree
              "-f u": execute morphological weight calibration using maximum likelihood, this will return a weight vector.
                      you need to provide a morphological alignment and a reference tree via "-t" 
              "-f v": classify a bunch of environmental sequences into a reference tree using thorough read insertions
                      you will need to start RAxML with a non-comprehensive reference tree and an alignment containing all sequences (reference + query)
              "-f w": compute ELW test on a bunch of trees passed via "-z" 
              "-f x": compute pair-wise ML distances, ML model parameters will be estimated on an MP 
                      starting tree or a user-defined tree passed via "-t", only allowed for GAMMA-based
                      models of rate heterogeneity
              "-f y": classify a bunch of environmental sequences into a reference tree using parsimony
                      you will need to start RAxML with a non-comprehensive reference tree and an alignment containing all sequences (reference + query)

              DEFAULT for "-f": new rapid hill climbing


      -F      enable ML tree searches under CAT model for very large trees without switching to 
              GAMMA in the end (saves memory).
              This option can also be used with the GAMMA models in order to avoid the thorough optimization 
              of the best-scoring ML tree in the end.

              DEFAULT: OFF

      -g      specify the file name of a multifurcating constraint tree
              this tree does not need to be comprehensive, i.e. must not contain all taxa

      -G      enable the ML-based evolutionary placement algorithm heuristics
              by specifiyng a threshold value (fraction of insertion branches to be evaluated
              using slow insertions under ML).

      -h      Display this help message.

      -i      Initial rearrangement setting for the subsequent application of topological 
              changes phase

      -I      a posteriori bootstopping analysis. Use:
             "-I autoFC" for the frequency-based criterion
             "-I autoMR" for the majority-rule consensus tree criterion
             "-I autoMRE" for the extended majority-rule consensus tree criterion
             "-I autoMRE_IGN" for metrics similar to MRE, but include bipartitions under the threshold whether they are compatible
                              or not. This emulates MRE but is faster to compute.
              You also need to pass a tree file containg several bootstrap replicates via "-z" 

      -j      Specifies that intermediate tree files shall be written to file during the standard ML and BS tree searches.

              DEFAULT: OFF

      -J      Compute majority rule consensus tree with "-J MR" or extended majority rule consensus tree with "-J MRE"
              or strict consensus tree with "-J STRICT".
              Options "-J STRICT_DROP" and "-J MR_DROP" will execute an algorithm that identifies dropsets which contain
              rogue taxa as proposed by Pattengale et al. in the paper "Uncovering hidden phylogenetic consensus".
              You will also need to provide a tree file containing several UNROOTED trees via "-z"

      -k      Specifies that bootstrapped trees should be printed with branch lengths.
              The bootstraps will run a bit longer, because model parameters will be optimized
              at the end of each run under GAMMA or GAMMA+P-Invar respectively.

              DEFAULT: OFF

      -K      Specify one of the multi-state substitution models (max 32 states) implemented in RAxML.
              Available models are: ORDERED, MK, GTR

              DEFAULT: GTR model 

      -m      Model of Binary (Morphological), Nucleotide, Multi-State, or Amino Acid Substitution: 

              BINARY:

                "-m BINCAT"         : Optimization of site-specific
                                      evolutionary rates which are categorized into numberOfCategories distinct 
                                      rate categories for greater computational efficiency. Final tree might be evaluated
                                      automatically under BINGAMMA, depending on the tree search option
                "-m BINCATI"        : Optimization of site-specific
                                      evolutionary rates which are categorized into numberOfCategories distinct 
                                      rate categories for greater computational efficiency. Final tree might be evaluated
                                      automatically under BINGAMMAI, depending on the tree search option 
                "-m BINGAMMA"       : GAMMA model of rate 
                                      heterogeneity (alpha parameter will be estimated)
                "-m BINGAMMAI"      : Same as BINGAMMA, but with estimate of proportion of invariable sites

              NUCLEOTIDES:

                "-m GTRCAT"         : GTR + Optimization of substitution rates + Optimization of site-specific
                                      evolutionary rates which are categorized into numberOfCategories distinct 
                                      rate categories for greater computational efficiency.  Final tree might be evaluated
                                      under GTRGAMMA, depending on the tree search option
                "-m GTRCATI"        : GTR + Optimization of substitution rates + Optimization of site-specific
                                      evolutionary rates which are categorized into numberOfCategories distinct 
                                      rate categories for greater computational efficiency.  Final tree might be evaluated
                                      under GTRGAMMAI, depending on the tree search option
                "-m GTRGAMMA"       : GTR + Optimization of substitution rates + GAMMA model of rate 
                                      heterogeneity (alpha parameter will be estimated)
                "-m GTRGAMMAI"      : Same as GTRGAMMA, but with estimate of proportion of invariable sites 

              MULTI-STATE:

                "-m MULTICAT"         : Optimization of site-specific
                                      evolutionary rates which are categorized into numberOfCategories distinct 
                                      rate categories for greater computational efficiency. Final tree might be evaluated
                                      automatically under MULTIGAMMA, depending on the tree search option
                "-m MULTICATI"        : Optimization of site-specific
                                      evolutionary rates which are categorized into numberOfCategories distinct 
                                      rate categories for greater computational efficiency. Final tree might be evaluated
                                      automatically under MULTIGAMMAI, depending on the tree search option 
                "-m MULTIGAMMA"       : GAMMA model of rate 
                                      heterogeneity (alpha parameter will be estimated)
                "-m MULTIGAMMAI"      : Same as MULTIGAMMA, but with estimate of proportion of invariable sites

                You can use up to 32 distinct character states to encode multi-state regions, they must be used in the following order:
                0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V
                i.e., if you have 6 distinct character states you would use 0, 1, 2, 3, 4, 5 to encode these.
                The substitution model for the multi-state regions can be selected via the "-K" option

              AMINO ACIDS:

                "-m PROTCATmatrixName[F]"         : specified AA matrix + Optimization of substitution rates + Optimization of site-specific
                                                    evolutionary rates which are categorized into numberOfCategories distinct 
                                                    rate categories for greater computational efficiency.   Final tree might be evaluated
                                                    automatically under PROTGAMMAmatrixName[f], depending on the tree search option
                "-m PROTCATImatrixName[F]"        : specified AA matrix + Optimization of substitution rates + Optimization of site-specific
                                                    evolutionary rates which are categorized into numberOfCategories distinct 
                                                    rate categories for greater computational efficiency.   Final tree might be evaluated
                                                    automatically under PROTGAMMAImatrixName[f], depending on the tree search option
                "-m PROTGAMMAmatrixName[F]"       : specified AA matrix + Optimization of substitution rates + GAMMA model of rate 
                                                    heterogeneity (alpha parameter will be estimated)
                "-m PROTGAMMAImatrixName[F]"      : Same as PROTGAMMAmatrixName[F], but with estimate of proportion of invariable sites 

                Available AA substitution models: DAYHOFF, DCMUT, JTT, MTREV, WAG, RTREV, CPREV, VT, BLOSUM62, MTMAM, LG, MTART, MTZOA, PMB, HIVB, HIVW, JTTDCMUT, FLU, GTR
                With the optional "F" appendix you can specify if you want to use empirical base frequencies
                Please note that for mixed models you can in addition specify the per-gene AA model in
                the mixed model file (see manual for details). Also note that if you estimate AA GTR parameters on a partitioned
                dataset, they will be linked (estimated jointly) across all partitions to avoid over-parametrization

      -M      Switch on estimation of individual per-partition branch lengths. Only has effect when used in combination with "-q"
              Branch lengths for individual partitions will be printed to separate files
              A weighted average of the branch lengths is computed by using the respective partition lengths

              DEFAULT: OFF

      -n      Specifies the name of the output file.

      -o      Specify the name of a single outgrpoup or a comma-separated list of outgroups, eg "-o Rat" 
              or "-o Rat,Mouse", in case that multiple outgroups are not monophyletic the first name 
              in the list will be selected as outgroup, don't leave spaces between taxon names!

      -O      Disable check for completely undetermined sequence in alignment.
              The program will not exit with an error message when "-O" is specified.

              DEFAULT: check enabled

      -p      Specify a random number seed for the parsimony inferences. This allows you to reproduce your results
              and will help me debug the program.

      -P      Specify the file name of a user-defined AA (Protein) substitution model. This file must contain
              420 entries, the first 400 being the AA substitution rates (this must be a symmetric matrix) and the
              last 20 are the empirical base frequencies

      -q      Specify the file name which contains the assignment of models to alignment
              partitions for multiple models of substitution. For the syntax of this file
              please consult the manual.

      -r      Specify the file name of a binary constraint tree.
              this tree does not need to be comprehensive, i.e. must not contain all taxa

      -R      Specify the file name of a binary model parameter file that has previously been generated
              with RAxML using the -f e tree evaluation option. The file name should be: 
              RAxML_binaryModelParameters.runID

      -s      Specify the name of the alignment data file in PHYLIP format

      -S      Specify the name of a secondary structure file. The file can contain "." for 
              alignment columns that do not form part of a stem and characters "()<>[]{}" to define 
              stem regions and pseudoknots

      -t      Specify a user starting tree file name in Newick format

      -T      PTHREADS VERSION ONLY! Specify the number of threads you want to run.
              Make sure to set "-T" to at most the number of CPUs you have on your machine,
              otherwise, there will be a huge performance decrease!

      -u      use the median for the discrete approximation of the GAMMA model of rate heterogeneity

              DEFAULT: OFF

      -U      Try to save memory by using SEV-based implementation for gap columns on large gappy alignments
              WARNING: this will only work for DNA under GTRGAMMA and is still in an experimental state.

      -v      Display version information

      -V      Disable rate heterogeneity among sites model and use one without rate heterogeneity instead.
              Only works if you specify the CAT model of rate heterogeneity.

              DEFAULT: use rate heterogeneity

      -w      FULL (!) path to the directory into which RAxML shall write its output files

              DEFAULT: current directory

      -W      Sliding window size for leave-one-out site-specific placement bias algorithm
              only effective when used in combination with "-f S" 

              DEFAULT: 100 sites

      -x      Specify an integer number (random seed) and turn on rapid bootstrapping
              CAUTION: unlike in version 7.0.4 RAxML will conduct rapid BS replicates under 
              the model of rate heterogeneity you specified via "-m" and not by default under CAT

      -X      EXPERIMENTAL OPTION: This option will do a per-site estimate of protein substitution models
              by looping over all given, fixed models LG, WAG, JTT, etc and using their respective base frequencies to independently
              assign a prot subst. model to each site via ML optimization
              At present this option only works with the GTR+GAMMA model, unpartitioned datasets, and in the sequential
              version only.

              DEFAULT: OFF

      -y      If you want to only compute a parsimony starting tree with RAxML specify "-y",
              the program will exit after computation of the starting tree

              DEFAULT: OFF

      -z      Specify the file name of a file containing multiple trees e.g. from a bootstrap
              that shall be used to draw bipartition values onto a tree provided with "-t",
              It can also be used to compute per site log likelihoods in combination with "-f g"
              and to read a bunch of trees for a couple of other options ("-f h", "-f m", "-f n").

      -#|-N   Specify the number of alternative runs on distinct starting trees
              In combination with the "-b" option, this will invoke a multiple boostrap analysis
              Note that "-N" has been added as an alternative since "-#" sometimes caused problems
              with certain MPI job submission systems, since "-#" is often used to start comments.
              If you want to use the bootstopping criteria specify "-# autoMR" or "-# autoMRE" or "-# autoMRE_IGN"
              for the majority-rule tree based criteria (see -I option) or "-# autoFC" for the frequency-based criterion.
              Bootstopping will only work in combination with "-x" or "-b"

              DEFAULT: 1 single analysis

	-->
	<!-- update to 7.4.4 involves no interface changes -->
	
	<parameters>
<!-- new logic for the command line delivery revised by mamiller, 1/21/2010, based on new logic from Wayne Pfeiffer:

For example, suppose -N nnn is specified with nnn < 20.  What I intended was the following.  Use one node with

. 8 Pthreads **only if** -x xxx -f a is specified & nchar >= 2,000 or . 2 MPI processes and 4 Pthreads in all other cases.

The other cases are

   -x xxx -f a with nchar < 2,000
   -x xxx -f d
   -b bbb -f d  or
   -f d.

There is a similar dichotomy between 8 and 4 Pthreads for larger values of nnn.

Upon reviewing my data more closely, I would like to change the nchar threshold to 2,000.  So here is the complete specification for nnn a number.

			the logic considers four cases: 
			1. the -f a -N nnn option is used, this selection implies -x  (hybridlogic1-3b); binning is based on nchar and boostop thresholds.
			2. whenever the -N option is used to specify a number of bootstraps or identical runs to conduct, where -f d is the analysis (hybridlogic5-7b)
				the logic change is to accomodate the fact that a best tree is not calculated, which is not efficient under mpi.
			3. the case where automatic bootstoppiong is used: a programmatic tools halts bootstrapping (hybridlogic8)
			4. all other analyses (-y, -f [other option] (hybridlogic8b)
			In the first two cases, the number of chars and the value of -N is considered, the logic is identical, but I spilt them into
			two groups because it made it easier for me, and presumably anyone who follows me. These run the hybrid code EXCEPT
			the first case in each allows for using the pthreads only. 
			In the third case, pthreads only code is used, and this is also true for the fourth case. 
The logic is constructed  in pairs of cases, based on thresholds. Each threshold case is accompanied by a scheduler element.  The precond for each logic scheduler element is necessarily identical to the mate that precedes it-->	
			
<!--	hybridlogic1  (revised 1/21/2010)
				For nnn < 20, use one node with
				8 Pthreads (no MPI) if and only if -xxx -f a is specified & nchar >= 2,000 (pthreads only)	or
				2 MPI processes and 4 Pthreads in all other cases, when  -x xxx -f a with nchar < 2,000,
 --> 
<!-- the first section considers only the cases where -f a is checked, and where bootstraps (=N, bootstop) 
	 are specified, these are binned as a matrix of bootstrap number -->		


<!--	hybridlogic2
				For nnn < 50, use 1 node on Comet with
				5 MPI processes & 6 Pthreads per process --> 
<!--mamiller revised the logic on 1/18/2011 to accomodate new rules for running on trestles per wayne recommendations

* Check whether the -N option is specified and, if so, what its value is.

* If -N is not specified,

   run the Pthreads-only version of RAxML on a single node of Abe with
8 threads.
   That is, use nodes=1:ppn=1 and -T 8.

* If -N nnn is specified with nnn < 50,

   run the hybrid parallel version of RAxML on a single node of Trestles using
   5 MPI processes and 6 threads per process.
   That is, use nodes=1:ppn=5, -np 5, and -T 6.

* If -N nnn is specified with nnn >= 50 or nnn = autoFC or nnn = autoMR or nnn = autoMRE or nnn = autoMRE_IGN,

   run the hybrid parallel version of RAxML on two nodes of Trestles using
   10 MPI processes and 6 threads per process.
   That is, use nodes=2:ppn=5, -np 10, and -T 6. -->
		
<!-- mamiller revised this version so we can accomodate larger data sets that need more memory -->
<!-- the design will be as follows:
	First prompt the user to ask if they have a big data set. This will avoid forcing all users to go through this process with no benefit
	
	Now, ask the user how many taxa and how many patterns/characters they have.
	Calculate the value of (ntax-2)*(nchar)*16*8 for dna and (ntax-2)*(nchar)*80*8 for protein.
	This will let us set the value of threads and processes correctly. The visible command is below, in the visible command section 
	-->
<!-- Rules for running RAxML via the CIPRES gateway
All runs are on Comet in the compute partition.

- If -N nnn is specified with nnn < 50,
  run the hybrid parallel version of RAxML on 24 cores of a single node using n MPI processes
  and t threads per process according to the following table.

    Memory per
  process (GB)    n    t

         <= 20    6    4
  > 20 & <= 30    4    6
  > 30 & <= 40    3    8
  > 40 & <= 60    2   12

  Thus include the following in the run script.

  #SBATCH -p compute
  #SBATCH -N 1
  #SBATCH -n 24
  #SBATCH (dash dash)ntasks-per-node=24
  ...
  module load raxml
  ibrun -np <n> raxmlHPC-HYBRID_8.2.9 -T <t> ...

- Check whether the -N option is specified and, if so, what its value is.

- Also, check whether more than 20 GB of memory per process is needed.
  If more than 60 GB of memory per process is needed, the user should contact us.
  

- If -N nnn is specified with nnn >= 50 or nnn = autoFC or nnn = autoMR or nnn =autoMRE
  or nnn = autoMRE_IGN,
  run the hybrid parallel version of RAxML on 48 cores of two nodes using n MPI processes
  and t threads per process according to the following table.

    Memory per
  process (GB)    n    t

         <= 20   12    4
  > 20 & <= 30    8    6
  > 30 & <= 40    6    8
  > 40 & <= 60    4   12

  #SBATCH -p compute
  #SBATCH -N 2
  #SBATCH -n 48
  #SBATCH (dash dash)ntasks-per-node=24
  ...
  module load raxml
  ibrun -np <n> raxmlHPC-HYBRID -T <t> ...
 -->
 
 <!-- WP patch to take raxml out of modules

2. I moved my executables for RAxML 8.2.9 to

  /projects/ps-ngbt/opt/comet/RAxML-8.2.9

If you are really keen to deploy this version of RAxML for use by CIPRES, you can do so by changing your scripts as follows:

2.1 For hybrid parallel jobs, replace

  module load raxml

by

  module unload mvapich2_ib
  module load openmpi_ib

and replace

  raxmlHPC-HYBRID

by

  /projects/ps-ngbt/opt/comet/RAxML-8.2.9/raxmlHPC-HYBRID

2.2 For threaded jobs, remove

  module load raxml

and replace

  raxmlHPC-PTHREADS

by

  /projects/ps-ngbt/opt/comet/RAxML-8.2.9/raxmlHPC-PTHREADS

* Let me know what you decide to do.
  -->
<!-- MOVE RAXML BACK TO GORDON -->
<!-- Rules for running RAxML via the CIPRES gateway

All runs are on Gordon.

- Check whether the -N option is specified and, if so, what its value is.

- Also, check how much memory per process is needed.
  If more than 30 GB of memory per process is needed, the user should contact us.

- If -N is not specified,
  run the Pthreads-only version of RAxML using 8 threads on 8 cores of a single node
  in the shared queue. Thus include the following in the run script.

  #PBS -q shared
  #PBS -v QOS=10
  #PBS -l nodes=1:ppn=8
  ...
  export MODULEPATH=/projects/ps-ngbt/opt/comet/modules:$MODULEPATH
  module load raxml/8.2.9
  raxmlHPC-PTHREADS -T 8 ...

- If -N nnn is specified with nnn < 50,
  run the hybrid parallel version of RAxML on 16 cores of a single node in the normal
  queue using n MPI processes and t threads per process according to the following table.

    Memory per
  process (GB)    n    t

         <= 15    4    4
  > 15 & <= 30    2    8

  Thus include the following in the run script.

  #PBS -q normal
  #PBS -l nodes=1:ppn=16
  ...
  export MODULEPATH=/projects/ps-ngbt/opt/comet/modules:$MODULEPATH
  module load raxml/8.2.9
  ibrun -np <n> raxmlHPC-HYBRID -T <t> ...

- If -N nnn is specified with nnn >= 50 or nnn = autoFC or nnn = autoMR or nnn =autoMRE
  or nnn = autoMRE_IGN,
  run the hybrid parallel version of RAxML on 48 cores of three nodes in the normal queue 
  using n MPI processes and t threads per process according to the following table.

    Memory per
  process (GB)    n    t

         <= 15   12    4
  > 15 & <= 30    6    8

  #PBS -q normal
  #PBS -l nodes=3:ppn=16
  ...
  export MODULEPATH=/projects/ps-ngbt/opt/comet/modules:$MODULEPATH
  module load raxml/8.2.9
  ibrun -np <n> raxmlHPC-HYBRID -T <t> ... -->
  
  <!-- MOVING JOBS BACK TO COMET for the foreseeable -->

<!--  Rules for running RAxML via the CIPRES gateway

All runs are on Comet.

- Check whether the -N option is specified and, if so, what its value is.

- Also, check how much memory per process is needed.
  If more than 60 GB of memory per process is needed, the user should contact us.

- Finally, check the specified time limit.

- If -N is not specified,
  run the Pthreads-only version of RAxML using 12 threads on 12 cores of a single node
  in the shared partition. Thus include the following in the run script.

  #SBATCH -p shared
  #SBATCH -N 1
  #SBATCH -*ntasks-per-node=12
  ...
  export MODULEPATH=/projects/ps-ngbt/opt/comet/modules:$MODULEPATH
  module load raxml/8.2.12
  raxmlHPC-PTHREADS -T 12 ...

- If -N nnn is specified with nnn < 50, or if the specified time limit is <= 2 hours,
  run the hybrid parallel version of RAxML on 24 cores of a single node in the compute
  partition using n MPI processes and t threads per process according to the following table.

    Memory per
  process (GB)    n    t

         <= 20    6    4
  > 20 & <= 30    4    6
  > 30 & <= 40    3    8
  > 40 & <= 60    2   12

  Thus include the following in the run script.

  #SBATCH -p compute
  #SBATCH -N 1
  #SBATCH -*ntasks-per-node=24
  ...
  export MODULEPATH=/projects/ps-ngbt/opt/comet/modules:$MODULEPATH
  module load raxml/8.2.12
  ibrun -np <n> raxmlHPC-HYBRID -T <t> ...

- If -N nnn is specified with nnn >= 50 or nnn = autoFC or nnn = autoMR or nnn =autoMRE
  or nnn = autoMRE_IGN, and if the specified time limit is > 2 hours,
  run the hybrid parallel version of RAxML on 48 cores of two nodes in the compute partition
  using n MPI processes and t threads per process according to the following table.

    Memory per
  process (GB)    n    t

         <= 20   12    4
  > 20 & <= 30    8    6
  > 30 & <= 40    6    8
  > 40 & <= 60    4   12

  #SBATCH -p compute
  #SBATCH -N 2
  #SBATCH -*ntasks-per-node=24
  ...
  export MODULEPATH=/projects/ps-ngbt/opt/comet/modules:$MODULEPATH
  module load raxml/8.2.12
  ibrun -np <n> raxmlHPC-HYBRID -T <t> ...

 -->
 <!-- moved to comet 3/15/2017 or thereabouts -->
  
	
<!-- Start -N < 50     Memory per <= 15    6    4, std run 
 --> 
 <!-- - If -N nnn is specified with nnn < 50, or if the specified time limit is <= 2 hours,
  run the hybrid parallel version of RAxML on 24 cores of a single node in the compute
  partition using n MPI processes and t threads per process according to the following table.

    Memory per
  process (GB)    n    t

         <= 20    6    4
  > 20 & <= 30    4    6
  > 30 & <= 40    3    8
  > 40 & <= 60    2   12

  Thus include the following in the run script.

  #SBATCH -p compute
  #SBATCH -N 1
  #SBATCH -*ntasks-per-node=24
  ...
  export MODULEPATH=/projects/ps-ngbt/opt/comet/modules:$MODULEPATH
  module load raxml/8.2.12
  ibrun -np <n> raxmlHPC-HYBRID -T <t> ... -->
 <!-- moved to comet 3/15/2017 or thereabouts -->

<!-- new rules 3/18/2018 --> 

<!-- Rules for running RAxML via the CIPRES gateway

All runs are on one or two standard nodes of Comet.

- Check whether the -N option is specified and, if so, what its value is.

- Also, check how much memory per process is needed.
  If more than 120 GB of memory per process is needed, the job cannot run.

- Finally, check the specified time limit.

- If -N is not specified,
  run the Pthreads-only version of RAxML using t threads on t cores of a single node
  in the partition listed in the following table.

  Memory per
  process (GB)    t  Partition

         <= 60   12    shared
  > 60 & <=120   24   compute

  Thus include following commands in the run script.

  #SBATCH -p <partition>
  #SBATCH -N 1
  #SBATCH -*ntasks-per-node=<t>
  ...
  export MODULEPATH=/projects/ps-ngbt/opt/comet/modules:$MODULEPATH
  module load raxml/8.2.12
  raxmlHPC-PTHREADS -T <t> ...

- If -N nnn is specified with nnn < 50, or if the specified time limit is <= 2 hours,
  run the hybrid parallel version of RAxML on 24 cores of a single node in the compute
  partition using n MPI processes and t threads per process according to the following table.

  Memory per
  process (GB)    n    t

         <= 20    6    4
  > 20 & <= 30    4    6
  > 30 & <= 40    3    8
  > 40 & <= 60    2   12
  > 60 & <=120    1   24

  Thus include the following in the run script.

  #SBATCH -p compute
  #SBATCH -N 1
  #SBATCH -*ntasks-per-node=24
  ...
  export MODULEPATH=/projects/ps-ngbt/opt/comet/modules:$MODULEPATH
  module load raxml/8.2.12
  srun -u -N 1 -n <n> -*cpus-per-task=<t> -*mpi=pmi2 raxmlHPC-HYBRID -T <t> ...

- If -N nnn is specified with nnn >= 50 or nnn = autoFC or nnn = autoMR or nnn =autoMRE
  or nnn = autoMRE_IGN, and if the specified time limit is > 2 hours,
  run the hybrid parallel version of RAxML on 48 cores of two nodes in the compute partition
  using n MPI processes and t threads per process according to the following table.

  Memory per
  process (GB)    n    t

         <= 20   12    4
  > 20 & <= 30    8    6
  > 30 & <= 40    6    8
  > 40 & <= 60    4   12
  > 60 & <=120    2   24

  #SBATCH -p compute
  #SBATCH -N 2
  #SBATCH -*ntasks-per-node=24
  ...
  export MODULEPATH=/projects/ps-ngbt/opt/comet/modules:$MODULEPATH
  module load raxml/8.2.12
  srun -u -N 2 -n <n> -*cpus-per-task=<t> -*mpi=pmi2 raxmlHPC-HYBRID -T <t> -->
  
					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic2</name>
						<attributes>
							<format>
								<language>perl</language>
								<code>"raxmlHPC-HYBRID_8.2.12_centos7<!-- -T 4 -->"</code>
							</format>
							<precond>
								<language>perl</language>
								<code>$specify_bootstraps &amp;&amp; $bootstop &lt; 50 &amp;&amp; !$more_memory</code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter>	
					
					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic2_scheduler</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<format>
								<language>perl</language>
								<code>
								<!-- RUN THESE JOBS ON Comet -->
									"jobtype=mpi\\n" .
									"mpi_processes=6\\n" .
									"threads_per_process=4\\n" .
									"node_exclusive=1\\n" .
									"nodes=1\\n"
								</code>
							</format>
							<precond>
								<!-- -N (bootstop) less than 50 --> 
								<language>perl</language>
								<code>$specify_bootstraps &amp;&amp; $bootstop &lt; 50 &amp;&amp; !$more_memory</code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter>	
<!-- Stop -N < 50 --> 	
<!-- Start $specify runs  --> 
					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic2b</name>
						<attributes>
							<format>
								<language>perl</language>
								<code>"raxmlHPC-HYBRID_8.2.12_centos7 <!-- -T 4 -->"</code>
							</format>
							<precond>
								<language>perl</language>
								<code>$specify_runs &amp;&amp; $altrun_number &lt; 50 &amp;&amp; !$more_memory</code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter>	
					
					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic2b_scheduler</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<precond>
								<!-- -N (bootstop) less than 50 --> 
								<language>perl</language>
								<code>$specify_runs &amp;&amp;  $altrun_number &lt; 50 &amp;&amp; !$more_memory</code>
							</precond>
							<format>
								<language>perl</language>
								<code>
								<!-- RUN THESE JOBS ON Comet -->
									"jobtype=mpi\\n" .
									"mpi_processes=6\\n" .
									"threads_per_process=4\\n" .
									"node_exclusive=1\\n" .
									"nodes=1\\n"
								</code>
							</format>
							<group>0</group>
						</attributes>
					</parameter>	
<!-- Stop $specify runs --> 	
					
<!-- - If -N nnn is specified with nnn >= 50 or nnn = autoFC or nnn = autoMR or nnn =autoMRE
  or nnn = autoMRE_IGN, and if the specified time limit is > 2 hours,
  run the hybrid parallel version of RAxML on 48 cores of two nodes in the compute partition
  using n MPI processes and t threads per process according to the following table.

    Memory per
  process (GB)    n    t

         <= 20   12    4
  > 20 & <= 30    8    6
  > 30 & <= 40    6    8
  > 40 & <= 60    4   12
 -->

<!-- Start  -N  >= 50; runtime greater than 2 -->	
					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic3</name>
						<attributes>
							<format>
								<language>perl</language>
								<code>"raxmlHPC-HYBRID_8.2.12_centos7 <!-- -T 4 -->"</code>
							</format>
							<precond>
								<!-- must be -N (bootstop >= 50 --> 
								<language>perl</language>
								<code>$specify_bootstraps  &amp;&amp; $runtime &gt; 2  &amp;&amp; $bootstop &gt;= 50 &amp;&amp; !$more_memory</code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter>
					
					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic3_scheduler</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<format>
								<language>perl</language>
								<code>
									"jobtype=mpi\\n" .
									"mpi_processes=12\\n" .
									"threads_per_process=4\\n" .
									"node_exclusive=1\\n" .
									"nodes=2\\n"
								</code>
							</format>
							<precond>
								<!-- must be -f a AND -N (bootstop), and -N >= 50 --> 
								<language>perl</language>
								<code>$specify_bootstraps  &amp;&amp; $runtime &gt; 2  &amp;&amp; $bootstop &gt;= 50 &amp;&amp; !$more_memory</code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter>
					
<!-- special case for short runs -->					
					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic3s</name>
						<attributes>
							<format>
								<language>perl</language>
								<code>"raxmlHPC-HYBRID_8.2.12_centos7 <!-- -T 4 -->"</code>
							</format>
							<precond>
								<!-- must be -N (bootstop >= 50 --> 
								<language>perl</language>
								<code>$specify_bootstraps  &amp;&amp; $runtime &lt;= 2 &amp;&amp; $bootstop &gt;= 50 &amp;&amp; !$more_memory</code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter>
					
					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic3s_scheduler</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<format>
								<language>perl</language>
								<code>
									"jobtype=mpi\\n" .
									"mpi_processes=6\\n" .
									"threads_per_process=4\\n" .
									"node_exclusive=1\\n" .
									"nodes=1\\n"
								</code>
							</format>
							<precond>
								<!-- must be -f a AND -N (bootstop), and -N >= 50 --> 
								<language>perl</language>
								<code>$specify_bootstraps &amp;&amp; $runtime &lt;= 2 &amp;&amp; $bootstop &gt;= 50 &amp;&amp; !$more_memory</code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter>
<!-- Stop  -N  >= 50 -->	
<!-- Start $specify runs  wen N > 50 --> 
					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic4</name>
						<attributes>
							<format>
								<language>perl</language>
								<code>"raxmlHPC-HYBRID_8.2.12_centos7 <!-- -T 4 -->"</code>
							</format>
							<precond>
								<language>perl</language>
								<code>$specify_runs &amp;&amp; $runtime &gt; 2 &amp;&amp;  $altrun_number &gt;= 50 &amp;&amp; !$more_memory</code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter>	
					
					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic4_scheduler</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<format>
								<language>perl</language>
								<code>
								<!-- RUN THESE JOBS ON Comet -->
									"jobtype=mpi\\n" .
									"mpi_processes=12\\n" .
									"threads_per_process=4\\n" .
									"node_exclusive=1\\n" .
									"nodes=2\\n"
								</code>
							</format>
							<precond>
								<!-- -N (bootstop) less than 50 --> 
								<language>perl</language>
								<code>$specify_runs &amp;&amp; $runtime &gt; 2 &amp;&amp;  $altrun_number &gt;= 50 &amp;&amp; !$more_memory</code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter>
					
<!-- special case for short runs -->					
					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic4s</name>
						<attributes>
							<format>
								<language>perl</language>
								<code>"raxmlHPC-HYBRID_8.2.12_centos7 <!-- -T 4 -->"</code>
							</format>
							<precond>
								<language>perl</language>
								<code>$specify_runs &amp;&amp; $runtime &lt;= 2 &amp;&amp; $altrun_number &gt;= 50 &amp;&amp; !$more_memory</code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter>	
					
					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic4s_scheduler</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<format>
								<language>perl</language>
								<code>
								<!-- RUN THESE JOBS ON Comet -->
									"jobtype=mpi\\n" .
									"mpi_processes=6\\n" .
									"threads_per_process=4\\n" .
									"node_exclusive=1\\n" .
									"nodes=1\\n"
								</code>
							</format>
							<precond>
								<!-- -N (bootstop) less than 50 --> 
								<language>perl</language>
								<code>$specify_runs &amp;&amp; $runtime &lt;= 2 &amp;&amp;  $altrun_number &gt;= 50 &amp;&amp; !$more_memory</code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter>				
					
<!--	hybridlogic11 
- If -N nnn is specified with nnn >= 50 or nnn = autoFC or nnn = autoMR or nnn =autoMRE
  or nnn = autoMRE_IGN,
  run the hybrid parallel version of RAxML on 48 cores of two nodes using n MPI processes
  and t threads per process according to the following table.

    Memory per
  process (GB)    n    t

         <= 20   12    4
 --> 
					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic11</name>
						<attributes>
							<format>
								<language>perl</language>
								<code>"raxmlHPC-HYBRID_8.2.12_centos7 <!-- -T 6 -->"</code>
							</format>
							<precond>
								<!-- must use bootstopping of any kind --> 
								<language>perl</language>
								<code>$use_bootstopping &amp;&amp; $runtime &gt; 2 &amp;&amp; !$more_memory</code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter>
		
					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic11_scheduler</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<format>
								<language>perl</language>
								<code>
								<!-- these jobs are run on Comet -->
									"jobtype=mpi\\n" .
									"mpi_processes=12\\n" .
									"threads_per_process=4\\n" .
									"node_exclusive=1\\n" .
									"nodes=2\\n"
								</code>
							</format>
							<precond>
								<!-- must use bootstopping of any kind --> 
								<language>perl</language>
								<code>$use_bootstopping &amp;&amp; $runtime &gt; 2 &amp;&amp; !$more_memory</code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter>
					
<!-- special case for short runs -->					
					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic11s</name>
						<attributes>
							<format>
								<language>perl</language>
								<code>"raxmlHPC-HYBRID_8.2.12_centos7 <!-- -T 6 -->"</code>
							</format>
							<precond>
								<!-- must use bootstopping of any kind --> 
								<language>perl</language>
								<code>$use_bootstopping &amp;&amp; $runtime &lt;= 2  &amp;&amp; !$more_memory</code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter>
		
					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic11s_scheduler</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<format>
								<language>perl</language>
								<code>
								<!-- these jobs are run on Comet -->
									"jobtype=mpi\\n" .
									"mpi_processes=6\\n" .
									"threads_per_process=4\\n" .
									"node_exclusive=1\\n" .
									"nodes=1\\n"
								</code>
							</format>
							<precond>
								<!-- must use bootstopping of any kind --> 
								<language>perl</language>
								<code>$use_bootstopping &amp;&amp; $runtime &lt;= 2  &amp;&amp; !$more_memory</code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter>
		
<!--	hybridlogic13
				For all options where -N is not used (not -f d -x (bootstrap_seed) or -b (mulparambootstrap_seed xxx -N  nnn; 
				and not -f d -N nnn (specify_runs) to be run on Comet in the shared queue, use pthreads version, 8 Pthreads in one node. 
				- If -N is not specified, run the Pthreads-only version of RAxML using 12 threads on 12 cores of a single node in the shared partition. Thus include the following in the run script.

  #SBATCH -p shared
  #SBATCH -N 1
  #SBATCH -*ntasks-per-node=12
  ...
  export MODULEPATH=/projects/ps-ngbt/opt/comet/modules:$MODULEPATH
  module load raxml/8.2.12
  raxmlHPC-PTHREADS -T 12 ...-->
<!-- RUN THESE JOBS ON Gordon in the shared queue --> 
					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic13</name>
						<attributes>
							<format>
								<language>perl</language>
								<code>"raxmlHPC-PTHREADS_8.2.12_centos7 <!-- -T 12 -->"</code>
							</format>
							<precond>
								<!-- deliver this line for any option that does not involve -f a or -f d -->
								<language>perl</language>
								<code>!$mulparambootstrap_seed &amp;&amp; !$bootstrap_seed &amp;&amp; !$specify_runs &amp;&amp; !$more_memory</code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter>
		
<!-- add a statement to run job on Gordon in the shared queue-->		
					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic13b_scheduler</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<format>
								<language>perl</language>
								<code>
								<!-- these jobs are run on Gordon -->
									"threads_per_process=12\\n" .
									"node_exclusive=0\\n" .
									"nodes=1\\n"
								</code>
							</format>
							<precond>
								<!-- must be -f d -x or -b AND use_bootstopping --> 
								<language>perl</language>
								<code>!$mulparambootstrap_seed &amp;&amp; !$bootstrap_seed &amp;&amp; !$specify_runs &amp;&amp; !$more_memory</code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter>
					
<!-- Large memory request configuration, specified by Wayne Pfeiffer  -->
		
			
<!-- large memory request for DNA case 1; 
 - If -N nnn is specified with nnn >= 50 or nnn = autoFC or nnn = autoMR or nnn =autoMRE
  or nnn = autoMRE_IGN, and if the specified time limit is > 2 hours,
  run the hybrid parallel version of RAxML on 48 cores of two nodes in the compute partition
  using n MPI processes and t threads per process according to the following table.

    Memory per
  process (GB)    n    t

         <= 20   12    4
  > 20 & <= 30    8    6
  > 30 & <= 40    6    8
  > 40 & <= 60    4   12

  #SBATCH -p compute
  #SBATCH -N 2
  #SBATCH -*ntasks-per-node=24
  ...
  export MODULEPATH=/projects/ps-ngbt/opt/comet/modules:$MODULEPATH
  module load raxml/8.2.12
  ibrun -np <n> raxmlHPC-HYBRID -T <t> ... -->
<!-- RUN THESE JOBS ON Comet on two nodes in the regular queue --> 
					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic22</name>
						<attributes>
							<format>
								<language>perl</language>
								<code>"raxmlHPC-HYBRID_8.2.12_centos7 <!-- -T 6 -->"</code>
							</format>
							<precond>
<!-- must request more memory, and have the correct memory requirement --> 
								<language>perl</language>
								<code>$runtime &gt; 2  &amp;&amp; $more_memory &amp;&amp; $datatype eq "dna" &amp;&amp;(($ntax - 2)*($nchar)*8*16) &gt; 20*(1024*1024*1024) &amp;&amp; (($ntax - 2)*($nchar)*8*16) &lt; 30*(1024*1024*1024) </code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter>
		
<!-- add a statement to run job on Comet on two nodes in the regular queue mpi=8 threads=6-->		
					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic22_scheduler</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<format>
								<language>perl</language>
								<code>
								<!-- these jobs are run on Comet -->
									"jobtype=mpi\\n" .
									"mpi_processes=8\\n" .
									"threads_per_process=6\\n" .
									"node_exclusive=1\\n" .
									"nodes=2\\n"
								</code>
							</format>
							<precond>
								<!-- must request more memory, and have the correct memory requirement --> 
								<language>perl</language>
								<code>$runtime &gt; 2  &amp;&amp; $more_memory &amp;&amp; $datatype eq "dna" &amp;&amp;(($ntax - 2)*($nchar)*8*16) &gt; 20*(1024*1024*1024) &amp;&amp; (($ntax - 2)*($nchar)*8*16) &lt; 30*(1024*1024*1024) </code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter>
		
<!-- large memory request for DNA case 2;
  > 30 & <= 40    6    8 -->
<!-- RUN THESE JOBS ON Comet on two nodes in the regular queue --> 
  					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic23</name>
						<attributes>
							<format>
								<language>perl</language>
								<code>"raxmlHPC-HYBRID_8.2.12_centos7"</code>
							</format>
							<precond>
								<language>perl</language>
								<code>$runtime &gt; 2  &amp;&amp; $more_memory &amp;&amp; $datatype eq "dna" &amp;&amp;(($ntax - 2)*($nchar)*8*16) &gt; 30*(1024*1024*1024) &amp;&amp; (($ntax - 2)*($nchar)*8*16) &lt; 40*(1024*1024*1024) </code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter> 
		
<!-- add a statement to run job on Comet on two nodes in the regular queue mpi=6 threads=8-->		
					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic23_scheduler</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<format>
								<language>perl</language>
								<code>
									"jobtype=mpi\\n" .
									"mpi_processes=6\\n" .
									"threads_per_process=8\\n" .
									"node_exclusive=1\\n" .
									"nodes=2\\n"
								</code>
							</format>
							<precond>
								<language>perl</language>
								<code>$runtime &gt; 2  &amp;&amp; $more_memory &amp;&amp; $datatype eq "dna" &amp;&amp;(($ntax - 2)*($nchar)*8*16) &gt; 30*(1024*1024*1024) &amp;&amp; (($ntax - 2)*($nchar)*8*16) &lt; 40*(1024*1024*1024) </code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter>
		
<!-- large memory request for DNA case 3;  > 40 & <= 60    4   12-->
<!-- RUN THESE JOBS ON Comet on two nodes in the regular queue --> 
 					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic24</name>
						<attributes>
							<format>
								<language>perl</language>
								<code>"raxmlHPC-HYBRID_8.2.12_centos7"</code>
							</format>
							<precond>
								<language>perl</language>
								<code>$runtime &gt; 2  &amp;&amp; $more_memory &amp;&amp; $datatype eq "dna" &amp;&amp;(($ntax - 2)*($nchar)*8*16) &gt; 40*(1024*1024*1024) &amp;&amp; (($ntax - 2)*($nchar)*8*16) &lt; 60*(1024*1024*1024) </code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter>  
		
<!-- add a statement to run job on Comet on two nodes in the regular queue mpi=4 threads=12-->		
				<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic24_scheduler</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<format>
								<language>perl</language>
								<code>
									"jobtype=mpi\\n" .
									"mpi_processes=4\\n" .
									"threads_per_process=12\\n" .
									"node_exclusive=1\\n" .
									"nodes=2\\n"
								</code>
							</format>
							<precond>
								<language>perl</language>
								<code>$runtime &gt; 2  &amp;&amp; $more_memory &amp;&amp; $datatype eq "dna" &amp;&amp;(($ntax - 2)*($nchar)*8*16) &gt; 40*(1024*1024*1024) &amp;&amp; (($ntax - 2)*($nchar)*8*16) &lt; 60*(1024*1024*1024) </code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter> 
					
<!-- large memory request for DNA case 3;  > 60 & <= 120    2   24-->
<!-- RUN THESE JOBS ON Comet on two nodes in the regular queue --> 
 					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic25</name>
						<attributes>
							<format>
								<language>perl</language>
								<code>"raxmlHPC-HYBRID_8.2.12_centos7"</code>
							</format>
							<precond>
								<language>perl</language>
								<code>$runtime &gt; 2  &amp;&amp; $more_memory &amp;&amp; $datatype eq "dna" &amp;&amp;(($ntax - 2)*($nchar)*8*16) &gt; 60*(1024*1024*1024) &amp;&amp; (($ntax - 2)*($nchar)*8*16) &lt; 120*(1024*1024*1024) </code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter>  
		
<!-- add a statement to run job on Comet on two nodes in the regular queue mpi=4 threads=12-->		
				<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic25_scheduler</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<format>
								<language>perl</language>
								<code>
									"jobtype=mpi\\n" .
									"mpi_processes=2\\n" .
									"threads_per_process=24\\n" .
									"node_exclusive=1\\n" .
									"nodes=2\\n"
								</code>
							</format>
							<precond>
								<language>perl</language>
								<code>$runtime &gt; 2  &amp;&amp; $more_memory &amp;&amp; $datatype eq "dna" &amp;&amp;(($ntax - 2)*($nchar)*8*16) &gt; 60*(1024*1024*1024) &amp;&amp; (($ntax - 2)*($nchar)*8*16) &lt; 120*(1024*1024*1024) </code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter> 
					
<!-- large memory DNA short run time -->
<!-- RUN THESE JOBS ON Comet on two nodes in the regular queue --> 
					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic22s</name>
						<attributes>
							<format>
								<language>perl</language>
								<code>"raxmlHPC-HYBRID_8.2.12_centos7 <!-- -T 6 -->"</code>
							</format>
							<precond>
<!-- must request more memory, and have the correct memory requirement --> 
								<language>perl</language>
								<code>$runtime &lt;= 2  &amp;&amp; $more_memory &amp;&amp; $datatype eq "dna" &amp;&amp;(($ntax - 2)*($nchar)*8*16) &gt; 20*(1024*1024*1024) &amp;&amp; (($ntax - 2)*($nchar)*8*16) &lt; 30*(1024*1024*1024) </code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter>
		
<!-- add a statement to run job on Comet on two nodes in the regular queue mpi=8 threads=6-->		
					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic22_scheduler_s</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<format>
								<language>perl</language>
								<code>
								<!-- these jobs are run on Comet -->
									"jobtype=mpi\\n" .
									"mpi_processes=4\\n" .
									"threads_per_process=6\\n" .
									"node_exclusive=1\\n" .
									"nodes=1\\n"
								</code>
							</format>
							<precond>
								<!-- must request more memory, and have the correct memory requirement --> 
								<language>perl</language>
								<code>$runtime &lt;= 2  &amp;&amp; $more_memory &amp;&amp; $datatype eq "dna" &amp;&amp;(($ntax - 2)*($nchar)*8*16) &gt; 20*(1024*1024*1024) &amp;&amp; (($ntax - 2)*($nchar)*8*16) &lt; 30*(1024*1024*1024) </code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter>
		
<!-- large memory request for DNA case 2;
  > 30 & <= 40    6    8 -->
<!-- RUN THESE JOBS ON Comet on two nodes in the regular queue --> 
  					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic23s</name>
						<attributes>
							<format>
								<language>perl</language>
								<code>"raxmlHPC-HYBRID_8.2.12_centos7"</code>
							</format>
							<precond>
								<language>perl</language>
								<code>$runtime &lt;= 2  &amp;&amp; $more_memory &amp;&amp; $datatype eq "dna" &amp;&amp;(($ntax - 2)*($nchar)*8*16) &gt; 30*(1024*1024*1024) &amp;&amp; (($ntax - 2)*($nchar)*8*16) &lt; 40*(1024*1024*1024) </code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter> 
		
<!-- add a statement to run job on Comet on two nodes in the regular queue mpi=6 threads=8-->		
					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic23_scheduler_s</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<format>
								<language>perl</language>
								<code>
									"jobtype=mpi\\n" .
									"mpi_processes=3\\n" .
									"threads_per_process=8\\n" .
									"node_exclusive=1\\n" .
									"nodes=1\\n"
								</code>
							</format>
							<precond>
								<language>perl</language>
								<code>$runtime &lt;= 2  &amp;&amp; $more_memory &amp;&amp; $datatype eq "dna" &amp;&amp;(($ntax - 2)*($nchar)*8*16) &gt; 30*(1024*1024*1024) &amp;&amp; (($ntax - 2)*($nchar)*8*16) &lt; 40*(1024*1024*1024) </code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter>
		
<!-- large memory request for DNA case 3;  > 40 & <= 60    4   12-->
<!-- RUN THESE JOBS ON Comet on two nodes in the regular queue --> 
 					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic24s</name>
						<attributes>
							<format>
								<language>perl</language>
								<code>"raxmlHPC-HYBRID_8.2.12_centos7"</code>
							</format>
							<precond>
								<language>perl</language>
								<code>$runtime &lt;= 2  &amp;&amp; $more_memory &amp;&amp; $datatype eq "dna" &amp;&amp;(($ntax - 2)*($nchar)*8*16) &gt; 40*(1024*1024*1024) &amp;&amp; (($ntax - 2)*($nchar)*8*16) &lt; 60*(1024*1024*1024) </code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter>  
		
<!-- add a statement to run job on Comet on two nodes in the regular queue mpi=4 threads=12-->		
				<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic24_scheduler_s</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<format>
								<language>perl</language>
								<code>
									"jobtype=mpi\\n" .
									"mpi_processes=2\\n" .
									"threads_per_process=12\\n" .
									"node_exclusive=1\\n" .
									"nodes=1\\n"
								</code>
							</format>
							<precond>
								<language>perl</language>
								<code>$runtime &lt;= 2  &amp;&amp; $more_memory &amp;&amp; $datatype eq "dna" &amp;&amp;(($ntax - 2)*($nchar)*8*16) &gt; 40*(1024*1024*1024) &amp;&amp; (($ntax - 2)*($nchar)*8*16) &lt; 60*(1024*1024*1024) </code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter> 
					
					<!-- large memory request for DNA case 3;  > 60 & <= 120    2   24-->
<!-- RUN THESE JOBS ON Comet on two nodes in the regular queue --> 
 					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic25s</name>
						<attributes>
							<format>
								<language>perl</language>
								<code>"raxmlHPC-HYBRID_8.2.12_centos7"</code>
							</format>
							<precond>
								<language>perl</language>
								<code>$runtime &lt;= 2  &amp;&amp; $more_memory &amp;&amp; $datatype eq "dna" &amp;&amp;(($ntax - 2)*($nchar)*8*16) &gt; 60*(1024*1024*1024) &amp;&amp; (($ntax - 2)*($nchar)*8*16) &lt; 120*(1024*1024*1024) </code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter>  
		
<!-- add a statement to run job on Comet on two nodes in the regular queue mpi=4 threads=12-->		
				<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic25_scheduler_s</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<format>
								<language>perl</language>
								<code>
									"jobtype=mpi\\n" .
									"mpi_processes=1\\n" .
									"threads_per_process=24\\n" .
									"node_exclusive=1\\n" .
									"nodes=1\\n"
								</code>
							</format>
							<precond>
								<language>perl</language>
								<code>$runtime &lt;= 2 &amp;&amp; $more_memory &amp;&amp; $datatype eq "dna" &amp;&amp;(($ntax - 2)*($nchar)*8*16) &gt; 60*(1024*1024*1024) &amp;&amp; (($ntax - 2)*($nchar)*8*16) &lt; 120*(1024*1024*1024) </code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter> 
		
<!-- large memory request for protein case 1   > 20 & <= 30    8    6 -->
<!-- RUN THESE JOBS ON Comet on two nodes in the regular queue --> 
					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic27</name>
						<attributes>
							<format>
								<language>perl</language>
								<code>"raxmlHPC-HYBRID_8.2.12_centos7 <!-- -T 6 -->"</code>
							</format>
							<precond>
<!-- must request more memory, and have the correct memory requirement --> 
								<language>perl</language>
								<code>$runtime  &gt; 2 &amp;&amp; $more_memory &amp;&amp; $datatype eq "protein" &amp;&amp; (($ntax - 2)*($nchar)*8*80) &gt; 20*(1024*1024*1024) &amp;&amp; (($ntax - 2)*($nchar)*8*80) &lt; 30*(1024*1024*1024) </code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter>
		
<!-- add a statement to run job on Comet on two nodes in the regular queue mpi=8 threads=6-->		
					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic27_scheduler</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<format>
								<language>perl</language>
								<code>
								<!-- these jobs are run on Comet -->
									"jobtype=mpi\\n" .
									"mpi_processes=8\\n" .
									"threads_per_process=6\\n" .
									"node_exclusive=1\\n" .
									"nodes=2\\n"
								</code>
							</format>
							<precond>
								<!-- must request more memory, and have the correct memory requirement 20-30 GB--> 
								<language>perl</language>
								<code>$runtime &gt; 2  &amp;&amp; $more_memory &amp;&amp; $datatype eq "protein" &amp;&amp; (($ntax - 2)*($nchar)*8*80) &gt; 20*(1024*1024*1024) &amp;&amp; (($ntax - 2)*($nchar)*8*80) &lt; 30*(1024*1024*1024) </code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter>

<!-- large memory request for protein case 2 -  Comet only
  > 30 & <= 40    6    8 -->
<!-- RUN THESE JOBS ON Comet on two nodes in the regular queue --> 
					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic28</name>
						<attributes>
							<format>
								<language>perl</language>
								<code>"raxmlHPC-HYBRID_8.2.12_centos7" </code>
							</format>
							<precond>
								<language>perl</language>
								<code>$runtime &gt; 2  &amp;&amp; $more_memory &amp;&amp; $datatype eq "protein" &amp;&amp; (($ntax - 2)*($nchar)*8*80) &gt; 30*(1024*1024*1024) &amp;&amp; (($ntax - 2)*($nchar)*8*80) &lt; 40*(1024*1024*1024) </code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter>  
		
<!-- add a statement to run job on Comet on two nodes in the regular queue mpi=6 threads=8-->		
  					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic28_scheduler</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<format>
								<language>perl</language>
								<code>
									"jobtype=mpi\\n" .
									"mpi_processes=6\\n" .
									"threads_per_process=8\\n" .
									"node_exclusive=1\\n" .
									"nodes=2\\n"
								</code>
							</format>
							<precond>
								<language>perl</language>
								<code>$runtime &gt; 2  &amp;&amp; $more_memory &amp;&amp; $datatype eq "protein" &amp;&amp; (($ntax - 2)*($nchar)*8*80) &gt; 30*(1024*1024*1024) &amp;&amp; (($ntax - 2)*($nchar)*8*80) &lt; 40*(1024*1024*1024) </code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter> 

<!-- large memory request for protein case 3 - 
  > 40 & <= 60    4   12-->
<!-- RUN THESE JOBS ON Comet on two nodes in the regular queue --> 
				<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic29</name>
						<attributes>
							<format>
								<language>perl</language>
								<code>"raxmlHPC-HYBRID_8.2.12_centos7"</code>
							</format>
							<precond>
								<language>perl</language>
								<code>$runtime &gt; 2  &amp;&amp; $more_memory &amp;&amp; $datatype eq "protein" &amp;&amp; (($ntax - 2)*($nchar)*8*80) &gt; 40*(1024*1024*1024) &amp;&amp; (($ntax - 2)*($nchar)*8*80) &lt; 60*(1024*1024*1024) </code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter>   
		
<!-- add a statement to run job on Comet on two nodes in the regular queue mpi=4 threads=12-->		
 					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic29_scheduler</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<format>
								<language>perl</language>
								<code>
									"jobtype=mpi\\n" .
									"mpi_processes=4\\n" .
									"threads_per_process=12\\n" .
									"node_exclusive=1\\n" .
									"nodes=2\\n"
								</code>
							</format>
							<precond> 
								<language>perl</language>
								<code>$runtime &gt; 2  &amp;&amp; $more_memory &amp;&amp; $datatype eq "protein" &amp;&amp; (($ntax - 2)*($nchar)*8*80) &gt; 40*(1024*1024*1024) &amp;&amp; (($ntax - 2)*($nchar)*8*80) &lt; 60*(1024*1024*1024) </code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter>
					
<!-- large memory request for protein case 3 - 
  > 60 & <= 120    2   24-->
<!-- RUN THESE JOBS ON Comet on two nodes in the regular queue --> 
				<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic30</name>
						<attributes>
							<format>
								<language>perl</language>
								<code>"raxmlHPC-HYBRID_8.2.12_centos7"</code>
							</format>
							<precond>
								<language>perl</language>
								<code>$runtime &gt; 2  &amp;&amp; $more_memory &amp;&amp; $datatype eq "protein" &amp;&amp; (($ntax - 2)*($nchar)*8*80) &gt; 60*(1024*1024*1024) &amp;&amp; (($ntax - 2)*($nchar)*8*80) &lt; 120*(1024*1024*1024) </code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter>   
		
<!-- add a statement to run job on Comet on two nodes in the regular queue mpi=4 threads=12-->		
 					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic30_scheduler</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<format>
								<language>perl</language>
								<code>
									"jobtype=mpi\\n" .
									"mpi_processes=2\\n" .
									"threads_per_process=24\\n" .
									"node_exclusive=1\\n" .
									"nodes=2\\n"
								</code>
							</format>
							<precond> 
								<language>perl</language>
								<code>$runtime &gt; 2  &amp;&amp; $more_memory &amp;&amp; $datatype eq "protein" &amp;&amp; (($ntax - 2)*($nchar)*8*80) &gt; 60*(1024*1024*1024) &amp;&amp; (($ntax - 2)*($nchar)*8*80) &lt; 120*(1024*1024*1024) </code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter>

<!-- protein cases for short runs  -->
<!-- RUN THESE JOBS ON Comet on two nodes in the regular queue --> 
					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic27s</name>
						<attributes>
							<format>
								<language>perl</language>
								<code>"raxmlHPC-HYBRID_8.2.12_centos7 <!-- -T 6 -->"</code>
							</format>
							<precond>
<!-- must request more memory, and have the correct memory requirement --> 
								<language>perl</language>
								<code>$runtime &lt;= 2  &amp;&amp; $more_memory &amp;&amp; $datatype eq "protein" &amp;&amp; (($ntax - 2)*($nchar)*8*80) &gt; 20*(1024*1024*1024) &amp;&amp; (($ntax - 2)*($nchar)*8*80) &lt; 30*(1024*1024*1024) </code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter>
		
<!-- add a statement to run job on Comet on two nodes in the regular queue mpi=8 threads=6-->		
					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic27_scheduler_s</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<format>
								<language>perl</language>
								<code>
								<!-- these jobs are run on Comet -->
									"jobtype=mpi\\n" .
									"mpi_processes=4\\n" .
									"threads_per_process=6\\n" .
									"node_exclusive=1\\n" .
									"nodes=1\\n"
								</code>
							</format>
							<precond>
								<!-- must request more memory, and have the correct memory requirement 20-30 GB--> 
								<language>perl</language>
								<code>$runtime &lt;= 2  &amp;&amp; $more_memory &amp;&amp; $datatype eq "protein" &amp;&amp; (($ntax - 2)*($nchar)*8*80) &gt; 20*(1024*1024*1024) &amp;&amp; (($ntax - 2)*($nchar)*8*80) &lt; 30*(1024*1024*1024) </code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter>

<!-- large memory request for protein case 2 -  Comet only
  > 30 & <= 40    6    8 -->
<!-- RUN THESE JOBS ON Comet on two nodes in the regular queue --> 
					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic28s</name>
						<attributes>
							<format>
								<language>perl</language>
								<code>"raxmlHPC-HYBRID_8.2.12_centos7" </code>
							</format>
							<precond>
								<language>perl</language>
								<code>$runtime &lt;= 2  &amp;&amp; $more_memory &amp;&amp; $datatype eq "protein" &amp;&amp; (($ntax - 2)*($nchar)*8*80) &gt; 30*(1024*1024*1024) &amp;&amp; (($ntax - 2)*($nchar)*8*80) &lt; 40*(1024*1024*1024) </code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter>  
		
<!-- add a statement to run job on Comet on two nodes in the regular queue mpi=6 threads=8-->		
  					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic28_scheduler_s</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<format>
								<language>perl</language>
								<code>
									"jobtype=mpi\\n" .
									"mpi_processes=3\\n" .
									"threads_per_process=8\\n" .
									"node_exclusive=1\\n" .
									"nodes=1\\n"
								</code>
							</format>
							<precond>
								<language>perl</language>
								<code>$runtime &lt;= 2  &amp;&amp; $more_memory &amp;&amp; $datatype eq "protein" &amp;&amp; (($ntax - 2)*($nchar)*8*80) &gt; 30*(1024*1024*1024) &amp;&amp; (($ntax - 2)*($nchar)*8*80) &lt; 40*(1024*1024*1024) </code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter> 

<!-- large memory request for protein case 3 - 
  > 40 & <= 60    4   12-->
<!-- RUN THESE JOBS ON Comet on two nodes in the regular queue --> 
				<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic29s</name>
						<attributes>
							<format>
								<language>perl</language>
								<code>"raxmlHPC-HYBRID_8.2.12_centos7"</code>
							</format>
							<precond>
								<language>perl</language>
								<code>$runtime &lt;= 2  &amp;&amp; $more_memory &amp;&amp; $datatype eq "protein" &amp;&amp; (($ntax - 2)*($nchar)*8*80) &gt; 40*(1024*1024*1024) &amp;&amp; (($ntax - 2)*($nchar)*8*80) &lt; 60*(1024*1024*1024) </code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter>   
		
<!-- add a statement to run job on Comet on two nodes in the regular queue mpi=4 threads=12-->		
 					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic29_scheduler_s</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<format>
								<language>perl</language>
								<code>
									"jobtype=mpi\\n" .
									"mpi_processes=2\\n" .
									"threads_per_process=12\\n" .
									"node_exclusive=1\\n" .
									"nodes=1\\n"
								</code>
							</format>
							<precond> 
								<language>perl</language>
								<code>$runtime &lt;= 2  &amp;&amp; $more_memory &amp;&amp; $datatype eq "protein" &amp;&amp; (($ntax - 2)*($nchar)*8*80) &gt; 40*(1024*1024*1024) &amp;&amp; (($ntax - 2)*($nchar)*8*80) &lt; 60*(1024*1024*1024) </code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter>
					
<!-- large memory request for protein case 3 - 
  > 60 & <= 120    2   24-->
<!-- RUN THESE JOBS ON Comet on two nodes in the regular queue --> 
				<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic30s</name>
						<attributes>
							<format>
								<language>perl</language>
								<code>"raxmlHPC-HYBRID_8.2.12_centos7"</code>
							</format>
							<precond>
								<language>perl</language>
								<code>$runtime &lt;= 2  &amp;&amp; $more_memory &amp;&amp; $datatype eq "protein" &amp;&amp; (($ntax - 2)*($nchar)*8*80) &gt; 60*(1024*1024*1024) &amp;&amp; (($ntax - 2)*($nchar)*8*80) &lt; 120*(1024*1024*1024) </code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter>   
		
<!-- add a statement to run job on Comet on two nodes in the regular queue mpi=4 threads=12-->		
 					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic30_scheduler_s</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<format>
								<language>perl</language>
								<code>
									"jobtype=mpi\\n" .
									"mpi_processes=1\\n" .
									"threads_per_process=24\\n" .
									"node_exclusive=1\\n" .
									"nodes=1\\n"
								</code>
							</format>
							<precond> 
								<language>perl</language>
								<code>$runtime &lt;= 2  &amp;&amp; $more_memory &amp;&amp; $datatype eq "protein" &amp;&amp; (($ntax - 2)*($nchar)*8*80) &gt; 60*(1024*1024*1024) &amp;&amp; (($ntax - 2)*($nchar)*8*80) &lt; 120*(1024*1024*1024) </code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter>
					
		
<!-- add a statement to run job on Comet on two nodes in the regular queue mpi=2 threads=32-->		
<!-- deprecated					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogic30_scheduler</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<format>
								<language>perl</language>
								<code> -->
								<!-- these jobs are run on Comet 
									"jobtype=mpi\\n" .
									"mpi_processes=2\\n" .
									"threads_per_process=32\\n" .
									"node_exclusive=1\\n" .
									"nodes=2\\n"
								</code>
							</format>-->
							<!--	<precond>
							 must request more memory, and have the correct memory requirement 
								<language>perl</language>
								<code>$more_memory &amp;&amp; $datatype eq "protein" &amp;&amp; (($ntax - 2)*($nchar)*8*80) &gt; 32*(1024*1024*1024)</code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter> --> 
							
<!-- required input file -->
					<parameter ismandatory="1" issimple="1" isinput="1" type="InFile">
						<name>infile</name>
						<attributes>
							<prompt>Sequences File (relaxed phylip format) (-s)</prompt>
							<group>1</group>
							<filenames>infile.txt</filenames>
						</attributes>
					</parameter>
		
<!-- required input file, when the -J option is not used -->
					<parameter ismandatory="1" ishidden="1" type="String">
						<name>infile_regular</name>
						<attributes>
							<prompt>Sequences File (relaxed phylip format) (-z)</prompt>
							<precond>
								<language>perl</language>
								<code>!$compute_mr</code>
							</precond>
							<format>
								<language>perl</language>
								<code>"-s infile.txt"</code>
							</format>
							<group>1</group>
						</attributes>
					</parameter>
		
<!-- required input file, only when the -J option is used -->
					<parameter ismandatory="1" ishidden="1" type="String">
						<name>infile_Joption</name>
						<attributes>
							<prompt>Tree file (-z)</prompt>
							<precond>
								<language>perl</language>
								<code>$compute_mr</code>
							</precond>
							<format>
								<language>perl</language>
								<code>" -z infile.txt"</code>
							</format>
							<group>1</group>
						</attributes>
					</parameter>
		
<!-- catchall to route std out to a log file -->
<!--	the logfile isnt used on teragrid, it is replaced with std out
		<parameter type="String" ishidden="1">
			<name>out_logifle</name>
			<attributes>
				<format>
					<language>perl</language>
					<code>" > output.txt"</code>
				</format>
				<group>99</group>
			</attributes>
		</parameter> -->
	
<!-- Parameters with visible controls start here -->
		<parameter type="Float" issimple="1" ismandatory="1">
			<name>runtime</name>
			<attributes>
				<group>1</group>
				<paramfile>scheduler.conf</paramfile>
				<prompt>Maximum Hours to Run (click here for help setting this correctly)</prompt>
				<vdef>
					<value>0.25</value>
				</vdef>
				<ctrls>
					<ctrl>
						<message>Maximum Hours to Run must be 168 or less</message>
						<language>perl</language>
						<code>$runtime &gt; 168</code>
					</ctrl>
					<ctrl>
						<message>Maximum Hours to Run must be greater than 0.1</message>
						<language>perl</language>
						<code>$runtime &lt; 0.1</code>
					</ctrl>
				</ctrls>
				<format>
					<language>perl</language>
					<code>"runhours=$value\\n"</code>
				</format>
<!-- added by mamiller to provide feedback on number of cpu hrs to be consumed -->
							<warns>
								<warn>
									<message>The job will run on 24 processors as configured. If it runs for the entire configured time, it will consume 24 x $runtime cpu hours</message>
									<language>perl</language>
									<code>$specify_bootstraps  &amp;&amp; $bootstop &lt; 50 </code>
								</warn>
								<warn>
									<message>The job will run on 24 processors as configured. If it runs for the entire configured time, it will consume 24 x $runtime cpu hours</message>
									<language>perl</language>
									<code>$specify_runs  &amp;&amp; $altrun_number &lt; 50 </code>
								</warn>
								<warn>
									<message>The job will run on 24 processors as configured. If it runs for the entire configured time, it will consume 24 x $runtime cpu hours</message>
									<language>perl</language>
									<code>$specify_runs &amp;&amp; $runtime &lt;= 2 &amp;&amp; $altrun_number &gt;= 50</code>
								</warn>
								<warn>
									<message>The job will run on 48 processors as configured. If it runs for the entire configured time, it will consume 48 x $runtime cpu hours</message>
									<language>perl</language>
									<code>$specify_runs &amp;&amp; $runtime &gt; 2 &amp;&amp; $altrun_number &gt;= 50 </code>
								</warn>
								<warn>
									<message>The job will run on 24 processors as configured. If it runs for the entire configured time, it will consume 24 x $runtime cpu hours</message>
									<language>perl</language>
									<code>$specify_bootstraps &amp;&amp; $runtime &lt;= 2 &amp;&amp; $bootstop &gt;= 50 &amp;&amp; !$ancestral_states &amp;&amp; !$fast_tree &amp;&amp; !$bipartitions &amp;&amp; !$startingtreeonly &amp;&amp; !$log_likelihood &amp;&amp; !$morpho_weight_calibration &amp;&amp; !$classify_into_reftree &amp;&amp; !$compute_mr</code>
								</warn>
								<warn>
									<message>The job will run on 48 processors as configured. If it runs for the entire configured time, it will consume 48 x $runtime cpu hours</message>
									<language>perl</language>
									<code>$specify_bootstraps &amp;&amp; $runtime &gt; 2  &amp;&amp; $bootstop &gt;= 50 &amp;&amp; !$ancestral_states &amp;&amp; !$fast_tree &amp;&amp; !$bipartitions &amp;&amp; !$startingtreeonly &amp;&amp; !$log_likelihood &amp;&amp; !$morpho_weight_calibration &amp;&amp; !$classify_into_reftree &amp;&amp; !$compute_mr</code>
								</warn>
								<warn>
									<message>The job will run on 24 processors as configured. If it runs for the entire configured time, it will consume 24 x $runtime cpu hours</message>
									<language>perl</language>
									<code>$use_bootstopping &amp;&amp; $runtime &lt;= 2</code>
								</warn>
								<warn>
									<message>The job will run on 48 processors as configured. If it runs for the entire configured time, it will consume 48 x $runtime cpu hours</message>
									<language>perl</language>
									<code>$use_bootstopping &amp;&amp; $runtime &gt; 2 </code>
								</warn>
								<warn>
									<message>The job will run on 12 processors as configured. If it runs for the entire configured time, it will consume 12 x $runtime cpu hours</message>
									<language>perl</language>
									<code>!$mulparambootstrap_seed &amp;&amp; !$bootstrap_seed &amp;&amp; !$specify_runs &amp;&amp; !$more_memory</code>
								</warn>
							</warns>
							<comment>
<value>Estimate the maximum time your job will need to run. We recommend testing initially with a time less than 0.5hr test run because Jobs set for 0.5 h or less depedendably run immediately in the "debug" queue. 
Once you are sure the configuration is correct, you then increase the time. The reason is that jobs &gt; 0.5 h are submitted to the "normal" queue, where jobs configured for 1 or a few hours times may
run sooner than jobs configured for the full 168 hours. 
</value>
							</comment>
			</attributes>
		</parameter>

<!-- use a text string with the -n argument to specify output file suffix; this is  is required -->
		<parameter type="String" issimple="1" >
			<name>outsuffix</name>
			<attributes>
				<prompt>Set a name for output files</prompt>
				<format>
					<language>perl</language>
					<code>"-n $value"</code>
				</format>
				<vdef>
					<value>result</value>
				</vdef> 
				<ctrls>
					<ctrl>
						<message>Please enter a name for the output files</message>
						<language>perl</language>
						<code>!defined $outsuffix</code>
					</ctrl>
				</ctrls>
				<group>1</group>
			</attributes>
		</parameter>
		
<!-- enable ML tree searches under CAT instead of GAMMA  -->
					<parameter type="Switch" issimple="1" >
						<name>MLsearch_CAT</name>
						<attributes>
							<prompt>Enable ML searches under CAT (-F)</prompt>
<!-- -F not allowed with bootstrapping -->
							<precond>
								<language>perl</language>
								<code>!$bootstrap_seed &amp;&amp; !$mulparambootstrap_seed &amp;&amp; !$mlsearch</code>
							</precond>
							<format>
								<language>perl</language>
								<code>($value)? " -F " : "" </code>
							</format>
							<vdef>
								<value>0</value>
							</vdef>
							<comment>
<value>This option allows one to enable tree searches under CAT for veyr large trees, as this saves memory. This option can also be used under GAMMA models
	to avoid thorough optimization of the best scoring ML tree at the end of the run.	 
								</value>
							</comment>
						</attributes>
					</parameter>	
		
<!-- user asks for the ability to configure for a large data set -->
					<parameter type="Switch" issimple="1" ismandatory="1">
						<name>more_memory</name>
						<attributes>
							<prompt>I have a data set that may require more than 20 GB of memory</prompt>
							<precond>
								<language>perl</language>
								<code>$datatype eq "dna" || $datatype eq "protein"</code>
							</precond>
							<vdef>
								<value>0</value>
							</vdef>
							<comment>
<value>To figure out if you need this option, use the RAxML memory calculator here: http://sco.h-its.org/exelixis/software.html.
Input the number of taxa, and patterns (or characters), and the gamma model(AA or DNA, as appropriate for your data). Multiply the value
you receive times 32. If that value is greater than 64 GB, then you should select this option. If you dont, the run will fail silently 
at the end due to an out of memory error.	 
								</value>
							</comment>
						</attributes>
					</parameter>		
		
<!-- user enters nchar parameter this will help decide how to run -->
		<parameter type="Integer" issimple="1">
			<name>nchar</name>
			<attributes>
				<prompt>Enter the number of patterns in your dataset</prompt>
				<precond>
					<language>perl</language>
					<code>$more_memory</code>
				</precond>
				<ctrls>
					<ctrl>
						<message>Please enter a value for the number of patterns in your data matrix</message>
						<language>perl</language>
						<code>!defined $nchar</code>
					</ctrl>
					<ctrl>
						<message>The number of patterns in the matrix must 1 or greater.</message>
						<language>perl</language>
						<code>$nchar &lt; 1</code>
					</ctrl>
				</ctrls>
				<group>15</group>
				<comment>
					<value>
						Knowing the number of characters in your dataset helps us determine the most efficient way to run raxml.
						We need to know the number of characters per row in the input data matrix.
					</value>
				</comment>
			</attributes>
		</parameter>
		
		<!-- user enters ntax parameter this will help decide how to run -->
		<parameter type="Integer" issimple="1">
			<name>ntax</name>
			<attributes>
				<prompt>Enter the number of taxa in your dataset</prompt>
				<precond>
					<language>perl</language>
					<code>$more_memory</code>
				</precond>
				<ctrls>
					<ctrl>
						<message>Please enter a value for the number of taxa in your data matrix</message>
						<language>perl</language>
						<code>!defined $ntax</code>
					</ctrl>
					<ctrl>
						<message>The number of taxa in the matrix must 1 or greater.</message>
						<language>perl</language>
						<code>$nchar &lt; 1</code>
					</ctrl>
					<ctrl>								
						<message>Your job does not require the large memory option, please uncheck the large memory box and run normally.</message>
						<language>perl</language>
						<code>$more_memory &amp;&amp; $datatype eq "dna" &amp;&amp;(($ntax - 2)*($nchar)*8*16) &lt; 20*(1024*1024*1024)</code>
						<!--   &gt; 12*(1024*1024*1024) &amp;&amp; (($ntax - 2)*($nchar)*8*16) &lt; 15*(1024*1024*1024) -->
					</ctrl>
					<ctrl>
						<message>Your job will probably not complete as configured, please contact us for help.</message>
						<language>perl</language>
						<code>$more_memory &amp;&amp; $datatype eq "dna" &amp;&amp; (($ntax-2)* ($nchar*8*16)) &gt; 120*(1024*1024*1024) </code>
					</ctrl>
					<ctrl>
						<message>Your job does not require the large memory option, please uncheck the large memory box and run normally.</message>
						<language>perl</language>
						<code>$more_memory &amp;&amp; $datatype eq "protein" &amp;&amp; (($ntax-2) * ($nchar*8*80)) &lt; 20*(1024*1024*1024)</code>
					</ctrl>
					<ctrl>
						<message>Your job will probably not complete as configured, please contact us for help.</message>
						<language>perl</language>
						<code>$more_memory &amp;&amp; $datatype eq "protein" &amp;&amp; (($ntax-2)* ($nchar*8*80)) &gt; 120*(1024*1024*1024)</code>
					</ctrl>
				</ctrls>
				<group>15</group>
				<comment>
					<value>
						Knowing the number of taxa and patterns in your dataset helps us determine the most efficient way to run raxml.
					</value>
				</comment>
			</attributes>
		</parameter>

<!-- is it protein or dna input ? -->
		
					<parameter type="Excl" issimple="1" ismandatory="1">
						<name>datatype</name>
						<attributes>
							<prompt>Please select the Data Type</prompt>
							<vlist>
								<value>protein</value>
								<label>Protein</label>
								<value>dna</value>
								<label>Nucleotide</label>
								<value>rna</value>
								<label>RNA Structure</label>
								<value>binary</value>
								<label>Binary Morphological</label>
								<value>multi</value>
								<label>Multi-State Morphological</label>
							</vlist>
							<vdef>
								<value>dna</value>
							</vdef>
							<group>2</group>
						</attributes>
					</parameter>
					
		<!-- outgroup (-o) -->
		<parameter type="String" issimple="1">
			<name>outgroup</name>
			<attributes>
				<prompt>Outgroup (one or more comma-separated outgroups, see comment for syntax)</prompt>
				<format>
					<language>perl</language>
					<code>(defined $value)? " -o $value " : "" </code>
				</format>
				<group>10</group>
				<comment>
<value>The correct syntax for the box is outgroup1,outgroup2,outgroupn. If white space is introduced (e.g. outgroup1, outgroup2, outgroupn) the program will fail with the message
"Error, you must specify a model of substitution with the '-m' option"
</value>					
				</comment>
			</attributes>
		</parameter>
		
		<!-- rev 2 -->
		<!--category (-c) -->
					<parameter type="Integer" issimple="1" ismandatory="1">
						<name>number_cats</name>
						<attributes>
							<prompt>Specify the number of distinct rate categories (-c)</prompt>
							<format>
								<language>perl</language>
								<code>(defined $value)? " -c $value" : "" </code>
							</format>
							<vdef>
								<value>25</value>
							</vdef>
							<group>2</group>
							<precond>
								<language>perl</language>
								<code>($datatype eq "dna" &amp;&amp; $dna_gtrcat eq "GTRCAT") || ($datatype eq "protein" &amp;&amp; $prot_sub_model eq "PROTCAT") || ($datatype eq "binary" &amp;&amp; $bin_model eq "BINCAT")</code>
							</precond>
							<comment>
					<value>This option allows you to specify the number of distinct rate categories, into which the individually optimized rates for each individual site are thrown under -m GTRCAT. The default of -c 25 works fine in most practical cases.
</value>
							</comment>
						</attributes>
					</parameter>
		
<!-- Disable rate heterogeneity (-V) -->
					<parameter type="Switch" issimple="1" ismandatory="1">
						<name>disable_ratehet</name>
						<attributes>
							<prompt>Disable Rate Heterogeneity  (-V)</prompt>
							<format>
								<language>perl</language>
								<code>($value)? " -V " : "" </code>
							</format>
							<vdef>
								<value>0</value>
							</vdef>
							<group>2</group>
							<precond>
								<language>perl</language>
								<code>($datatype eq "dna" &amp;&amp; $dna_gtrcat eq "GTRCAT") || ($datatype eq "protein" &amp;&amp; $prot_sub_model eq "PROTCAT") || ($datatype eq "binary" &amp;&amp; $bin_model eq "BINCAT")</code>
							</precond>
							<comment>
					<value>This option allows you to disable rate heterogeneity anong the sites. Valid for CAT model only.
</value>
							</comment>
						</attributes>
					</parameter>
		<!-- user supplied starting tree (-t) -->
		
					<parameter issimple="1" type="InFile">
						<name>treetop</name>
						<attributes>
							<prompt>Supply a tree (Not available when doing rapid bootstrapping, -x) (-t)</prompt>
							<precond>
								<language>perl</language>
								<code>!$bootstrap_seed</code>
							</precond>
							<format>
								<language>perl</language>
								<code>" -t tree.tre"</code>
							</format>
							<group>2</group>
							<filenames>tree.tre</filenames>
<!--							<ctrls>
								<ctrl>
									<message>Sorry, you can't specify a random seed AND supply a starting tree</message>
									<language>perl</language>
									<code>defined $value &amp;&amp; $provide_parsimony_seed</code>
								</ctrl>
							</ctrls> -->
							<comment>
<value>Specifies a user starting tree file in Newick format. Not available when doing rapid bootstrapping. Branch lengths of that tree will be ignored. Note that you can also specify a non-comprehensive (not containing all taxa in the alignment) starting tree now. This might be useful if newly aligned/sequenced taxa have been added to your alignment. Initially, taxa will be added to the tree using the MP criterion. The comprehensive tree will then be optimized
under ML.</value>
							</comment>
						</attributes>
					</parameter>

					<!--PARSIMONY SEED VALUE FOR CONSTANT STARTING TREE-->
					<!-- I split the seeds  into invocation, and number entry, due to command line conflicts -->
					<parameter type="Switch" issimple="1" ismandatory="1">
						<name>provide_parsimony_seed</name>
						<attributes>
							<prompt>Specify a random seed value for parsimony inferences (-p)</prompt>
							<vdef>
								<value>1</value>
							</vdef>
<!--  						<precond>
								<language>perl</language>
								<code>!defined $treetop</code>
							</precond> -->
							<ctrls>
								<ctrl>
									<message>Please provide a parsimony seed</message>
									<language>perl</language>
									<code>$specify_runs &amp;&amp; !defined $parsimony_seed_val</code>
								</ctrl>
								<ctrl>
									<message>Please provide a parsimony seed</message>
									<language>perl</language>
									<code>$startingtreeonly &amp;&amp; !defined $parsimony_seed_val</code>
								</ctrl>
<!--						    <ctrl>
									<message>Sorry, you cannot specify a starting tree (via the -t option above) and a random seed value</message>
									<language>perl</language>
									<code>defined $treetop</code>
								</ctrl> -->
							</ctrls> 
							<comment>
								<value>Specify a random number seed. The -p option allows you and others to reproduce your results (reproducible/verifiable experiments) and will help Alexis debug the program. Do not use this option if you want to generate multiple different starting trees.</value>
							</comment>
						</attributes>
					</parameter>

					<parameter type="Integer" issimple="1"  ismandatory="1">
						<name>parsimony_seed_val</name>
						<attributes>
							<prompt>Enter a random seed value for parsimony inferences (gives reproducible results from random starting tree)</prompt>
							<format>
								<language>perl</language>
								<code>($value) ? " -p $value" : ""</code>
							</format>
							<vdef>
								<value>12345</value>
							</vdef>
							<group>2</group>
							<precond>
								<language>perl</language>
								<code>$provide_parsimony_seed</code>
							</precond>
							<ctrls>
								<ctrl>
									<message>Please enter a random seed for the -p option (eg 12345)</message>
									<language>perl</language>
									<code>$provide_parsimony_seed &amp;&amp; !defined $parsimony_seed_val</code>
								</ctrl>
							</ctrls>
						</attributes>
					</parameter>

		<!-- rearrangement (-i) INVOCATION AND SPECIFICATION -->
					<parameter type="Switch" issimple="1" ismandatory="1">
						<name>rearrangement_yes</name>
						<attributes>
							<prompt>Specify an initial rearrangement setting (-i)</prompt>
							<vdef>
								<value>0</value>
							</vdef>
						</attributes>
					</parameter>
					
					<parameter type="Integer" issimple="1" ismandatory="1">
						<name>number_rearrange</name>
						<attributes>
							<prompt>Specify the distance from original pruning point (-i)</prompt>
							<format>
								<language>perl</language>
								<code>(defined $value)? " -i $value" : "" </code>
							</format>
							<vdef>
								<value>10</value>
							</vdef>
							<precond>
								<language>perl</language>
								<code>$rearrangement_yes</code>
							</precond>
							<ctrls>
								<ctrl>
									<message>Please specify the distance from original pruning point  (default would be 10)</message>
									<language>perl</language>
									<code>$rearrangement_yes &amp;&amp; !defined $number_rearrange</code>
								</ctrl>
							</ctrls>
							<group>2</group>
							<comment>
<value>This option allows you to specify an initial rearrangement setting for the initial phase of the search algorithm. If you specify e.g. -i 10; the pruned subtrees will be inserted up to a distance of 10 nodes away from their original pruning point. If you dont specify -i; a "good" initial rearrangement setting will automatically be determined by RAxML.
</value>
							</comment>
						</attributes>
					</parameter>
		<!-- rev 2 -->
		<!-- constraint (-g) -->
					<parameter type="InFile" issimple="1">
						<name>constraint</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>!defined $binary_backbone &amp;&amp; !$startingtreeonly</code>
							</precond>
							<prompt>Constraint (-g)</prompt>
							<filenames>constraint.tre</filenames>
							<format>
								<language>perl</language>
					<!-- 
						parameters of type Results are always processed so we need to check
						whether we actually got a value entered.
					-->
								<code>defined $value ? " -g constraint.tre" : ""</code>
							</format>
							<group>2</group>
<comment>
					<value> This option allows you to specify an incomplete or comprehensive multifurcating constraint 
					tree for the RAxML search in NEWICK format. Initially, multifurcations are resolved 
					randomly. If the tree is incomplete (does not contain all taxa) the remaining taxa are added by 
					using the MP criterion. Once a comprehensive (containing all taxa) bifurcating tree 
					is computed, it is further optimized under ML respecting the given constraints. Important: If you 
					specify a non-comprehensive constraint, e.g., a constraint tree that does not contain all taxa, 
					RAxML will assume that any taxa that not found in the constraint topology 
					are unconstrained, i.e., these taxa can be placed in any part of the tree.  As an example 
					consider an alignment with 10 taxa: Loach, Chicken, Human, Cow, Mouse, Whale, Seal, Carp, 
					Rat, Frog.  If, for example you would like Loach, Chicken, Human, Cow to be monophyletic you 
					would specify the constraint tree as follows: </value>
					<value> ((Loach, Chicken, Human, Cow),(Mouse, Whale, Seal, Carp, Rat, Frog)); </value>
					<value> Moreover, if you would like Loach, Chicken, Human, Cow to be monophyletic and in 
					addition Human, Cow to be monophyletic within that clade you could specify: </value>
					<value> ((Loach, Chicken, (Human, Cow)),(Mouse, Whale, Seal, Carp, Rat, Frog)); </value>
					<value> If you specify an incomplete constraint: </value>
					<value> ((Loach, Chicken, Human, Cow),(Mouse, Whale, Seal, Carp)); </value>
					<value> the two groups Loach, Chicken, Human, Cow and Mouse, Whale, Seal, Carp will be 
					monophyletic, while Rat and Frog can end up anywhere in the tree.  </value>
				</comment>
						</attributes>
					</parameter>
		
		<!-- binary backbone (-r) -->
					<parameter type="InFile" issimple="1">
						<name>binary_backbone</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>! defined $constraint</code>
							</precond>
							<prompt>Binary Backbone (-r)</prompt>
							<filenames>binary_backbone.tre</filenames>
							<format>
								<language>perl</language>
<!--  parameters of type Results are always processed so we need to check
						whether we actually got a value entered.   -->
								<code>(defined $value) ? " -r binary_backbone.tre" : ""</code>
							</format>
							<group>2</group>
							<comment>
<value>This option allows you to pass a binary/bifurcating constraint/backbone tree in NEWICK format to RAxML. Note that using this option only makes sense if this tree contains fewer taxa than the input alignment. The remaining taxa will initially be added by using the MP criterion. Once a comprehensive tree with all taxa has been obtained it will be  optimized under ML respecting the restrictions of the constraint tree.
</value>
							</comment>
						</attributes>
					</parameter>
		
		<!-- Optional mixed  model file -->
		<!-- If user doesn't enter a value the partition parameter won't be in the map that the web app sends the command renderer (which evaluates the perl for parameters that are present), so we don't need to worry about making the format code conditional since this parameter just won't be evaluated. Command renderer evaluates 3 types of parameters: 1) those that appear in the map coming from the gui, those that are	hidden, 3) those that are of type OutFile or Result. -->
					<parameter type="InFile" issimple="1">
						<name>partition</name>
						<attributes>
							<prompt>Use a mixed/partitioned model? (-q)</prompt>
							<format>
								<language>perl</language>
								<code>" -q part.txt"</code>
							</format>
							<group>2</group>
							<filenames>part.txt</filenames>
							<comment>
					<value>This parameter allows you to upload a file that specifies the regions of your alignment for which an individual model of nucleotide substitution should be estimated. This will typically be used to infer trees for long (in terms of base pairs) multi-gene alignments. If DNA and protein mixed models are used together (for example) you should choose a model option based on the model of rate heterogeneity you want to use. If you specify either -m GTRCAT or PROTCAT, the CAT model will be used, if you specify -m GTRGAMMA or -m BINGAMMA, the GAMMA model will be used ....
For example, if -m GTRGAMMA is used, individual alpha-shape parameters, GTR-rates, and empirical base frequencies will be estimated and optimized for each partition. Since Raxml can now handles mixed Amino Acid and DNA alignments, you must specify the data type in the partition file, before the partition name. For DNA, this means you have to add DNA to each line in the partition. For AA data you must specify the transition matrices for each partition: 
The AA substitution model must be the first entry in each line and must be separated by a comma from the gene name, just like the DNA token above. You can not assign different models of rate heterogeneity to different partitions, i.e. it will be either CAT, GAMMA, GAMMAI etc. for all partitions, as specified with -m. Finally, if you have a concatenated DNA and AA alignments, with DNA data at positions 1 - 500 and AA data at 501-1000 with the WAG model the partition file should look as follows:</value>
<value>DNA, gene1 = 1-500</value> 
<value>WAG gene2 = 501-1000</value>
							</comment>
						</attributes>
					</parameter>
					
<!-- 		7.0.4			"-f s":	option can be used to split a multi-gene alignment into individual genes, provided a model file with -q. This might be useful to select best fitting models for individual partitions of an AA multi-gene alignment or to infer per-partition trees in order to analyze tree compatibility. Example: raxmlHPC -f s -q part -s alg -m GTRCAT -n TEST. -->
<!--					<parameter type="Switch" issimple="1" ismandatory="1">
						<name>split_multigene</name>
						<attributes>
							<prompt>Split a multi-gene alignment into individual genes (-f s)</prompt>
							<precond>
								<language>perl</language>
								<code>defined $partition</code>
							</precond>
							<format>
								<language>perl</language>
								<code>($value) ? " -f s" : "" </code>
							</format>
							<ctrls>
								<ctrl>
									<message>In order to use this option, you must upload a set of bootstrapped trees using the -z option</message>
									<language>perl</language>
									<code>!defined $partition</code>
								</ctrl>
							</ctrls>
							<vdef>
								<value>0</value>
							</vdef>
							<comment>
								<value>The -f s option can be used to split a multi-gene alignment into individual genes, provided a model file with -q. This might be useful to select best fitting models for individual partitions of an AA multi-gene alignment or to infer per-partition trees in order to analyze tree compatibility. Example: raxmlHPC -f s -q part -s alg -m GTRCAT -n TEST</value>
							</comment>
						</attributes>
					</parameter> -->
					
		<!-- -M Switch on estimation of individual per-partition branch lengths. Only has effect when used in combination
with -q and an alignment partition file. Branch lengths for individual partitions will be printed to separate
files. A weighted average of the branch lengths is also computed by using the respective partition lengths
(number of columns per partition). Note that, this does not take into account the "gappyness" of partitions,
but I am currently not sure how to solve this problem. By default the -M option is turned off for partitioned
analyses, i.e., RAxML will compute a joined branch length estimate.
Example: raxmlHPC - alg -m GTRGAMMA -q part -M -n TEST.-->

					<parameter type="Switch" issimple="1" ismandatory="1">
						<name>estimate_perpartbrlen</name>
						<attributes>
							<prompt>Estimate individual per-partition branch lengths (-M)</prompt>
							<precond>
								<language>perl</language>
								<code>defined $partition</code>
							</precond>
							<format>
								<language>perl</language>
								<code>($value) ? " -M" : "" </code>
							</format>
							<vdef>
								<value>0</value>
							</vdef>
							<comment>
								<value>The -M option switches on estimation of individual per-partition branch lengths. Only has effect when used in combination with -q and an alignment partition file. Branch lengths for individual partitions will be printed to separate files. A weighted average of the branch lengths is also computed by using the respective partition lengths (number of columns per partition). Note that, this does not take into account the "gappyness" of partitions, but I am currently not sure how to solve this problem. By default RAxML will compute a joined branch length estimate.</value>
							</comment>
						</attributes>
					</parameter>

<!-- ascertainment bias -->
					<parameter issimple="1" type="Excl" >
						<name>ascertainment</name>
						<attributes>
							<prompt>Correct for Ascertainment bias (ASC_)</prompt>
							<precond>
								<language>perl</language>
								<code>!$invariable</code>
							</precond>
							<vlist>
								<value>ASC_</value>
								<label>yes</label>
								<value></value>
								<label>no</label>
							</vlist>
							<warns>
								<warn>
									<message>Ascertainment bias correction will be applied only to partitions for which it is requested in the partition file (-q) </message>
									<language>perl</language>
									<code>$ascertainment eq "ASC_" &amp;&amp; defined $partition </code>
								</warn>
							</warns>
							<vdef>
								<value></value>
							</vdef>
							<group>2</group>
							<comment>
								<value>This is useful for binary/morphological datasets that only contain variable sites (the identical morphological features are usually not
included in the alignments, hence you need to correct for this, see, e.g., http://sysbio.oxfordjournals.org/content/50/6/913.short).For DNA data this option might be useful when
you analyze alignments of SNPs that also don't contain constant sites. Note that, for mathematical and numerical reasons you can
not apply an ascertainment bias correction to datasets or partitions that contain constant sites. In this case, RAxML will exit with an error.</value>
<value>Ascertainment bias correction will be applied only to partitions for which it is requested in the partition file (-q). For example, even if the command line states -m ASC_GTRGAMMA, if the partition file does not specify ASC_ for the DNA partition, the ASC_ prefix will be ignored. </value>
							</comment>
						</attributes>
					</parameter>
<!-- end ascertainment bias		-->
<!-- ascertainment bias -->
					<parameter issimple="1" type="Excl">
						<name>ascertainment_corr</name>
						<attributes>
							<prompt>Ascertainment bias correction type (--asc-corr)</prompt>
<!-- 			  			<precond>
								<language>perl</language>
								<code>$ascertainment</code>
							</precond> -->
							<format>
								<language>perl</language>
								<code>"--asc-corr $value"</code>
							</format>
							<vlist>
								<value>lewis</value>
								<label>Lewis</label>
								<value>felsenstein</value>
								<label>Felsenstein</label>
								<value>stamatakis</value>
								<label>Stamatakis</label>
							</vlist>
							<vdef>
								<value>lewis</value>
							</vdef>
							<group>40</group>
							<ctrls>
								<ctrl>
									<message>To use the Felsentein option, you must specify the number of invariable sites in a file using -q</message>
									<language>perl</language>
									<code>$ascertainment_corr eq "felsenstein" &amp;&amp; !defined $partition</code>
								</ctrl>
								<ctrl>
									<message>To use the Stamatakis option, you must specify the number of invariable sites per state for each partition in a file using -q</message>
									<language>perl</language>
									<code>$ascertainment_corr eq "stamatakis" &amp;&amp; !defined $partition</code>
								</ctrl>
								<ctrl>
									<message>Please select an ascertainment correction method</message>
									<language>perl</language>
									<code>!defined $ascertainment_corr &amp;&amp; $ascertainment</code>
								</ctrl>
							</ctrls>
							<comment>
								<value>This option allows to specify the type of ascertainment bias correction you wish to
use. There are three types available: Lewis: the standard correction by Paul Lewis, Felsenstein: a correction introduced by Joe Felsenstein
that allows to explicitely specify the number of invariable sites (if known) one wants to correct for. Stamatakis: a correction introduced by myself that
allows to explicitly specify the number of invariable sites for each character (if known) one wants to correct for. Flesenstein and Stamatkis corrections are 
accompanied by an upload file specified by the -q option, even if only one partiion is present. For file formatting, please see the RaxML 8.1 or higher manual.</value>
							</comment>
						</attributes>
					</parameter>
					
<!-- ascertainment correction 		-->

		<!-- rev 5 -->
		<!-- Estimate proportion of invariable sites, mlsearch is a precondition  -->
		<!-- The control should be of type switch, but I need the value of the parameter
		to be either "I" or "", so I made it type Excl instead. -->
		<!-- disabled 5/5/2009 based on information in the manual -->
					<parameter issimple="1" type="Excl" >
						<name>invariable</name>
						<attributes>
							<prompt>Estimate proportion of invariable sites (GTRGAMMA + I)</prompt>
							<vlist>
								<value>I</value>
								<label>yes</label>
								<value></value>
								<label>no</label>
							</vlist>
							<vdef>
								<value></value>
							</vdef>
							<warns>
								<warn>
									<message>The invariable option is not recommended by the developer of RAxML. Please see the manual for details.</message>
									<language>perl</language>
									<code>$invariable</code>
								</warn>
							</warns>
							<group>2</group>
							<comment>
								<value>This option is not recommended by the developer of RAxML</value>
							</comment>
						</attributes>
					</parameter>
					
		<!-- Substitution matrix for protein datatype, datatype=protein is a precondition -->
		<!-- Is used to build the -m model string -->
		<!-- A value must be selected when datatype=protein, so I added a vdef, so users wont have a job fail accidentally; this also highlights where the value needs to be set by populating the box with text-->

		<!-- Optional excludes these characters -->
		<!-- If user doesn't enter a value, the parameter won't be in the map that the web app sends the command renderer (which evaluates the perl for parameters that are present), so we don't need to worry about making the format code conditional; if null, this parameter just won't be evaluated. Command renderer evaluates 3 types of parameters: 1) those that appear in the map coming from the gui, those that are hidden, 3) those that are of type OutFile or Result. -->
			<parameter type="InFile" issimple="1">
						<name>exclude_file</name>
						<attributes>
							<prompt>Choose an input file that excludes the range of positions specifed in this file (-E)</prompt>
							<format>
								<language>perl</language>
								<code>" -E excl"</code>
							</format>
							<group>2</group>
				<filenames>excl</filenames>
				<comment>
					<value>This option is used to excludes specific positions in the matrix. For example, uploading a file
					that contains the text: 100-200 300-400 will create a file that excludes all columns between positions
					100 and 200 as well as all columns between positions 300 and 400. Note that the boundary numbers (positions 100, 200, 300, 
					and 400) will also be excluded. To exclude a single column write (100-100). This option does not 
					run an analysis but just prints an alignment file without the excluded columns. Save this file to your 
					data area, and then run the real analysis. If you use a mixed model, an appropriately adapted model file 
					will also be written. The ntax element of the phylip files is automatically corrected Example: raxmlHPC -E excl
						-s infile -m GTRCAT -q part -n TEST. In this case the files with columns excluded will be named
						infile.excl and part.excl. </value>
				</comment>
						</attributes>
			</parameter>
					
			<parameter type="InFile" issimple="1">
				<name>set_weights</name>
				<attributes>
					<prompt>Weight characters as specifed in this file (-a)</prompt>
						<format>
							<language>perl</language>
							<code>" -a weights"</code>
						</format>
						<group>2</group>
					<filenames>weights</filenames>
				<comment>
<value>This option alows you to specify a column weight file name to assign individual weights to each
column of the alignment. Those weights must be integers separated by any type and number of whitespaces
within a separate file. There must, of course, be as many weights as there are columns in your
alignment. The contents of an example weight file could look like this:
5 1 1 2 1 1 1 1 1 1 1 2 1 1 3 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 4 1 1 1 4 1 1 </value>
				</comment>
				</attributes>
			</parameter>
			
<!-- add the -O option to disable checking for sequences with no values in them  
      -O      Disable check for completely undetermined sequence in alignment.
              The program will not exit with an error message when "-O" is specified.-->				
					<parameter type="Switch" issimple="1" ishidden="0">
						<name>disable_seqcheck</name>
						<attributes>
							<prompt>Disable checking for sequences with no values (-O)</prompt>
							<format>
								<language>perl</language>
								<code>($value) ? "-O" : ""</code>
							</format>
							<vdef>
								<value>0</value>
							</vdef>
							<warns>
								<warn>
									<message>Please use the -O with caution. It disables the check to see if sequences are completely devoid of information. See the RAxML manual for guidance</message>
									<language>perl</language>
									<code>$disable_seqcheck</code>
								</warn>
							</warns>
						<group>54</group>
						</attributes>
					</parameter>
					
<!-- add the -mesquite option for David Maddison mesquite
Print output files that can be parsed by Mesquite.
DEFAULT: Off
Example: raxmlHPC -p 12345 -s alg -*mesquite -n TEST -m GTRGAMMA-->				
					<parameter type="Switch" issimple="1" ishidden="0">
						<name>mesquite_output</name>
						<attributes>
							<prompt>Print output files that can be parsed by Mesquite. (-mesquite)</prompt>
							<format>
								<language>perl</language>
								<code>($value) ? "--mesquite" : ""</code>
							</format>
							<vdef>
								<value>0</value>
							</vdef>
						<group>54</group>
						</attributes>
					</parameter>
		
<!-- Nucleotides as sequences (not secondary structure -->
<parameter type="Paragraph">
	<paragraph>
		<name>nucleic_opts</name>
		<prompt>Nucleic Acid Options</prompt>
		<parameters>
<!--               NUCLEOTIDES:

                "-m GTRCAT"         : GTR + Optimization of substitution rates + Optimization of site-specific
                                      evolutionary rates which are categorized into numberOfCategories distinct 
                                      rate categories for greater computational efficiency.  Final tree might be evaluated
                                      under GTRGAMMA, depending on the tree search option
  NOT SUPPORTED "-m GTRCAT_FLOAT"   : Same as above but uses single-precision floating point arithmetics instead of double-precision
                                      Usage only recommend for testing, the code will run slower, but can save almost 50% of memory.
                                      If you have problems with phylogenomic datasets and large memory requirements you may give it a shot.
                                      Keep in mind that numerical stability seems to be okay but needs further testing.
  NOT SUPPORTED "-m GTRCATI"        : GTR + Optimization of substitution rates + Optimization of site-specific
                                      evolutionary rates which are categorized into numberOfCategories distinct 
                                      rate categories for greater computational efficiency.  Final tree might be evaluated
                                      under GTRGAMMAI, depending on the tree search option
                "-m GTRGAMMA"       : GTR + Optimization of substitution rates + GAMMA model of rate 
                                      heterogeneity (alpha parameter will be estimated)
				
  NOT SUPPORTED "-m GTRGAMMA_FLOAT" : Same as GTRGAMMA, but also with single-precision arithmetics, same cautionary notes as for  
                                      GTRCAT_FLOAT apply.
  NOT SUPPORTED "-m GTRGAMMAI"      : Same as GTRGAMMA, but with estimate of proportion of invariable sites -->
                
					<parameter type="Excl">
						<name>dna_gtrcat</name>
						<attributes>
							<prompt>Choose model for bootstrapping phase</prompt>
							<precond>
								<language>perl</language>
								<code>$datatype eq "dna" || $datatype eq "rna"</code>
							</precond>
							<vlist>
								<value>GTRCAT</value>
								<label>GTRCAT</label>
				                <value>GTRGAMMA</value>
								<label>GTRGAMMA</label>
							</vlist>
							<format>
								<language>perl</language>
								<code>"-m $ascertainment$value$invariable"</code>
							</format>
							<vdef>
								<value>GTRCAT</value>
							</vdef>
							<group>2</group>
							<ctrls>
								<ctrl>
									<message>Please choose a DNA model</message>
									<language>perl</language>
									<code>($datatype eq "dna" || $datatype eq "rna") &amp;&amp; $dna_gtrcat ne "GTRCAT" &amp;&amp; $dna_gtrcat ne "GTRGAMMA"</code>
								</ctrl>
							</ctrls>
							<comment>
								<value>The meaning of the model name GTRGAMMA used by RAxML 7.2.0 is exactly opposite that 
									used in RAxML 7.0.4, so we have eliminated selection by model name. Instead we use a 
									description of the  model analysis. This selection gives GTR + Optimization of substitution
									 rates + Optimization of site-specific evolutionary rates which are categorized into "numberOfCategories" distinct
									 rate categories for greater computational efficiency.  Final tree is evaluated under GTRGAMMA. 
									GTRMIX  and GTRCAT_GAMMA have been eliminated as options. FLOAT options that are native in RAxML 7.2.3 are currently not supported here.
								</value>
							</comment>
						</attributes>
					</parameter>
				
		</parameters>
	</paragraph>
</parameter>
						
			<parameter type="Paragraph">
				<paragraph>
					<name>protein_opts</name>
					<prompt>Protein Analysis Options</prompt>
					<parameters>		 
					
<!--               AMINO ACIDS:

                "-m PROTCATmatrixName[F]"         : specified AA matrix + Optimization of substitution rates + Optimization of site-specific
                                                    evolutionary rates which are categorized into numberOfCategories distinct 
                                                    rate categories for greater computational efficiency.   Final tree might be evaluated
                                                    automatically under PROTGAMMAmatrixName[f], depending on the tree search option
                "-m PROTCATmatrixName[F]_FLOAT"   : PROTCAT with single precision arithmetics, same cautionary notes as for GTRCAT_FLOAT apply
                "-m PROTCATImatrixName[F]"        : specified AA matrix + Optimization of substitution rates + Optimization of site-specific
                                                    evolutionary rates which are categorized into numberOfCategories distinct 
                                                    rate categories for greater computational efficiency.   Final tree might be evaluated
                                                    automatically under PROTGAMMAImatrixName[f], depending on the tree search option
                "-m PROTGAMMAmatrixName[F]"       : specified AA matrix + Optimization of substitution rates + GAMMA model of rate 
                                                    heterogeneity (alpha parameter will be estimated)
                "-m PROTGAMMAmatrixName[F]_FLOAT" : PROTGAMMA with single precision arithmetics, same cautionary notes as for GTRCAT_FLOAT apply
                "-m PROTGAMMAImatrixName[F]"      : Same as PROTGAMMAmatrixName[F], but with estimate of proportion of invariable sites 

                Available AA substitution models: DAYHOFF, DCMUT, JTT, MTREV, WAG, RTREV, CPREV, VT, BLOSUM62, MTMAM, LG, GTR
                With the optional "F" appendix you can specify if you want to use empirical base frequencies
                Please note that for mixed models you can in addition specify the per-gene AA model in
                the mixed model file (see manual for details). Also note that if you estimate AA GTR parameters on a partitioned
                dataset, they will be linked (estimated jointly) across all partitions to avoid over-parameterization -->
   
<!-- not sure if we should support cat or not -->             		
					<parameter type="Excl" ismandatory="1">
						<name>prot_sub_model</name>
						<attributes>
							<prompt>Choose GAMMA or CAT model:</prompt>
							<precond>
								<language>perl</language>
								<code>$datatype eq "protein"</code>
							</precond>
							<vlist>
								<value>PROTGAMMA</value>
								<label>Protein GAMMA</label>
								<value>PROTCAT</value>
								<label>Protein CAT</label>
							</vlist>
<!--change for invariable option -->
							<format>
								<language>perl</language>
								<code>"-m $ascertainment$value$invariable$prot_matrix_spec$use_emp_freqs"</code>
							</format>
							<vdef>
								<value>PROTCAT</value>
							</vdef>
							<group>2</group>
							<ctrls>
								<ctrl>
									<message>Please choose a protein model</message>
									<language>perl</language>
									<code>$datatype eq "protein" &amp;&amp; $prot_sub_model ne "PROTGAMMA" &amp;&amp; $prot_sub_model ne "PROTCAT" </code>
								</ctrl>
								<ctrl>
									<message>Sorry, the -f x option is valid only with GAMMA models</message>
									<language>perl</language>
									<code>$compute_ml_distances &amp;&amp; $prot_sub_model ne "PROTGAMMA"</code>
								</ctrl>
							</ctrls>
						</attributes>
					</parameter> 
		
				<parameter type="Excl" ismandatory="1">
						<name>prot_matrix_spec</name>
						<attributes>
							<prompt>Protein Substitution Matrix</prompt>
							<precond>
								<language>perl</language>
								<code>$datatype eq "protein"</code>
							</precond>
<!--New AA substitution models: MTART, MTZOA, PMB, HIVB, HIVW, JTTDCMUT, FLU 10/4/2010-->
							<vlist>
								<value>DAYHOFF</value>
								<label>DAYHOFF</label>
								<value>DCMUT</value>
								<label>DCMUT</label>
								<value>JTT</value>
								<label>JTT</label>
								<value>MTREV</value>
								<label>MTREV</label>
								<value>WAG</value>
								<label>WAG</label>
								<value>RTREV</value>
								<label>RTREV</label>
								<value>CPREV</value>
								<label>CPREV</label>
								<value>VT</value>
								<label>VT</label>
								<value>BLOSUM62</value>
								<label>BLOSUM62</label>
								<value>MTMAM</value>
								<label>MTMAM</label>
								<value>LG</value>
								<label>LG</label>
								<value>MTART</value>
								<label>MTART</label>
								<value>MTZOA</value>
								<label>MTZOA</label>
								<value>PMB</value>
								<label>PMB</label>
								<value>HIVB</value>
								<label>HIVB</label>
								<value>HIVW</value>
								<label>HIVW</label>
								<value>JTTDCMUT</value>
								<label>JTTDCMUT</label>
								<value>FLU</value>
								<label>FLU</label>
								<value>DUMMY</value>
								<label>DUMMY</label>
								<value>DUMMY2</value>
								<label>DUMMY2</label>
								<value>AUTO</value>
								<label>AUTO</label>
								<value>LG4M</value>
								<label>LG4M</label>
								<value>LG4X</value>
								<label>LG4X</label>
								<value>PROT_FILE</value>
								<label>PROT_FILE</label>
								<value>GTR_UNLINKED</value>
								<label>GTR_UNLINKED</label>
								<value>GTR</value>
								<label>GTR</label>
							</vlist>
							<vdef>
								<value>DAYHOFF</value>
							</vdef>
							<comment>
<value>Note: FLOAT and invariable sites (I) options are not exposed here. If you require this option, please contact mmiller@sdsc.edu.</value>
<value>-m PROTCATmatrixName: analyses using the specified AA matrix + Optimization of substitution rates + Optimization of site-specific evolutionary rates which are categorized into numberOfCategories distinct rate categories for greater computational efficiency. Final tree might be evaluated automatically under PROTGAMMAmatrixName[f], depending on the tree search option.
</value>
<value>-m PROTGAMMAmatrixName[F] analyses use the specified AA matrix + Optimization of substitution rates + GAMMA model of rate heterogeneity (alpha parameter will be estimated)</value>
<value>Available AA substitution models: DAYHOFF, DCMUT, JTT, MTREV, WAG, RTREV, CPREV, VT, BLOSUM62, MTMAM, LG, GTR. You can specify if you want to use empirical base frequencies. Please note that for mixed models you can in addition specify the per-gene AA model in the mixed model file (see manual for details). Also note that if you estimate AA GTR parameters on a partitioned dataset, they will be linked (estimated jointly) across all partitions to avoid over-parametrization.</value>
							</comment>
						</attributes>
					</parameter>

<!--[-P proteinModel] Specify the file name of a user-defined AA (Protein) substitution model. This file must contain 420 entries, the first 400 being the AA substitution rates (this must be a symmetric matrix) and the last 20 are the empirical base frequencies -->

					<parameter type="InFile" >
						<name>user_prot_matrix</name>
						<attributes>
							<prompt>Upload a Custom Protein Substitution Matrix</prompt>
							<precond>
								<language>perl</language>
								<code>$datatype eq "protein"</code>
							</precond>
							<format>
								<language>perl</language>
								<code>"-P Userproteinmatrix.txt"</code>
							</format>
							<group>2</group>
							<filenames>Userproteinmatrix.txt</filenames>
							<comment>
<value>Specify a file containing a user-defined Protein substitution model. This file must contain 420 entries, the first 400 entires are the AA substitution rates (this matrix must be symmetric) and the last 20 entries are the empirical base frequencies</value>
							</comment>
						</attributes>
					</parameter>
						
<!-- user requested option for multiple protein matrices-->	
					<parameter type="Switch">
						<name>mulcustom_aa_matrices</name>
						<attributes>
							<prompt>Use a Partition file that specifies AA Matrices</prompt>
							<precond>
								<language>perl</language>
								<code>$datatype eq "protein"</code>
							</precond>
							<ctrls>
								<ctrl>
									<message>Please choose a partition file specifying up to 5 partitions</message>
									<language>perl</language>
									<code>$mulcustom_aa_matrices &amp;&amp; !defined $partition</code>
								</ctrl>
							</ctrls>
							<comment>
								<value>This option can be used to specify multiple custom matrices via a partition file. The filenames must be specified as firstpartition, secondpartition, thirdpartition, fourthpartition, and fifthpartition, in order, </value>
							</comment>
						</attributes>
					</parameter>
										
<!--  This option has never received much attention in the RAxML manual and
tutorials, but I think it is available since one or two years. That's how it works in a local implementation.

Files needed:
data.phy
matrix1
matrix2
matrix3
partitions

The "matrix" files have a specific format, the same as if you use only
custom one. The "partitions" file is similar to the one used in regular partitioned
analyses. It is different only in that each line begins with the name of
the matrix file (with path if needed, between square brackets) instead of
the name of the model. The -q options tells the software to read this file.

A small "partition" file:
[/home/fn/Desktop/raxml776/mat582], firstpartition = 1-20
[/home/fn/Desktop/raxml776/mat1414], secondpartition = 21-30
[/home/fn/Desktop/raxml776/mat657], thirdpartition = 31-50


Then the command is:
./raxmlHPC -m PROTGAMMAMTREV -q partitions -p 123 -s smallprotein.phy -n
test 

The software takes the fact that we are talking about proteins (PROT) and
the among site rate variation part (GAMMA) from the PROTGAMMAMTREV token,
discarding the r-matrix (MTREV) part. The r-matrices are in turn taken
(differently for each partition) from the matrix files, whose location is
indicated in the partiton file. The among site rate variation has to be the
same for all partitions (not much of a problem). -->
	
					<parameter type="InFile" >
						<name>user_prot_matrixq1</name>
						<attributes>
							<prompt>Select the First Protein Substitution Matrix Called in Your Partition File</prompt>
							<precond>
								<language>perl</language>
								<code>$mulcustom_aa_matrices</code>
							</precond>
							<filenames>firstpartition</filenames>
							<comment>
<value>This option allows the user to upload a Protein subsitution matrix</value>
							</comment>
						</attributes>
					</parameter>
					
					<parameter type="InFile" >
						<name>user_prot_matrixq2</name>
						<attributes>
							<prompt>Select the Second Protein Substitution Matrix Called in Your Partition File</prompt>
							<precond>
								<language>perl</language>
								<code>$mulcustom_aa_matrices &amp;&amp; defined $user_prot_matrixq1</code>
							</precond>
							<filenames>secondpartition</filenames>
							<comment>
<value>This option allows the user to upload a second Protein subsitution matrix</value>
							</comment>
						</attributes>
					</parameter>
						
					<parameter type="InFile" >
						<name>user_prot_matrixq3</name>
						<attributes>
							<prompt>Select the Third Protein Substitution Matrix Called in Your Partition File</prompt>
							<precond>
								<language>perl</language>
								<code>$mulcustom_aa_matrices &amp;&amp; defined $user_prot_matrixq2</code>
							</precond>
							<filenames>thirdpartition</filenames>
							<comment>
<value>This option allows the user to upload a third Protein subsitution matrix</value>
							</comment>
						</attributes>
					</parameter>

					<parameter type="InFile" >
						<name>user_prot_matrixq4</name>
						<attributes>
							<prompt>Select the Fourth Protein Substitution Matrix Called in Your Partition File</prompt>
							<precond>
								<language>perl</language>
								<code>$mulcustom_aa_matrices &amp;&amp; defined $user_prot_matrixq3</code>
							</precond>
							<filenames>fourthpartition</filenames>
							<comment>
<value>This option allows the user to upload a fourth Protein subsitution matrix</value>
							</comment>
						</attributes>
					</parameter>	
						
					<parameter type="InFile" >
						<name>user_prot_matrixq5</name>
						<attributes>
							<prompt>Select the Fifth Protein Substitution Matrix Called in Your Partition File</prompt>
							<precond>
								<language>perl</language>
								<code>$mulcustom_aa_matrices &amp;&amp; defined $user_prot_matrixq4</code>
							</precond>
							<filenames>fifthpartition</filenames>
							<comment>
<value>This option allows the user to upload a fifth Protein subsitution matrix</value>
							</comment>
						</attributes>
					</parameter>

		<!-- Empirical Base Frequencies -->		
					<parameter type="Excl">
						<name>use_emp_freqs</name>
						<attributes>
							<prompt>Use empirical frequencies?</prompt>
							<precond>
								<language>perl</language>
								<code>$datatype eq "protein"</code>
							</precond>
							<vlist>
								<value>F</value>
								<label>Yes</label>
								<value></value>
								<label>No</label>
							</vlist>
						</attributes>
					</parameter> 

		<!-- datatype=protein is a precondition, adds -F to end of -m model string -->
				
				</parameters>
			</paragraph>
		</parameter>
		
		<parameter type="Paragraph">
			<paragraph>
				<name>Sec_structure_opts</name>
				<prompt>RNA Secondary Structure Options</prompt>
				<parameters>
<!--***************************************************************************************************************************************************************************-->
<!-- ******************************THESE FEATURES ARE READY TO GO, BUT WHO KNOWS IF THEY WORK************************************************-->
<!-- 	[-S secondaryStructureFile] Specify the name of a secondary structure file. The file can contain "." for  alignment columns that do not form part of a stem and characters. "()<>[]{}" to define stem regions and pseudoknots -->
		 
					<parameter type="InFile" >
						<name>sec_str_file</name>
						<attributes>
						<precond>
								<language>perl</language>
								<code>$datatype eq "rna"</code>
							</precond> 
							<prompt>Upload a Secondary Structure File (-S)</prompt>
							<filenames>sec_structure.txt</filenames>
							<format>
								<language>perl</language>
								<code>(defined $value) ? " -S sec_structure.txt" : ""</code>
							</format>
							<group>2</group>
							<comment>
<value>This option allows you to provide a secondary structure file. The file can contain "." for  alignment columns that do not form part of a stem and characters, while  "(), [], and {}" are used to define stem regions and pseudoknots.</value>
							</comment>
						</attributes>
					</parameter>	 
		 
<!--     [-A secondaryStructureSubstModel] 	Specify one of the RNA secondary structure substitution models implemented in RAxML.
			The same nomenclature as in the PHASE manual is used, available models: 
			S6A, S6B, S6C, S6D, S6E, S7A, S7B, S7C, S7D, S7E, S7F, S16, S16A, S16B
			DEFAULT: 16-state GTR model (S16)
			6 state model nomenclature: http://www.cs.manchester.ac.uk/ai/Software/phase/manual/node101.html 
			7 state model nomenclature http://www.cs.manchester.ac.uk/ai/Software/phase/manual/node107.html
			16 state model nomenclature http://www.cs.manchester.ac.uk/ai/Software/phase/manual/node114.html -->
														  
 			<parameter type="Excl" ismandatory="1">
						<name>rna_model</name>
						<attributes>
							<prompt>Use an RNA Secondary Structure Substitution Model (-A)</prompt>
							<precond>
								<language>perl</language>
								<code>defined $sec_str_file</code>
							</precond>
							<vlist>
								<value>S6A</value>
								<label>Six State Model A</label>
								<value>S6B</value>
								<label>Six State Model B</label>
								<value>S6C</value>
								<label>Six State Model C</label>
								<value>S6D</value>
								<label>Six State Model D</label>
								<value>S6E</value>
								<label>Six State Model E</label>
								<value>S7A</value>
								<label>Seven State Model A</label>
								<value>S7B</value>
								<label>Seven State Model B</label>
								<value>S7C</value>
								<label>Seven State Model C</label>
								<value>S7D</value>
								<label>Seven State Model D</label>
								<value>S7E</value>
								<label>Seven State Model E</label>
								<value>S7F</value>
								<label>Seven State Model F</label>
								<value>S16A</value>
								<label>Sixteen State Model A</label>
								<value>S16B</value>
								<label>Sixteen State Model B</label>
							</vlist>
							<vdef>
								<value>S16A</value>
							</vdef>
							<format>
								<language>perl</language>
								<code>"-A $value"</code>
							</format>
							<group>2</group>
							<comment>
<value>Use this option to specify one of the 6, 7, or 16 state RNA secondary structure substitution models.The nomenclature is identical to that used in the program PHASE. For more information, see PHASE documentation: 6 state model nomenclature: http://www.cs.manchester.ac.uk/ai/Software/phase/manual/node101.html; 7 state model nomenclature http://www.cs.manchester.ac.uk/ai/Software/phase/manual/node107.html; 16 state model nomenclature http://www.cs.manchester.ac.uk/ai/Software/phase/manual/node114.html</value>
							</comment> 
					</attributes> 
					</parameter>
		
				</parameters>
			</paragraph>
		</parameter>
		
		<parameter type="Paragraph">
			<paragraph>
				<name>bin_opts</name>
				<prompt>Binary Matrix Options</prompt>
				<parameters>
						<!-- -m argument to specify substitution model is required -->
<!-- mmiller changed the way this is done  I exposed the other nucleic acid model options on 8/3/2009 -->
		<!--             [ -m      Model of Binary (Morphological), Nucleotide or Amino Acid Substitution]: 

            BINARY: (NEW for 7.2.0)

                "-m BINCAT"         : Optimization of site-specific
                                      evolutionary rates which are categorized into numberOfCategories distinct 
                                      rate categories for greater computational efficiency. Final tree might be evaluated
                                      automatically under BINGAMMA, depending on the tree search option
                "-m BINCATI"        : Optimization of site-specific
                                      evolutionary rates which are categorized into numberOfCategories distinct 
                                      rate categories for greater computational efficiency. Final tree might be evaluated
                                      automatically under BINGAMMAI, depending on the tree search option 
                "-m BINGAMMA"       : GAMMA model of rate heterogeneity (alpha parameter will be estimated)
                "-m BINGAMMAI"      : Same as BINGAMMA, but with estimate of proportion of invariable sites

The I option is not added in this interface                                                                 -->
					<parameter type="Excl" ismandatory="1">
						<name>bin_model</name>
						<attributes>
							<prompt>Binary data model (-m)</prompt>
							<precond>
								<language>perl</language>
								<code>$datatype eq "binary"</code>
							</precond> 
							<vlist>
								<value>BINCAT</value>
								<label>Binary CAT</label>
								<value>BINGAMMA</value>
								<label>Binary GAMMA</label>
							</vlist>
							<vdef>
								<value>BINCAT</value>
							</vdef>
							<format>
								<language>perl</language>
								<code>"-m $ascertainment$value$invariable"</code>
							</format>
							<group>2</group>
							<ctrls>
								<ctrl>
									<message>Please choose a binary model</message>
									<language>perl</language>
									<code>$datatype eq "binary" &amp;&amp; $bin_model ne "BINCAT" &amp;&amp; $bin_model ne "BINGAMMA" </code>
								</ctrl>
								<ctrl>
									<message>Sorry, the -f x option is valid only with GAMMA models</message>
									<language>perl</language>
									<code>$compute_ml_distances &amp;&amp; $bin_model ne "BINGAMMA"</code>
								</ctrl>
							</ctrls>
							<comment>
<value>Binary data is handled in RAXML 7.2.0. Binary CAT use optimization of site-specific evolutionary rates, which are categorized into numberOfCategories (option -c) distinct  rate categories for greater computational efficiency. Final tree might be evaluatedautomatically under BINGAMMA, depending on the tree search option. </value>
<value>Binary GAMMA uses the GAMMA model of rate heterogeneity (alpha parameter will be estimated). The option for invariable sites is not provided at this time. The program's author supports the use of Gamma models.</value>
							</comment> 
						</attributes>
					</parameter>
				</parameters>
			</paragraph>
		</parameter>

		<parameter type="Paragraph">
			<paragraph>
				<name>multi_opts</name>
				<prompt>Multiple State Morphological Matrix Options</prompt>
				<parameters>
<!--             MULTI-STATE:

                 "-m MULTICAT"         Optimization of site-specific evolutionary rates which are categorized into numberOfCategories distinct
                                       rate categories for greater computational efficiency. Final tree might be evaluated automatically under MULTIGAMMA,
	                                   depending on the tree search option
                 "-m MULTICATI"        : Optimization of site-specific evolutionary rates which are categorized into numberOfCategories distinct
                                       rate categories for greater computational efficiency. Final tree might be evaluated automatically under MULTIGAMMAI, depending on the 
	                                   tree search option
                 "-m MULTIGAMMA"       : GAMMA model of rate heterogeneity (alpha parameter will be estimated)
                 "-m MULTIGAMMAI"      : Same as MULTIGAMMA, but with estimate of proportion of invariable sites
	                                     You can use up to 32 distinct characters to encode multi-state regions, they must be used in the following 
	                                     order:0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V
                                         i.e., if you have 6 distinct characters you would use 0, 1, 2, 3, 4, 5 to encode these.
                                         The substitution model for the multi-state regions can be selected via the "-K" option-->
					<parameter type="Excl" ismandatory="1">
						<name>multi_model</name>
						<attributes>
							<prompt>Multiple State Data Model (-m)</prompt>
							<precond>
								<language>perl</language>
								<code>$datatype eq "multi"</code>
							</precond> 
							<vlist>
								<value>MULTICAT</value>
								<label>Multi-state CAT</label>
								<value>MULTIGAMMA</value>
								<label>Multi-state GAMMA</label>
							</vlist>
							<vdef>
								<value>MULTICAT</value>
							</vdef>
							<format>
								<language>perl</language>
								<code>"-m $ascertainment$value$invariable"</code>
							</format>
							<group>2</group>
							<ctrls>
								<ctrl>
									<message>Please choose a Multi-State model</message>
									<language>perl</language>
									<code>$datatype eq "multi" &amp;&amp; $multi_model ne "MULTICAT" &amp;&amp; $multi_model ne "MULTIGAMMA" </code>
								</ctrl>
							</ctrls>
							<comment>
<value>Multi-state morphological data are handled in RAXML at V. 7.3.0 and above. Multi-state CAT uses optimization of site-specific evolutionary rates which are categorized
into numberOfCategories distinct rate categories for greater computational efficiency. Final tree might be evaluated automatically under MULTIGAMMA depending on the tree search option </value>
<value>Mutli-state GAMMA uses the GAMMA model of rate heterogeneity (alpha parameter will be estimated). Invariable sites (I) options are not exposed here. 
	If you require this option, please contact mmiller@sdsc.edu.</value>
							</comment> 
						</attributes>
					</parameter>
					
					<parameter type="Excl" ismandatory="1">
<!--	[-K] syntax?(not yet supported)Specify one of the multi-state substitution models (max 32 states) implemented in RAxML.
              Available models are: ORDERED, MK, GTR
              DEFAULT: GTR model -->
						<name>choose_multi_model</name>
						<attributes>
							<prompt>Select a Multiple state data model (-K)</prompt>
  							<precond>
								<language>perl</language>
								<code>$datatype eq "multi"</code>
							</precond>
							<vlist>
								<value>ORDERED</value>
								<label>Ordered</label>
								<value>MK</value>
								<label>MK</label>
								<value>GTR</value>
								<label>GTR</label>
							</vlist>
							<vdef>
								<value>GTR</value>
							</vdef>
							<format>
								<language>perl</language>
								<code>"-K $value"</code>
							</format>
							<group>2</group>
							<ctrls>
								<ctrl>
									<message>Please choose a Multi-State data model</message>
									<language>perl</language>
									<code>$datatype eq "multi" &amp;&amp; $choose_multi_model ne "ORDERED" &amp;&amp; $choose_multi_model ne "MK" &amp;&amp; $choose_multi_model ne "GTR" </code>
								</ctrl>
							</ctrls>
							<comment>
<value>Multi-state morphological data are handled in RAXML 7.3.0 and above. Multi-state CAT uses optimization of site-specific evolutionary rates which are categorized
into numberOfCategories distinct rate categories for greater computational efficiency. Final tree might be evaluated automatically under MULTIGAMMA depending on the tree search option </value>
<value>Mutli-state GAMMA uses the GAMMA model of rate heterogeneity (alpha parameter will be estimated). The program's author supports the use of Gamma models.</value>
							</comment> 
						</attributes>
					</parameter>
					
					
				</parameters>
			</paragraph>
		</parameter>
		
		<parameter type="Paragraph">
			<paragraph>
				<name>set_analysis</name>
				<prompt>Select the Analysis</prompt>
				<parameters>
					<!-- rev 3 -->
					<!-- added for jbmunro -->
					<parameter type="Switch">
						<name>startingtreeonly</name>
						<attributes>
							<prompt>Only compute a randomized parsimony starting tree (-y)</prompt>
							<format>
								<language>perl</language>
								<code> ($value)?" -y":""</code>
							</format>
							<vdef>
								<value>0</value>
							</vdef>
							<precond>
								<language>perl</language>
								<code>!$compute_mr &amp;&amp; !$thorough_opt &amp;&amp; !$ancestral_states &amp;&amp; !$fast_tree &amp;&amp; !$mulparambootstrap_seed &amp;&amp;!$bootstrap_seed &amp;&amp; !$bipartitions &amp;&amp; ! defined $constraint &amp;&amp; !$log_likelihood &amp;&amp;  !$compute_ml_distances &amp;&amp; !$specify_runs &amp;&amp; !$morpho_weight_calibration &amp;&amp; !$classify_into_reftree</code>
							</precond>
							<group>2</group>
							<comment>
								<value>If you want to only compute a randomized parsimony starting tree with RAxML and not execute an ML analysis of the tree specify -y. The program will exit after computation of the starting tree. This option can be useful if you want to assess the impact of randomized MP and Neighbor Joining starting trees on your search algorithm. They can also be used e.g. as starting trees for Derrick Zwickls GARLI program for ML inferences, which needs comparatively good starting trees to work well above approximately 500 taxa. </value>
							</comment>
						</attributes>
					</parameter>
					
					<!-- added for jbmunro -->
					<!-- -f d:	DEFAULT, RAxML will execute the new (as of version 2.2.1) and significantly faster rapid hill-climbing algorithm [3]. -->
					<!-- added for jbmunro -->

<!--					<parameter type="Switch">
						<name>hillclimb</name>
						<attributes>
							<prompt>Use the new, faster rapid hill-climbing algorithm (-f d)</prompt>
							<format>
								<language>perl</language>
								<code> ($value)?" -f d ":""</code>
							</format>
							<vdef>
								<value>1</value>
							</vdef>
							<group>2</group>
							<precond>
								<language>perl</language>
								<code>!$bipartitions &amp;&amp; !$startingtreeonly &amp;&amp; !$log_likelihood</code>
							</precond>
							<comment>
								<value>This is the deault option. RAxML will execute the new (as of version 2.2.1) and significantly faster rapid hill-climbing algorithm</value>
							</comment>
						</attributes>
					</parameter>  -->
					
<!-- -#|-N numberOfRuns Specifies the number of alternative runs on distinct starting trees, e.g., if -# 10 or -N 10 is specfied RAxML
will compute 10 distinct ML trees starting from 10 distinct randomized maximum parsimony starting trees. -->
					<parameter type="Switch" ismandatory="1">
						<name>specify_runs</name>
						<attributes>
							<prompt>Specify the number alternative runs on distinct starting trees? (-#/-N)</prompt>
							<precond>
								<language>perl</language>
								<code>!$compute_mr &amp;&amp; !$thorough_opt &amp;&amp; !$fast_tree &amp;&amp; !$ancestral_states &amp;&amp; !$bootstrap_seed &amp;&amp; !$mulparambootstrap_seed &amp;&amp; !$bipartitions &amp;&amp; !$startingtreeonly &amp;&amp; !$log_likelihood &amp;&amp; !$classify_into_reftree</code>
							</precond> 
							<comment>
								<value>This option specifies the number of alternative runs on distinct starting trees. For example, if  -N 10 is specfied, RAxML
will compute 10 distinct ML trees starting from 10 distinct randomized maximum parsimony starting trees. </value>
							</comment>
						</attributes>
					</parameter>
					
					<parameter type="Integer" ismandatory="1">
						<name>altrun_number</name>
						<attributes>
							<prompt>Enter number of number alternative runs</prompt>
							<precond>
								<language>perl</language>
								<code>$specify_runs</code>
							</precond>
							<format>
								<language>perl</language>
								<code>"-N $value"</code>
							</format>
							<group>15</group>
							<ctrls>
								<ctrl>
									<message>Please specify how many runs you wish to execute  (eg 10)</message>
									<language>perl</language>
									<code>$specify_runs &amp;&amp; !defined $altrun_number</code>
								</ctrl>
								<ctrl>
									<message>Sorry, the value for alternative runs must 1000 or less</message>
									<language>perl</language>
									<code>$altrun_number &gt; 1000</code>				
								</ctrl>		
							</ctrls>
							<comment>
								<value>if  -N 10 is specfied, RAxML will compute 10 distinct ML trees starting from 10 distinct randomized maximum parsimony starting trees.</value>
							</comment>
						</attributes>
					</parameter>
					
<!--  -->					
<!-- Dont use BFGS-->					
					<parameter type="Switch" issimple="0">
						<name>no_bfgs</name>
						<attributes>
							<prompt>Don't use BFGS searching algorithm (--no-bfgs)</prompt>
							<vdef>
								<value>0</value>
							</vdef>
							<format>
								<language>perl</language>
								<code>($value)? "--no-bfgs":""</code>
							</format>
<!--  							<ctrls>
								<ctrl>
									<message>Sorry, you cant use automatic bootstopping with a constraint tree</message>
									<language>perl</language>
									<code>$use_bootstopping &amp;&amp; defined $constraint</code>
								</ctrl>
							</ctrls> -->
							<comment>
<value> BFGS is a more efficient optimization algorithm for optimizing 
branch lengths and GTR parameters simultaneously. YUOu can disable it using this option</value>
							</comment>
						</attributes>
					</parameter>	
					
								
					<!-- added for jbmunro -->
					<parameter type="Switch">
						<name>bipartitions</name>
						<attributes>
							<prompt>Draw bipartitions onto a single tree topology. (-f b)</prompt>
							<format>
								<language>perl</language>
								<code> ($value)?" -f b ":""</code>
							</format>
							<vdef>
								<value>0</value>
							</vdef>
							<group>2</group>
							<precond>
								<language>perl</language>
								<code>!$compute_mr &amp;&amp; !$thorough_opt &amp;&amp; !$ancestral_states &amp;&amp; !$fast_tree &amp;&amp; !$mulparambootstrap_seed &amp;&amp;!$bootstrap_seed &amp;&amp; !$startingtreeonly &amp;&amp; !$log_likelihood &amp;&amp; !$compute_ml_distances  &amp;&amp; !$specify_runs &amp;&amp; !$morpho_weight_calibration &amp;&amp; !$classify_into_reftree</code>
							</precond> 
							<ctrls>
								<ctrl>
									<message>To use the -f b option you must specify a best tree with "-t" and file containing multiple trees with the "-z" option</message>
									<language>perl</language>
									<code>!$bootstrap_seed &amp;&amp; $bipartitions &amp;&amp; ( !defined $bunchotops || !defined $treetop)</code>
									</ctrl>
							</ctrls>
							<comment>
								<value>When this is specified, RAxML draws the bipartitions using a bunch of topologies (typically boot-strapped trees) specified with -z onto a single tree topology specified by -t (typically the best-scoring ML tree). </value>
							</comment>
						</attributes>
					</parameter>
<!--ancestral states added for andrew bergemann-->
					<parameter type="Switch">
						<name>ancestral_states</name>
						<attributes>
							<prompt>Compute Marginal Ancestral States using a rooted reference tree. (-f A)</prompt>
							<format>
								<language>perl</language>
								<code> ($value)?" -f A ":""</code>
							</format>
							<vdef>
								<value>0</value>
							</vdef>
							<group>2</group>
							<precond>
								<language>perl</language>
								<code>!$compute_mr &amp;&amp; !$thorough_opt &amp;&amp; !$bipartitions &amp;&amp; !$fast_tree &amp;&amp; !$mulparambootstrap_seed &amp;&amp;!$bootstrap_seed &amp;&amp; !$startingtreeonly &amp;&amp; !$log_likelihood &amp;&amp; !$compute_ml_distances  &amp;&amp; !$specify_runs &amp;&amp; !$morpho_weight_calibration &amp;&amp; !$classify_into_reftree</code>
							</precond> 
							<ctrls>
								<ctrl>
									<message>To use the -f A option you must specify a best tree with "-t"</message>
									<language>perl</language>
									<code>!$bootstrap_seed &amp;&amp; $ancestral_states &amp;&amp; !defined $treetop</code>
									</ctrl>
							</ctrls>
							<comment>
								<value>When this is specified, RAxML draws the bipartitions using a bunch of topologies (typically boot-strapped trees) specified with -z onto a single tree topology specified by -t (typically the best-scoring ML tree). </value>
							</comment>
						</attributes>
					</parameter>					
					
<!-- -f h:	RAxML will compute a log likelihood test (SH-test [21]) between a best tree passed via -t and a bunch of other trees passed via -z. Example: raxmlHPC -f h -t ref -z trees -s alg -m GTRGAMMA -n TEST. -->
<!-- added for Ryan Lower  raxmlHPC   -->
					<parameter type="Switch">
						<name>log_likelihood</name>
						<attributes>
							<prompt>Compute a log likelihood test (-f h)</prompt>
							<format>
								<language>perl</language>
								<code> ($value)?" -f h ":""</code>
							</format>
							<vdef>
								<value>0</value>
							</vdef>
							<group>2</group>
							<precond>
								<language>perl</language>
								<code>!$compute_mr &amp;&amp; !$thorough_opt &amp;&amp; !$ancestral_states &amp;&amp; !$fast_tree &amp;&amp; !$mulparambootstrap_seed &amp;&amp; !$bootstrap_seed &amp;&amp; !$startingtreeonly &amp;&amp; !$bipartitions &amp;&amp; !$compute_ml_distances  &amp;&amp; !$specify_runs &amp;&amp; !$morpho_weight_calibration &amp;&amp; !$classify_into_reftree</code>
							</precond> 
							<ctrls>
								<ctrl>
									<message>To use the "compute a log likelihood test option" you must specify a file containing multiple trees with the "-z" option</message>
									<language>perl</language>
									<code>$log_likelihood &amp;&amp; !defined $bunchotops</code>
								</ctrl>
								<ctrl>
									<message>To use the "compute a log likelihood test option" you must specify a best tree with "-t"</message>
									<language>perl</language>
									<code>$log_likelihood &amp;&amp; !defined $bunchotops</code>
								</ctrl>
								<ctrl>
									<message>Sorry, you cannot compute a log likelihood test with GTRCAT models, please use "GTRGAMMA for the bootstrapping phase and GTRGAMMA for the final tree"</message>
									<language>perl</language>
									<code>($datatype eq "dna" || $datatype eq "rna" ) &amp;&amp; $log_likelihood &amp;&amp; $dna_gtrcat eq "GTRCAT"</code>
								</ctrl>
								
								<ctrl>
									<message>Sorry, you cannot compute a log likelihood test with GTRCAT models, please select PROTGAMMA for the model</message>
									<language>perl</language>
									<code>$datatype eq "protein" &amp;&amp; $log_likelihood &amp;&amp; $prot_sub_model eq "PROTCAT"</code>
								</ctrl>
								<ctrl>
									<message>Sorry, you cannot compute a log likelihood test with GTRCAT models, please select PROTGAMMA for the model</message>
									<language>perl</language>
									<code>$datatype eq "protein" &amp;&amp; $log_likelihood &amp;&amp; $prot_sub_model eq "PROTCAT"</code>
								</ctrl>
								<ctrl>
									<message>Sorry, you cannot compute a log likelihood test with GTRCAT models, please select BINGAMMA for the model</message>
									<language>perl</language>
									<code>$datatype eq "binary" &amp;&amp; $log_likelihood &amp;&amp; $bin_model eq "BINCAT"</code>
								</ctrl>
							</ctrls>
							<comment>
								<value>When this is specified,  RAxML will compute a log likelihood test (SH-test [21]) between a best tree passed via -t and a bunch of other trees passed via -z. Example: raxmlHPC -f h -t ref -z trees -s alg -m GTRGAMMA -n TEST</value>
							</comment>
						</attributes>
					</parameter>
<!-- -f T option:  create this command line:
	raxmlHPC -p 12345 -m WAG -s sequenceFileName -f T -t treeFileName -n outputFileName

According to the RaxML 8.0 manual, this is the optimization that is run at end of the fast bootstrap with ML 
search option (implemented by f -a) that is available in Cipres, but looking at the output from previous, unfinished runs, I assume that  is implemented, too.

-->
					<parameter type="Switch" >
						<name>thorough_opt</name>
						<attributes>
							<prompt>Do A Final Opimization of ML Tree (-f T)</prompt>
							<vdef>
								<value>0</value>
							</vdef>
							<precond>
								<language>perl</language>
								<code>!$compute_mr &amp;&amp; !$ancestral_states &amp;&amp; !$bipartitions &amp;&amp; !$fast_tree &amp;&amp; !$mulparambootstrap_seed &amp;&amp;!$bootstrap_seed &amp;&amp; !$startingtreeonly &amp;&amp; !$log_likelihood &amp;&amp; !$compute_ml_distances  &amp;&amp; !$specify_runs &amp;&amp; !$morpho_weight_calibration &amp;&amp; !$classify_into_reftree</code>
							</precond>
							<group>2</group>
							<format>
								<language>perl</language>
								<code>($value)?" -f T ":""</code>
							</format>
							<ctrls>
								<ctrl>
									<message>You must specify a tree (via the -t option above) to use the -f T option</message>
									<language>perl</language>
									<code>$thorough_opt &amp;&amp; !defined $treetop</code>
								</ctrl>
								<ctrl>
									<message>Sorry, you cant use the -f T option with the high memory option</message>
									<language>perl</language>
									<code>$thorough_opt &amp;&amp; $more_memory</code>
								</ctrl>
							</ctrls>
							<comment>
								<value>The -f T option allows the user to do a more thorough tree search that uses the 
									less lazy, i.e. more exhaustive SPR moves, in a stand alone mode. This algorithm is typically executed in the very end of a search done by -f a.</value>
							</comment>
						</attributes>
					</parameter>
					
<!-- -j option j
Specifies that intermediate tree files shall be written to file during the standard ML and BS tree searches.
DEFAULT: OFF

This will simply print out a couple of intermediate trees during the tree search and not the
final tree only. The intermediate trees are written to files called: RAxML_checkpoint.TEST.0, RAxML_checkpoint.TEST.1, etc.
-->
					<parameter type="Switch" >
						<name>intermediate_treefiles</name>
						<attributes>
							<prompt>Write intermediate tree files to a file (-j)</prompt>
							<vdef>
								<value>0</value>
							</vdef>
							<precond>
								<language>perl</language>
								<code>!$compute_mr &amp;&amp; !$ancestral_states &amp;&amp; !$bipartitions &amp;&amp; !$fast_tree &amp;&amp; !$startingtreeonly &amp;&amp; !$log_likelihood &amp;&amp; !$compute_ml_distances &amp;&amp; !$morpho_weight_calibration &amp;&amp; !$classify_into_reftree</code>
							</precond>
							<group>2</group>
							<format>
								<language>perl</language>
								<code>($value)?" -j ":""</code>
							</format>
							<comment>
								<value>This will simply print out a couple of intermediate trees during the tree search and not the
final tree only. The intermediate trees are written to files called: RAxML_checkpoint.TEST.0, RAxML_checkpoint.TEST.1, etc.</value>
							</comment>
						</attributes>
					</parameter>

<!-- -D option  = ML search convergence criterion. This will break off ML searches if the
relative RobinsonFoulds distance between the trees obtained from two consecutive lazy SPR cycles
is smaller or equal to 1%. Usage recommended for very large datasets in terms of taxa. On trees
with more than 500 taxa this will yield execution time improvements of approximately 50% while yielding
only slightly worse trees.

DEFAULT: OFF
	
When enabling this option, RAxML will stop ML and standard, slow bootstrap searches early,
when the RF distance between the trees generated by two consecutive cycles of SPR
(Subtree Pruning Re-Grafting) moves is smaller than 1%. This leads to substantial speed
improvements while the decrease in log likelihood scores is only very small. The option has
been tested on several datasets and the results have been included in the following book
chapter:
A. Stamatakis: "Phylogenetic Search Algorithms for Maximum Likelihood". In M. Elloumi,
A.Y. Zomaya, editors. Algorithms in Computational Biology: techniques, Approaches and
Applications, 547-577, John Wiley and Sons, 2011.
-->	
					<parameter type="Switch" >
						<name>convergence_criterion</name>
						<attributes>
							<prompt>Use ML search convergence criterion. (-D)</prompt>
							<vdef>
								<value>0</value>
							</vdef>
							<precond>
								<language>perl</language>
								<code>!$compute_mr &amp;&amp; !$ancestral_states &amp;&amp; !$bipartitions &amp;&amp; !$startingtreeonly &amp;&amp; !$log_likelihood &amp;&amp; !$compute_ml_distances  &amp;&amp; !$specify_runs &amp;&amp; !$morpho_weight_calibration &amp;&amp; !$classify_into_reftree</code>
							</precond>
							<group>2</group>
							<format>
								<language>perl</language>
								<code>($value)?" -D ":""</code>
							</format>
							<ctrls>
								<ctrl>
									<message>The tree search convergence criterion "-D" has no effect in conjunction with the:  "-x" or "-f a" options.</message>
									<language>perl</language>
									<code>$value &amp;&amp; $bootstrap_seed </code>
								</ctrl>
							</ctrls>
							<comment>
								<value>-D option  = ML search convergence criterion. This will break off ML searches if the
relative RobinsonFoulds distance between the trees obtained from two consecutive lazy SPR cycles
is smaller or equal to 1%. Usage recommended for very large datasets in terms of taxa. On trees
with more than 500 taxa this will yield execution time improvements of approximately 50% while yielding
only slightly worse trees.</value>
							</comment>
						</attributes>
					</parameter>				
					
<!-- 	[-J MR|MRE] Compute majority rule consensus tree with "-J MR" or extended majority rule consensus tree with "-J MRE"
                You will need to provide a tree file containing several trees via "-z"-->
                	<parameter type="Switch" >
						<name>compute_mr</name>
						<attributes>
							<prompt>Compute majority rule consensus tree  (-J)</prompt>
							<precond>
								<language>perl</language>
								<code>($dna_gtrcat eq "GTRGAMMA" || $prot_sub_model eq "PROTGAMMA" || $bin_model eq "BINGAMMA" || $multi_model eq "MULTIGAMMA" ) &amp;&amp; !$compute_ml_distances &amp;&amp; !$thorough_opt &amp;&amp; !$ancestral_states &amp;&amp; !$fast_tree &amp;&amp; !$mulparambootstrap_seed &amp;&amp; !$bootstrap_seed &amp;&amp; !$bipartitions &amp;&amp; !$startingtreeonly &amp;&amp; !$log_likelihood  &amp;&amp; !$specify_runs &amp;&amp; !$morpho_weight_calibration &amp;&amp; !$classify_into_reftree</code>
							</precond>
							<vdef>
								<value>0</value>
							</vdef>
			<!--				<ctrls>
								<ctrl>
									<message>Sorry, this option can only be used if the data type is a Collection of Trees</message>
									<language>perl</language>
									<code>$compute_mr &amp;&amp; $datatype ne "trees"</code>
								</ctrl>
							</ctrls> -->
							<comment>
								<value>This option allows the user to compute majority rule consensus tree or extended majority rule consensus tree from an uploaded file containing several trees (-z)</value>
							</comment>
						</attributes>
					</parameter>
                
 					<parameter type="Excl" ismandatory="1">
						<name>specify_mr</name>
						<attributes>
							<prompt>Specify majority rule consensus tree (-J) technique </prompt>
							<precond>
								<language>perl</language>
								<code>$compute_mr</code>
							</precond>								
							<format>
								<language>perl</language>
								<code>"-J $value"</code>
							</format>
							<vlist>
								<value>MR</value>
								<label>Majority rule</label>
								<value>MRE</value>
								<label>Extended majority rule</label>
								<value>STRICT</value>
								<label>Strict Majority</label>
								<value>MR_DROP</value>
								<label>MR_Drop</label>
								<value>STRICT_DROP</value>
								<label>Strict_Drop</label>
							</vlist>
							<vdef>
								<value>MR</value>
							</vdef>
							<ctrls>
								<ctrl>
									<message>Please select a majority rule option</message>
									<language>perl</language>
									<code>!$specify_mr</code>
								</ctrl>
							</ctrls>
							<comment>
<value>You must use a collection of trees as your input file for this option. The option lets you compute a majority rule consensus tree with "MR" or extended majority rule consensus tree with "J
MRE" or strict consensus tree with "J STRICT". Options "J STRICT_DROP" and "J MR_DROP" will execute an algorithm that identifies dropsets which contain rogue taxa as proposed by Pattengale et
al. in the paper "Uncovering hidden phylogenetic consensus". 
</value>
								</comment>
						</attributes>
					</parameter>	
					
						
	<!-- added for jbmunro -->
					<parameter type="InFile">
						<name>bunchotops</name>
						<attributes>
							<prompt>File with topologies for bipartitions or bootstopping (-z)</prompt>
								<format>
									<language>perl</language>
									<code>" -z topologies_file.tre"</code>
								</format>
							<group>2</group>
							<filenames>topologies_file.tre</filenames>
							<precond>
								<language>perl</language>
								<code>($bipartitions || $log_likelihood) &amp;&amp; !defined $apo_tops</code>
							</precond>
	<!--						<ctrls>
								<ctrl>
									<message>You must specify a starting tree (via the -t option above) to use the -z option</message>
									<language>perl</language>
									<code>$bunchotops &amp;&amp; !defined $treetop</code>
								</ctrl>
							</ctrls> -->
							<comment>
<value>The -z option is used in combination with the -f b,-f h,-f m,-f n options. The uploaded file should contain a number of trees in NEWICK format. The file should contain one tree per line without blank lines between trees. For example, you can directly read in a RAxML bootstrap result file.</value>
							</comment>
						</attributes>
					</parameter>
					
<!--	  "-f x":	compute pair-wise ML distances, ML model parameters will be estimated on an MP starting tree or a user-defined tree passed via "-t"-->
					<parameter type="Switch" ismandatory="1">
						<name>compute_ml_distances</name>
						<attributes>
							<prompt>Compute pair-wise ML distances (-f x; GAMMA models only)</prompt>
							<vdef>
								<value>0</value>
							</vdef>
							<precond>
								<language>perl</language>
								<code>!$compute_mr &amp;&amp; !$thorough_opt &amp;&amp; !$ancestral_states &amp;&amp; !$fast_tree &amp;&amp; !$mulparambootstrap_seed &amp;&amp; !$bootstrap_seed &amp;&amp; !$bipartitions &amp;&amp; !$startingtreeonly &amp;&amp; !$log_likelihood  &amp;&amp; !$specify_runs &amp;&amp; !$morpho_weight_calibration &amp;&amp; !$classify_into_reftree</code>
							</precond>
							<format>
								<language>perl</language>
								<code> ($value)?" -f x ":""</code>
							</format>
							<ctrls>
<!-- This isnt really required  							<ctrl>
									<message>You must specify a starting tree (via the -t option above) to use the -f x option</message>
									<language>perl</language>
									<code>$compute_ml_distances &amp;&amp; ! defined $treetop</code>
								</ctrl> -->
								<ctrl>
									<message>Sorry, the -f x option is valid only with GAMMA models</message>
									<language>perl</language>
									<code>$compute_ml_distances &amp;&amp; $dna_gtrcat ne "GTRGAMMA"</code>
								</ctrl>
							</ctrls>
							<comment>
								<value>Compute pair-wise ML distances, ML model parameters will be estimated on an MP starting tree or a user-defined tree passed via "-t".</value>
							</comment>
						</attributes>
					</parameter>
					
<!-- add the fast tree (experimental) option -->					
					<parameter type="Switch" ismandatory="1">
						<name>fast_tree</name>
						<attributes>
							<prompt>Run very fast experimental tree search(-f E)</prompt>
							<vdef>
								<value>0</value>
							</vdef>
							<precond>
								<language>perl</language>
								<code>!$compute_mr &amp;&amp; !$thorough_opt &amp;&amp; !$ancestral_states &amp;&amp; !$compute_ml_distances &amp;&amp; !$mulparambootstrap_seed &amp;&amp; !$bootstrap_seed &amp;&amp; !$bipartitions &amp;&amp; !$startingtreeonly &amp;&amp; !$log_likelihood  &amp;&amp; !$specify_runs &amp;&amp; !$morpho_weight_calibration &amp;&amp; !$classify_into_reftree</code>
							</precond>
							<format>
								<language>perl</language>
								<code> ($value)?" -f E ":""</code>
							</format>
							<warns>
								<warn>
									<message>Any constraint trees will be ignored</message>
									<language>perl</language>
									<code>$fast_tree</code>
								</warn>
							</warns>
							<comment>
								<value>Compute pair-wise ML distances, ML model parameters will be estimated on an MP starting tree or a user-defined tree passed via "-t".</value>
							</comment>
						</attributes>
					</parameter>

<!--	  "-f u":	f u execute morphological weight calibration using maximum likelihood, this will
return a weight vector. you need to provide a morphological alignment and a reference tree via -t -->
					<parameter type="Switch" ismandatory="1">
						<name>morpho_weight_calibration</name>
						<attributes>
							<prompt>Execute morphological weight calibration using maximum likelihood (-f u)</prompt>
							<vdef>
								<value>0</value>
							</vdef>
							<precond>
								<language>perl</language>
								<code>($datatype eq "binary" || $datatype eq "multi")&amp;&amp;(!$classify_into_reftree &amp;&amp; !$thorough_opt &amp;&amp; !$ancestral_states &amp;&amp; !$fast_tree &amp;&amp; !$mulparambootstrap_seed &amp;&amp; !$bootstrap_seed &amp;&amp; !$bipartitions &amp;&amp; !$startingtreeonly &amp;&amp; !$log_likelihood) &amp;&amp; !$compute_mr </code>
							</precond>
							<format>
								<language>perl</language>
								<code> ($value)?" -f u ":""</code>
							</format>
							<ctrls>
								<ctrl>
									<message>You must specify a starting tree (via the -t option above) to use the -f x option</message>
									<language>perl</language>
									<code>$morpho_weight_calibration &amp;&amp; !defined $treetop</code>
								</ctrl>
							</ctrls>
							<comment>
<value>This option will determine to which degree the sites of a morphological alignment are
congruent with a given molecular reference tree. As output it will generate a RAxML weight
file that reflects the degree of congruence and that can be subsequently read via the a
option to conduct a more informed evolutionary placement of fossils using the evolutionary
placement algorithm (f -v option). For more details, see the corresponding papers:
Evolutionary placement http://sysbio.oxfordjournals.org/content/60/3/291.short
Fossil calibration http://sco.h-its.org/exelixis/pubs/Exelixis-RRDR-2009-1.pdf</value>
							</comment>
						</attributes>
					</parameter>
					
<!--	  -f v classify a bunch of environmental sequences into a reference tree using
thorough read insertions you will need to start RAxML with a noncomprehensive
reference tree and an alignment containing all sequences
(reference + query) -->
					<parameter type="Switch" ismandatory="1">
						<name>classify_into_reftree</name>
						<attributes>
							<prompt>Classify a bunch of environmental sequences into a reference tree using
thorough read insertions(-f v)</prompt>
							<vdef>
								<value>0</value>
							</vdef>
							<precond>
								<language>perl</language>
								<code>!$compute_mr &amp;&amp; !$morpho_weight_calibration &amp;&amp; !$thorough_opt &amp;&amp; !$ancestral_states &amp;&amp; !$fast_tree &amp;&amp; !$mulparambootstrap_seed &amp;&amp; !$bootstrap_seed &amp;&amp; !$bipartitions &amp;&amp; !$startingtreeonly &amp;&amp; !$log_likelihood  &amp;&amp; !$specify_runs</code>
							</precond>
							<format>
								<language>perl</language>
								<code> ($value)?" -f v ":""</code>
							</format>
							<ctrls>
								<ctrl>
									<message>You must specify a starting tree (via the -t option above) to use the -f x option</message>
									<language>perl</language>
									<code>$classify_into_reftree &amp;&amp; !defined $treetop</code>
								</ctrl>
							</ctrls>
							<comment>
<value>Classify a bunch of environmental sequences into a reference tree using thorough read insertions you will need to start RAxML with a noncomprehensive
reference tree and an alignment containing all sequences (reference + query) For details on the design and performance of this algorithm, see: http://sysbio.oxfordjournals.org/content/60/3/291.short.
RAxML will produce a couple of idiosyncratic output files for the placements, but also an output file according to the common file standard defined by Erick Matsen for his pplacer(see http://matsen.fhcrc.org/pplacer/) program that is similar to the EPA (Evolutionary
Placement Algorithm) and myself. The common file format is described in this paper here:
http://www.plosone.org/article/info %3Adoi%2F10.1371%2Fjournal.pone.0031009</value>
							</comment>
						</attributes>
					</parameter>					
					
<!--  	We arent supporting this in the browser interface currently. I replaced some double dashes (not alloed in comments) with -*
be sure to catch those before implementing. -->

<!--				<parameter  type="String">
                        <name>generic</name>
                        <attributes>
                            <prompt>Additional RAxML  options (advanced users only)</prompt>
                            <format>
                                <language>perl</language>
                                <code>"$value"</code>
                            </format>
                            <group>99</group>
							<ctrls>
								<ctrl>
									<message>Additional RAxML options: You must specify each argument separately, with a - or -*.</message>
									<language>perl</language> -->
									<!-- don't use !~, there's something wrong with the way we translate it to javascript in pise2JavaScriptControl.ftl. -->
	<!--								<code> 
  								!($value =~ /^\s*$/ ) &amp;&amp;  
									!($value =~ /^((((-[A-Za-z0-9])(\s+([A-Za-z0-9,_\.][A-Za-z0-9,_\.\-]*))?)|(-*\S+))\s+)*(((-[A-Za-z0-9])(\s+([A-Za-z0-9,_\.][A-Za-z0-9,_\.\-]*))?)|(-*\S+))\s*$/ ) 
									</code>
								</ctrl>
								<ctrl>
									<message>Sorry, additional RAxML options: -T and -w are not allowed. </message>
									<language>perl</language>
									<code> ($value =~ /^(-w)|(\s+-w)/ ) or ($value =~ /^(-T)|(\s+-T)/ ) </code>
								</ctrl>
							</ctrls>
							<comment>
							<value>This option is meant to allow users to run command line strings that are not currently supported explicitly by the interface</value>
							</comment>
                        </attributes>
                    </parameter>
					-->

				</parameters>
			</paragraph>
		</parameter>

	<!-- under development for large DS -->
	<!-- 	[-D]													ML search convergence criterion. This will break off ML searches if the relative Robinson-Foulds distance
		large trees													between the trees obtained from two consecutive lazy SPR cycles is smaller or equal to 1%. Usage recommended
															for very large datasets in terms of taxa. On trees with more than 500 taxa this will yield execution time improvements
															of approximately 50% while yielding only slightly worse trees.
															DEFAULT: OFF -->
	<!-- 
	[-F]													enable ML tree searches under CAT model for very large trees without switching to GAMMA in the end (saves memory) and print out some additional files
			(large trees)									with intermediate trees from the search.	This option can also be used with the GAMMA models in order to avoid the thorough optimization  of the best-scoring
															ML tree in the end.
															DEFAULT: OFF-->	
	<!-- 
	[-L sequenceSimilarityThreshold]     	Same functionality as "-l" above, but uses a less exhaustive and thus faster clustering algorithm. This is intended for very large datasets with more than 	
			(large data sets)						20,000-30,000 sequences
															DEFAULT: OFF-->
	<!-- -->
	
		<parameter type="Paragraph">
			<paragraph>
				<name>bootstrap_config</name>
				<prompt>Configure Bootstrapping</prompt>
				<parameters>
					<!--add for jbmunro-->
					<!-- I split the seeds  into invocation, and number entry, due to command line conflicts -->
					<parameter type="Switch" ismandatory="1">
						<name>mulparambootstrap_seed</name>
						<attributes>
							<prompt>Conduct Multiparametric Bootstrapping? (-b)</prompt>
							<vdef>
								<value>0</value>
							</vdef>
							<precond>
								<language>perl</language>
								<code>!$compute_mr &amp;&amp; !$thorough_opt &amp;&amp; !$ancestral_states &amp;&amp; !$fast_tree &amp;&amp; !$bootstrap_seed &amp;&amp; !$startingtreeonly &amp;&amp; !$compute_ml_distances &amp;&amp; !$bipartitions &amp;&amp; !$log_likelihood &amp;&amp; !$compute_mr  &amp;&amp; !$specify_runs</code>
							</precond>
							<comment>
								<value>This option allows you to turn on non-parametric bootstrapping. To allow for reproducibility of runs in the sequential program, you have to specify a random number seed. 
</value>
							</comment>
						</attributes>
					</parameter>
					
					<parameter type="Integer" ismandatory="1">
						<name>mulparambootstrap_seed_val</name>
						<attributes>
							<prompt>Enter a random seed value for multi-parametric bootstrapping</prompt>
							<format>
								<language>perl</language>
								<code>($value) ? " -b $value" : ""</code>
							</format>
							<vdef>
								<value>12345</value>
							</vdef>
							<precond>
								<language>perl</language>
								<code>$mulparambootstrap_seed</code>
							</precond>
							<group>2</group>
							<ctrls>
								<ctrl>
									<message>Please enter a random seed for the -b option (eg 12345)</message>
									<language>perl</language>
									<code>$mulparambootstrap_seed &amp;&amp; !defined $mulparambootstrap_seed_val</code>
								</ctrl>
							</ctrls>
							<comment>
								<value>This random number is provided to assure that there is comparability between runs.</value>
							</comment>
						</attributes>
					</parameter>
					<!--add for jbmunro-->
					<!-- I split the seeds  into invocation, and number entry, due to command line conflicts -->
					
					<parameter type="Switch">
						<name>bootstrap_seed</name>
						<attributes>
							<prompt>Conduct rapid bootstrapping? (-x)</prompt>
							<vdef>
								<value>1</value>
							</vdef>
							<precond>
								<language>perl</language>
								<code>!$compute_mr &amp;&amp; !$thorough_opt &amp;&amp; !$ancestral_states &amp;&amp; !$fast_tree &amp;&amp; !$mulparambootstrap_seed  &amp;&amp; !$startingtreeonly &amp;&amp; !$compute_ml_distances &amp;&amp; !$bipartitions &amp;&amp; !$log_likelihood &amp;&amp; !$compute_mr  &amp;&amp; !$specify_runs</code>
							</precond>
							<comment>
								<value>This option offers a novel rapid Bootstrapping algorithm that is faster by at least one order of magnitude than all other current implementations (RAxML 2.2.3, GARLI, PHYML). The results obtained are qualitatively comparable to those obtained via the standard RAxML BS algorithm and, more importantly, the deviations in support values between the rapid and the standard RAxML BS algorithm are smaller than those induced by using a different search strategy, e.g. GARLI or PHYML. This rapid BS search can be combined with a rapid ML search on the original alignment and thus allows users to conduct a full ML analysis within one single program run.</value>
							</comment>
						</attributes>
					</parameter>

					<parameter type="Integer" ismandatory="1">
						<name>bootstrap_seed_val</name>
						<attributes>
							<prompt>Enter a random seed value for rapid bootstrapping</prompt>
							<format>
								<language>perl</language>
								<code>($value) ? " -x $value" : ""</code>
							</format>
							<vdef>
								<value>12345</value>
							</vdef>
							<group>2</group>
							<precond>
								<language>perl</language>
								<code>$bootstrap_seed &amp;&amp; !$mulparambootstrap_seed  &amp;&amp; !$startingtreeonly &amp;&amp; !$compute_ml_distances</code>
							</precond>
							<ctrls>
								<ctrl>
									<message>Please enter a random seed for the -x option (eg 12345)</message>
									<language>perl</language>
									<code>$bootstrap_seed &amp;&amp; !defined $bootstrap_seed_val</code>
								</ctrl>
							</ctrls>
							<comment>
<value>This random number is provided to assure that there is comparability between runs.</value>
							</comment>
						</attributes>
					</parameter>
					<!-- rev 6 -->
					<!-- Do maximum likelihood search after bootstrap -->

					<parameter type="Switch">
						<name>mlsearch</name>
						<attributes>
							<prompt>Conduct a rapid Bootstrap analysis and search for the best-scoring ML tree in one single program run. (-f a)</prompt>
							<format>
								<language>perl</language>
								<code> ($value)?" -f a ":""</code>
							</format>
							<vdef>
								<value>1</value>
							</vdef>
							<group>2</group>
							<comment>
								<value>Conduct a Rapid Bootstrap analysis (-x) and search for the best-scoring ML tree in one single program run.
								</value>
							</comment>
							<precond>
								<language>perl</language>
								<code>!$compute_mr &amp;&amp; !$thorough_opt &amp;&amp; !$ancestral_states &amp;&amp; !$fast_tree &amp;&amp; !$bipartitions &amp;&amp; !$startingtreeonly &amp;&amp; $bootstrap_seed &amp;&amp; !$compute_ml_distances</code>
							</precond>
						</attributes>
					</parameter>
					
<!-- 	[-k] 		Specifies that bootstrapped trees should be printed with branch lengths. The bootstraps will run a bit longer, because model parameters will be optimized at 
					the end of each run under GAMMA or GAMMA+P-Invar respectively. DEFAULT: OFF (old version said Use with CATMIX/PROTMIX or GAMMA/GAMMAI., check on this)-->

					<parameter type="Switch">
						<name>printbrlength</name>
						<attributes>
							<prompt>Print branch lengths (-k)</prompt>
							<format>
								<language>perl</language>
								<code> ($value)?" -k":""</code>
							</format>
							<vdef>
								<value>0</value>
							</vdef>
							<group>2</group>
							<comment>
								<value>	The -k option causes bootstrapped trees to be printed with branch lengths. 
The bootstraps will require a bit longer to run under this option because model parameters will be optimized at 
					the end of each run under GAMMA or GAMMA+P-Invar respectively.
								</value>
							</comment>
						</attributes>
					</parameter>
					
					
<!--	I replaced this with a split inference, so the parsimony tree alone will work ok.  
				<parameter type="Integer" ismandatory="1">
						<name>parsimony_seed_val</name>
						<attributes>
							<prompt>Specify a random number seed for the parsimony inferences.</prompt>
							<format>
								<language>perl</language>
								<code>"-p $value"</code>
							</format>
							<vdef>
								<value>12345</value>
							</vdef>
							<group>2</group>
							<comment>
								<value>A Maximum Parsimony starting tree is constructed if no user-defined tree is provided. This random number is provided to assure that there is comparability between runs by keeping a consistent starting tree.
</value>
							</comment>
						</attributes>
					</parameter> -->
					
					<!-- rev 6 -->
					<!-- Bootstrap iterations, either 100 or auto -->
					<!-- I split the seeds  into invocation, and number entry, due to command line conflicts -->
					<parameter type="Switch" ismandatory="1">
						<name>specify_bootstraps</name>
						<attributes>
							<prompt>Specify an Explicit Number of Bootstraps</prompt>
							<vdef>
								<value>1</value>
							</vdef>
							<precond>
								<language>perl</language>
								<code>($bootstrap_seed || $mulparambootstrap_seed) &amp;&amp; (!defined $use_bootstopping || !$use_bootstopping)</code>
							</precond>
						</attributes>
					</parameter>

					<parameter type="Integer" ismandatory="1">
						<name>bootstop</name>
						<attributes>
							<prompt>Bootstrap iterations (-#|-N)</prompt>
							<precond>
								<language>perl</language>
								<code>($bootstrap_seed || $mulparambootstrap_seed) &amp;&amp; !$use_bootstopping &amp;&amp; !$startingtreeonly</code>
							</precond>
							<format>
								<language>perl</language>
<!-- replaced -# with -N for TG -->
								<code>" -N $value"</code>
							</format>
							<vdef>
								<value>100</value>
							</vdef>
							<group>2</group>
							<ctrls>
								<ctrl>
									<message>Please enter number of bootstrap reps desired (eg 100)</message>
									<language>perl</language>
									<code>$specify_bootstraps &amp;&amp; !defined $bootstop</code>
								</ctrl>
<!-- bootstraps must be less than or equal to 1000 -->
								<ctrl>
									<message>Sorry, the value of bootstraps cannot exceed 1,000</message>
									<language>perl</language>
									<code>$bootstop &gt; 1000</code>
								</ctrl>	
							</ctrls>
							<comment>
								<value>Specifies the number of alternative runs on distinct starting trees. If 10, RAxML computes 10 distinct ML trees starting from 10 distinct randomized maximum parsimony starting trees. In combination with the Random seed for rapid bootstrap (-x) invoke a rapid BS analysis.
</value>
							</comment>
						</attributes>
					</parameter>

<!-- Activate programmatic bootstopping -->					
					<parameter type="Switch" ismandatory="1">
						<name>use_bootstopping</name>
						<attributes>
							<prompt>Let RAxML halt bootstrapping automatically</prompt>
							<precond>
								<language>perl</language>
								<code>($bootstrap_seed || $mulparambootstrap_seed) &amp;&amp; (!defined $specify_bootstraps || !$specify_bootstraps)</code>
							</precond>
							<vdef>
								<value>0</value>
							</vdef>
							<ctrls>
								<ctrl>
									<message>Please select to "specify bootstraps explicitly" or "automatically halt bootstrapping"</message>
									<language>perl</language>
									<code> ($bootstrap_seed || $mulparambootstrap_seed) &amp;&amp; (!$use_bootstopping  &amp;&amp; !$specify_bootstraps)</code>
								</ctrl>
<!--  								<ctrl>
									<message>Sorry, you can not use a constraint tree with automatic boot stopping</message>
									<language>perl</language>
									<code>$use_bootstopping &amp;&amp; defined $constraint</code>
								</ctrl> -->
							</ctrls>
							<comment>
<value>This option instructs Raxml to automatically halt bootstrapping when certain criteria are met, instead of specifying the number of bootstraps for an analysis. The exact criteria are specified/configured using subsequent entry fields.</value>
							</comment>
						</attributes>
					</parameter>

<!--                    <parameter type="Excl" ismandatory="1">
						<name>select_bootstopping</name>
						<attributes>
							<prompt>Select Bootstopping Strategy</prompt>
							<vdef>
								<value>otf_bootstopping</value>
							</vdef>
							<vlist>
								<value>otf_bootstopping</value>
								<label>On-the-fly Bootstopping</label>
								<value>apo_bootstopping</value>
								<label>A posteriori bootstrapping</label>
							</vlist>	
							<precond>
								<language>perl</language>
								<code>($bootstrap_seed || $mulparambootstrap_seed) &amp;&amp; !$specify_bootstraps</code>
							</precond>
							<ctrls>
								<ctrl>
									<message>Please choose either on-the-fly or a posteriori bootstrapping</message>
									<language>perl</language>
									<code>$use_bootstopping &amp;&amp; ($select_bootstopping ne "otf_bootstopping" &amp;&amp; $select_bootstopping ne  "apo_bootstopping")</code>
								</ctrl>
							</ctrls>
							<comment>
<value>This option allows the user to let Raxml "decide" whether bootstrapping is stopped (i.e. "bootstopping") by criteria determined "on-the-fly" or based on a set of bootstrapped trees uploaded as a single file using the -z option.  Once this selection is made, the user must select whether the bootstopping threshold is determined using frequency criteria or majority rule criteria</value>
							</comment>						
						</attributes>
					</parameter>  -->
					
<!--	  [-#|-N numberOfRuns|autoFC|autoMR|autoMRE|autoMRE_IGN] Specify the number of alternative runs on distinct starting trees
              In combination with the "-b" option, this will invoke a multiple bootstrap analysis
              Note that "-N" has been added as an alternative since "-#" sometimes caused problems
              with certain MPI job submission systems, since "-#" is often used to start comments.

              If you want to use the bootstopping criteria specify "-# autoMR" or "-# autoMRE" or "-# autoMRE_IGN"
              for the majority-rule tree based criteria (see -I option) or "-# autoFC" for the frequency-based criterion.
              Bootstopping will only work in combination with "-x" or "-b"
              DEFAULT: 1 single analysis -->
              					
					<parameter type="Switch" ismandatory="1">
						<name>freq_bootstopping</name>
						<attributes>
							<prompt>Stop Bootstrapping Automatically with Frequency Criterion</prompt>
							<precond>
								<language>perl</language>
								<code>$use_bootstopping &amp;&amp; !$mr_bootstopping</code>
							</precond>										
							<format>
								<language>perl</language> 
					<!-- Replace -# with -N -->
								<code>($value) ? "-N autoFC":""</code>
							</format>
							<vdef>
								<value>0</value>
							</vdef>
							<ctrls>
								<ctrl>
									<message>Please choose either majority rule or frequency criterion</message>
									<language>perl</language>
									<code>$use_bootstopping  &amp;&amp; ( !$mr_bootstopping &amp;&amp; !$freq_bootstopping )</code>
								</ctrl>
							</ctrls>
							<comment>
<value>If you want to use the bootstopping criteria specify "-# autoMR" or "-# autoMRE" or "-# autoMRE_IGN" for the majority-rule tree based criteria (see -I option) or "-# autoFC" for the frequency-based criterion. Bootstopping will only work in combination with "-x" or "-b"</value>
							</comment>
						</attributes>
					</parameter>
					
					<parameter type="Switch" >
						<name>mr_bootstopping</name>
						<attributes>
							<prompt>Stop Bootstrapping Automatically with Majority Rule Criterion (recommended)</prompt>
							<precond>
								<language>perl</language>
								<code>$use_bootstopping &amp;&amp; !$freq_bootstopping </code>
							</precond>
							<vdef>
								<value>1</value>
							</vdef>
							<ctrls>
								<ctrl>
									<message>Please choose either majority rule or frequency criterion</message>
									<language>perl</language>
									<code>$use_bootstopping &amp;&amp; (!$mr_bootstopping &amp;&amp; !$freq_bootstopping) </code>
								</ctrl>
							</ctrls>
							<comment>
<value>If you want to use the bootstopping criteria specify "-# autoMR" or "-# autoMRE" or "-# autoMRE_IGN" for the majority-rule tree based criteria (see -I option) or "-# autoFC" for the frequency-based criterion. Bootstopping will only work in combination with "-x" or "-b"</value>
							</comment>
						</attributes>
					</parameter>
					
					<parameter type="Excl" ismandatory="1">
						<name>mrbootstopping_type</name>
						<attributes>
							<prompt>Select Majority Rule Criterion: (autoMRE is recommended)</prompt>
							<precond>
								<language>perl</language>
								<code>$mr_bootstopping</code>	
							</precond>													
							<format>
								<language>perl</language>
<!--replace -# with -N -->
								<code>"-N $value"</code>
							</format>
							<vlist>
								<value>autoMR</value>
								<label>autoMR</label>
								<value>autoMRE</value>
								<label>autoMRE</label>
								<value>autoMRE_IGN</value>
								<label>autoMRE_IGN</label>
							</vlist>
							<vdef>
								<value>autoMRE</value>
							</vdef>
							<ctrls>
								<ctrl>
									<message>Please choose a Majority Rule criterion</message>
									<language>perl</language>
									<code>$mr_bootstopping  &amp;&amp; !defined $mrbootstopping_type</code>
								</ctrl>
							</ctrls>
						</attributes>
					</parameter> 
					
<!-- The  [-B wcCriterionThreshold]	 feature is eliminated in 7.2.3. Specify a floating point number between 0.0 and 1.0 that will be used as cutoff threshold for the WC bootstopping criterion. The recommended setting is 0.03. 7.2.0 DEFAULT: 0.03 (recommended empirically determined setting)   -->
										
<!-- This option is used when a bootstrap analysis is already completed. Upload an input file, a tree, and bootstrapped trees
	
		[-I autoFC|autoMR|autoMRE|autoMRE_IGN] a posteriori bootstopping analysis. Use:
             "-I autoFC" for the frequency-based criterion
             "-I autoMR" for the majority-rule consensus tree criterion
             "-I autoMRE" for the extended majority-rule consensus tree criterion
             "-I autoMRE_IGN" for metrics similar to MRE, but include bipartitions under the threshold whether they are compatible
             or not. This emulates MRE but is faster to compute. For any of these options, you also need to pass a tree file containing several bootstrap replicates via "-z" -->
                    <parameter type="Switch">
						<name>use_apobootstopping</name>
						<attributes>
							<prompt>Use a posteriori bootstrapping</prompt>
							<vdef>
								<value>0</value>
							</vdef>	
							<precond>
								<language>perl</language>
								<code>!$use_bootstopping</code>	
							</precond>
							<ctrls>
								<ctrl>
									<message>Sorry, you cannot use a posteriori bootstrapping with the -b or -x options</message>
									<language>perl</language>
									<code>$use_apobootstopping &amp;&amp; ($bootstrap_seed || $mulparambootstrap_seed)</code>
								</ctrl>
							</ctrls>
							<comment>
<value>This option is used when a bootstrap analysis is already completed. Upload an input file, a tree, and bootstrapped trees. You must upload a set of bootstrapped trees uploaded as a single file using the -z option.  Once this selection is made, the user must select whether the bootstopping threshold is determined using frequency criteria or majority rule criteria</value>
							</comment>						
						</attributes>
					</parameter>
					
<!-- a priori bootstopping (-I) is mutually exclusive with on the fly bootstopping (-N) -->	
					<parameter type="Excl" ismandatory="1">
						<name>aposterior_bootstopping</name>
						<attributes>
							<prompt>Select the criterion for a posteriori bootstrapping analysis</prompt>
							<precond>
								<language>perl</language>
								<code>$use_apobootstopping</code>
							</precond>								
							<format>
								<language>perl</language>
								<code>"-I $value"</code>
							</format>
							<vlist>
								<value>autoFC</value>
								<label>autoFC</label>
								<value>autoMR</value>
								<label>autoMR</label>
								<value>autoMRE</value>
								<label>autoMRE</label>
								<value>autoMRE_IGN</value>
								<label>autoMRE_IGN</label>
							</vlist>
							<ctrls>
								<ctrl>
									<message>In order to use the a posteriori bootstrapping option, you must upload a set of bootstrapped trees below</message>
									<language>perl</language>
									<code>!defined $apo_tops</code>
								</ctrl>
							</ctrls>
								<comment>
<value>This option allows the user to conduct a posteriori bootstopping analysis based on a set of bootstrapped trees. Use: autoFC for the frequency-based criterion, autoMR for the majority-rule consensus tree criterion, autoMRE for the extended majority-rule consensus tree criterion
and autoMRE_IGN for metrics similar to MRE, but include bipartitions under the threshold whether they are compatible or not. This emulates MRE but is faster to compute. For any of these options, you also need to upload a tree file containing several bootstrap replicates via "-z"</value>
								</comment>
						</attributes>
					</parameter>
					
					<parameter type="InFile">
						<name>apo_tops</name>
						<attributes>
							<prompt>File with topologies for a posteriori bootstopping (-z)</prompt>
								<format>
									<language>perl</language>
									<code>" -z apotopologies_file.tre"</code>
								</format>
							<group>2</group>
							<filenames>apotopologies_file.tre</filenames>
							<precond>
								<language>perl</language>
								<code>$use_apobootstopping &amp;&amp; !defined $bunchotops</code>
							</precond>
							<comment>
<value></value>
							</comment>
						</attributes>
					</parameter>		
					
				</parameters>
			</paragraph>
		</parameter>
		
		<!-- When we're done with raxml, run consense on the bootstrapped trees to produce
		a file with a consense tree in "outtree".  A file named outfile is also produced
		by we don't want to return it to the user.
		-->
		<!--
		<parameter type="String" ishidden="1">
			<name>consense</name>
			<attributes>
				<group>99</group>
				<format>
					<language>perl</language>
					<code>
					"&amp;&amp; ( echo RAxML_bootstrap.result &gt; c.p; echo 1 &gt;&gt; c.p; echo 2 &gt;&gt; c.p; echo 3 &gt;&gt; c.p; echo Y &gt;&gt; c.p; consense &lt; c.p )"
					</code>
				</format>
				<precond>
					<language>perl</language>
					<code>!startingtreeonly</code>
				</precond>
			</attributes>
		</parameter>
		-->
		<!-- result of running consense -->
		<!--
		<parameter type="Results">
			<name>consense_output</name>
			<attributes>
				<filenames>outtree</filenames>
			</attributes>
		</parameter>
		-->
		<!-- return all output files from raxml in one big mess -->
		
	 	<parameter type="Results">
				<name>all_outputfiles</name>
				<attributes>
					<filenames>*</filenames>
				</attributes>
			</parameter>		
		
	<!-- 	<parameter type="Results">
			<name>outputfile</name>
			<attributes>
				<filenames>*.result</filenames>
			</attributes>
		</parameter>
		<parameter type="Results">
			<name>all_commandline</name>
			<attributes>
				<filenames>COMMANDLINE</filenames>
			</attributes>
		</parameter>
		<parameter type="Results">
			<name>all_excludeFile</name>
			<attributes>
				<filenames>*.excl</filenames>
			</attributes>
		</parameter>
		<parameter type="OutFile">
			<name>results_files</name>
			<attributes>
				<filenames>RAxML_log.result</filenames>
			</attributes>
		</parameter>
		<parameter type="OutFile">
			<name>outresult</name>
			<attributes>
				<filenames>RAxML_result.result</filenames>
			</attributes>
		</parameter>
		<parameter type="OutFile">
			<name>outinfo</name>
			<attributes>
				<filenames>RAxML_info.result</filenames>
			</attributes>
		</parameter>
		<parameter type="OutFile">
			<name>outparsimonytree</name>
			<attributes>
				<filenames>RAxML_parsimonyTree.result</filenames>
			</attributes>
		</parameter>
		<parameter type="OutFile">
			<name>outrandomtree</name>
			<attributes>
				<filenames>RAxML_randomTree.result</filenames>
			</attributes>
		</parameter>
		<parameter type="OutFile">
			<name>outcheckpoint</name>
			<attributes>
				<filenames>RAxML_checkpoint.result</filenames>
			</attributes>
		</parameter>
		<parameter type="OutFile">
			<name>outbootstrap</name>
			<attributes>
				<filenames>RAxML_bootstrap.result</filenames>
			</attributes>
		</parameter>
		<parameter type="OutFile">
			<name>outbipartitions</name>
			<attributes>
				<filenames>RAxML_bipartitions.result</filenames>
			</attributes>
		</parameter>
		<parameter type="OutFile">
			<name>outreducedlist</name>
			<attributes>
				<filenames>RAxML_reducedList.result</filenames>
			</attributes>
		</parameter>
		<parameter type="OutFile">
			<name>outbipartitionfrequencies</name>
			<attributes>
				<filenames>RAxML_bipartitionFrequencies.result</filenames>
			</attributes>
		</parameter>
		<parameter type="OutFile">
			<name>outpersitells</name>
			<attributes>
				<filenames>RAxML_perSiteLLs.result</filenames>
			</attributes>
		</parameter>
		<parameter type="OutFile">
			<name>outbesttree</name>
			<attributes>
				<filenames>RAxML_bestTree.result</filenames>
			</attributes>
		</parameter>
		<parameter type="OutFile">
			<name>reduced_results</name>
			<attributes>
				<filenames>*.reduced</filenames>
			</attributes>
		</parameter>
		<parameter type="OutFile">
			<name>txt_results</name>
			<attributes>
				<filenames>*.txt</filenames>
			</attributes>
		</parameter> -->
	</parameters>
</pise>

