<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE pise PUBLIC "pise2.dtd" "pise2.dtd" >
<pise>
	<head>
		<title>IQ-Tree on XSEDE</title>
		<version>1.6.10</version>
		<description>Efficient phylogenomic software by maximum likelihood, run on XSEDE</description>
		<authors>L.-T. Nguyen, H.A. Schmidt, A. von Haeseler, and B.Q. Minh</authors>
		<reference>L.-T. Nguyen, H.A. Schmidt, A. von Haeseler, and B.Q. Minh (2015) IQ-TREE: A fast and effective stochastic algorithm for estimating maximum likelihood phylogenies. Mol. Biol. Evol., 32:268-274. 
DOI: 10.1093/molbev/msu300</reference>
		<category>Phylogeny / Alignment</category>
	</head>
	
	<command>iqtree_xsede_1_01_01</command>
	
<!--
*****************************************************************************************************************************************
Created by Mark Miller for CSG, 5/2/2017
***************************************************************************************************************************************** -->

<!-- Usage: /projects/ps-ngbt/opt/comet/iqtree-omp-1.5.4-Linux/bin/iqtree-omp -s <alignment> [OPTIONS]

GENERAL OPTIONS:
  -? or -h             Print this help dialog
  -s <alignment>       Input alignment in PHYLIP/FASTA/NEXUS/CLUSTAL/MSF format
  -st <data_type>      BIN, DNA, AA, NT2AA, CODON, MORPH (default: auto-detect)
  -q <partition_file>  Edge-linked partition model (file in NEXUS/RAxML format)
 -spp <partition_file> Like -q option but allowing partition-specific rates
  -sp <partition_file> Edge-unlinked partition model (like -M option of RAxML)
  -t <start_tree_file> or -t BIONJ or -t RANDOM
                       Starting tree (default: 99 parsimony tree and BIONJ)
  -te <user_tree_file> Like -t but fixing user tree (no tree search performed)
  -o <outgroup_taxon>  Outgroup taxon name for writing .treefile
  -pre <PREFIX>        Prefix for all output files (default: aln/partition)
  -nt <#cpu_cores>     Number of cores/threads to use (REQUIRED)
  -seed <number>       Random seed number, normally used for debugging purpose
  -v, -vv, -vvv        Verbose mode, printing more messages to screen
  -quiet               Quiet mode, suppress printing to screen (stdout)
  -keep-ident          Keep identical sequences (default: remove & finally add)
  -safe                Safe likelihood kernel to avoid numerical underflow
  -mem RAM             Maximal RAM usage for memory saving mode

CHECKPOINTING TO RESUME STOPPED RUN:
  -redo                Redo analysis even for successful runs (default: resume)
  -cptime <seconds>    Minimum checkpoint time interval (default: 20)

LIKELIHOOD MAPPING ANALYSIS:
  -lmap <#quartets>    Number of quartets for likelihood mapping analysis
  -lmclust <clustfile> NEXUS file containing clusters for likelihood mapping
  -wql                 Print quartet log-likelihoods to .quartetlh file

NEW STOCHASTIC TREE SEARCH ALGORITHM:
  -ninit <number>      Number of initial parsimony trees (default: 100)
  -ntop <number>       Number of top initial trees (default: 20)
  -nbest <number>      Number of best trees retained during search (defaut: 5)
  -n <#iterations>     Fix number of iterations to stop (default: auto)
  -nstop <number>      Number of unsuccessful iterations to stop (default: 100)
  -pers <proportion>   Perturbation strength for randomized NNI (default: 0.5)
  -sprrad <number>     Radius for parsimony SPR search (default: 6)
  -allnni              Perform more thorough NNI search (default: off)
  -g <constraint_tree> (Multifurcating) topological constraint tree file

ULTRAFAST BOOTSTRAP:
  -bb <#replicates>    Ultrafast bootstrap (>=1000)
  -bnni Starting with IQ-TREE version 1.6 we provide a new option -bnni to reduce the risk
of overestimating branch supports with UFBoot due to severe model violations. With
this option UFBoot will further optimize each bootstrap tree using a hill-climbing nearest
neighbor interchange (NNI) search based directly on the corresponding bootstrap alignment.
  -wbt                 Write bootstrap trees to .ufboot file (default: none)
  -wbtl                Like -wbt but also writing branch lengths
  -nm <#iterations>    Maximum number of iterations (default: 1000)
  -nstep <#iterations> #Iterations for UFBoot stopping rule (default: 100)
  -bcor <min_corr>     Minimum correlation coefficient (default: 0.99)
  -beps <epsilon>      RELL epsilon to break tie (default: 0.5)

STANDARD NON-PARAMETRIC BOOTSTRAP:
  -b <#replicates>     Bootstrap + ML tree + consensus tree (>=100)
  -bc <#replicates>    Bootstrap + consensus tree
  -bo <#replicates>    Bootstrap only

SINGLE BRANCH TEST:
  -alrt <#replicates>  SH-like approximate likelihood ratio test (SH-aLRT)
  -alrt 0              Parametric aLRT test (Anisimova and Gascuel 2006)
  -abayes              approximate Bayes test (Anisimova et al. 2011)
  -lbp <#replicates>   Fast local bootstrap probabilities

MODEL-FINDER:
  -m TESTONLY          Standard model selection (like jModelTest, ProtTest)
  -m TEST              Standard model selection followed by tree inference
  -m MF                Extended model selection with FreeRate heterogeneity
  -m MFP               Extended model selection followed by tree inference
  -m TESTMERGEONLY     Find best partition scheme (like PartitionFinder)
  -m TESTMERGE         Find best partition scheme followed by tree inference
  -m MF+MERGE          Find best partition scheme incl. FreeRate heterogeneity
  -m MFP+MERGE         Like -m MF+MERGE followed by tree inference
  -rcluster <percent>  Percentage of partition pairs (relaxed clustering alg.)
  -mset program        Restrict search to models supported by other programs
                       (raxml, phyml or mrbayes)
  -mset m1,...,mk      Restrict search to models in a comma-separated list
                       (e.g. -mset WAG,LG,JTT)
  -msub source         Restrict search to AA models for specific sources
                       (nuclear, mitochondrial, chloroplast or viral)
  -mfreq f1,...,fk     Restrict search to using a list of state frequencies
                       (default AA: -mfreq FU,F; codon: -mfreq ,F1x4,F3x4,F)
  -mrate r1,...,rk     Restrict search to a list of rate-across-sites models
                       (e.g. -mrate E,I,G,I+G,R is used for -m MF)
  -cmin <kmin>         Min #categories for FreeRate model [+R] (default: 2)
  -cmax <kmax>         Max #categories for FreeRate model [+R] (default: 10)
  -merit AIC|AICc|BIC  Optimality criterion to use (default: all)
  -mtree               Perform full tree search for each model considered
  -mredo               Ignore model results computed earlier (default: reuse)
  -madd mx1,...,mxk    List of mixture models to also consider
  -mdef <nexus_file>   A model definition NEXUS file (see Manual)

SUBSTITUTION MODEL:
  -m <model_name>
                  DNA: HKY (default), JC, F81, K2P, K3P, K81uf, TN/TrN, TNef,
                       TIM, TIMef, TVM, TVMef, SYM, GTR, or 6-digit model
                       specification (e.g., 010010 = HKY)
              Protein: LG (default), Poisson, cpREV, mtREV, Dayhoff, mtMAM,
                       JTT, WAG, mtART, mtZOA, VT, rtREV, DCMut, PMB, HIVb,
                       HIVw, JTTDCMut, FLU, Blosum62, GTR20
      Protein mixture: C10,...,C60, EX2, EX3, EHO, UL2, UL3, EX_EHO, LG4M, LG4X
               Binary: JC2 (default), GTR2
      Empirical codon: KOSI07, SCHN05
    Mechanistic codon: GY (default), MG, MGK, GY0K, GY1KTS, GY1KTV, GY2K,
                       MG1KTS, MG1KTV, MG2K
 Semi-empirical codon: XX_YY where XX is empirical and YY is mechanistic model
       Morphology/SNP: MK (default), ORDERED
            Otherwise: Name of file containing user-model parameters
                       (rate parameters and state frequencies)
  -m <model_name>+F or +FO or +FU or +FQ (default: auto)
                       counted, optimized, user-defined, equal state frequency
  -m <model_name>+F1x4 or +F3x4
                       Codon frequencies
  -m <model_name>+ASC  Ascertainment bias correction for morphological/SNP data
  -m "MIX{m1,...mK}"   Mixture model with K components
  -m "FMIX{f1,...fK}"  Frequency mixture model with K components
  -mwopt               Turn on optimizing mixture weights (default: auto)

RATE HETEROGENEITY AMONG SITES:
  -m <model_name>+I or +G[n] or +I+G[n] or +R[n]
                       Invar, Gamma, Invar+Gamma, or FreeRate model where n is
                       number of categories (default: n=4)
  -a <Gamma_shape>     Gamma shape parameter for site rates (default: estimate)
  -amin <min_shape>    Min Gamma shape parameter for site rates (default: 0.02)
  -gmedian             Median approximation for +G site rates (default: mean)
  -*opt-gamma-inv      More thorough estimation for +I+G model parameters
  -i <p_invar>         Proportion of invariable sites (default: estimate)
  -wsr                 Write site rates to .rate file
  -mh                  Computing site-specific rates to .mhrate file using
                       Meyer & von Haeseler (2003) method

SITE-SPECIFIC FREQUENCY MODEL:
  -ft <tree_file>      Input tree to infer site frequency model
  -fs <in_freq_file>   Input site frequency model file
  -fmax                Posterior maximum instead of mean approximation

CONSENSUS RECONSTRUCTION:
  -t <tree_file>       Set of input trees for consensus reconstruction
  -minsup <threshold>  Min split support in range [0,1]; 0.5 for majority-rule
                       consensus (default: 0, i.e. extended consensus)
  -bi <burnin>         Discarding <burnin> trees at beginning of <treefile>
  -con                 Computing consensus tree to .contree file
  -net                 Computing consensus network to .nex file
  -sup <target_tree>   Assigning support values for <target_tree> to .suptree
  -suptag <name>       Node name (or ALL) to assign tree IDs where node occurs

ROBINSON-FOULDS DISTANCE:
  -rf_all              Computing all-to-all RF distances of trees in <treefile>
  -rf <treefile2>      Computing all RF distances between two sets of trees
                       stored in <treefile> and <treefile2>
  -rf_adj              Computing RF distances of adjacent trees in <treefile>

TREE TOPOLOGY TEST:
  -z <trees_file>      Evaluating a set of user trees
  -zb <#replicates>    Performing BP,KH,SH,ELW tests for trees passed via -z
  -zw                  Also performing weighted-KH and weighted-SH tests
  -au                  Also performing approximately unbiased (AU) test

GENERATING RANDOM TREES:
  -r <num_taxa>        Create a random tree under Yule-Harding model
  -ru <num_taxa>       Create a random tree under Uniform model
  -rcat <num_taxa>     Create a random caterpillar tree
  -rbal <num_taxa>     Create a random balanced tree
  -rcsg <num_taxa>     Create a random circular split network
  -rlen <min_len> <mean_len> <max_len>  
                       min, mean, and max branch lengths of random trees

MISCELLANEOUS:
  -wt                  Write locally optimal trees into .treels file
  -blfix               Fix branch lengths of user tree passed via -te
  -blscale             Scale branch lengths of user tree passed via -t
  -blmin               Min branch length for optimization (default 0.000001)
  -blmax               Max branch length for optimization (default 100)
  -wsr                 Write site rates and categories to .rate file
  -wsl                 Write site log-likelihoods to .sitelh file
  -wslr                Write site log-likelihoods per rate category
  -wslm                Write site log-likelihoods per mixture class
  -wslmr               Write site log-likelihoods per mixture+rate class
  -wspr                Write site probabilities per rate category
  -wspm                Write site probabilities per mixture class
  -wspmr               Write site probabilities per mixture+rate class
  -wpl                 Write partition log-likelihoods to .partlh file
  -fconst f1,...,fN    Add constant patterns into alignment (N=#nstates)
  -me <epsilon>        LogL epsilon for parameter estimation (default 0.01)
  -*no-outfiles        Suppress printing output files
 -->
<!-- To maintain IQ-TREE, support users and secure fundings, it is important for us that you cite the following papers, whenever the corresponding features were applied for your analysis.
Example 1: "...We obtained branch supports with the ultrafast bootstrap (Minh et al. 2013) implemented in the IQ-TREE software (Nguyen et al. 2015)..." 

 Example 2: "...We inferred the maximum-likelihood tree using the edge-linked partition model in IQ-TREE (Chernomor et al. 2016; Nguyen et al. 2015)..." 


General Options:

Usage and meaning

-h or -? Print help usage. 

-s Specify input alignment file in PHYLIP, FASTA, NEXUS, CLUSTAL or MSF format. 

-st Specify sequence type as either of DNA, AA, BIN, MORPH, CODON or NT2AA for DNA, amino-acid, binary, morphological, codon or DNA-to-AA-translated sequences. This is only necessary if IQ-TREE did not detect the sequence type correctly. Note that -st CODON is always necessary when using codon models (otherwise, IQ-TREE applies DNA models) and you also need to specify a genetic code like this if differed from the standard genetic code. -st NT2AA tells IQ-TREE to translate protein-coding DNA into AA sequences and then subsequent analysis will work on the AA sequences. You can also use a genetic code like -st NT2AA5 for the Invertebrate Mitochondrial Code (see genetic code table). 

-t Specify a file containing starting tree for tree search. The special option -t BIONJ starts tree search from BIONJ tree and -t RANDOM starts tree search from completely random tree. DEFAULT: 100 parsimony trees + BIONJ tree 

-te Like -t but fixing user tree. That means, no tree search is performed and IQ-TREE computes the log-likelihood of the fixed user tree. 

-o Specify an outgroup taxon name to root the tree. The output tree in .treefile will be rooted accordingly. DEFAULT: first taxon in alignment 

-pre Specify a prefix for all output files. DEFAULT: either alignment file name (-s) or partition file name (-q, -spp or -sp) 

-nt Specify the number of CPU cores for iqtree-omp version. A special option -nt AUTO will tell IQ-TREE to automatically determine the best number of cores given the current data and computer. 

-seed Specify a random number seed to reproduce a previous run. This is normally used for debugging purposes. DEFAULT: based on current machine clock 

-v Turn on verbose mode for printing more messages to screen. This is normally used for debugging purposes. DFAULT: OFF 

-quiet Silent mode, suppress printing to the screen. Note that .log file is still written. 

-keep-ident Keep identical sequences in the alignment. Bu default: IQ-TREE will remove them during the analysis and add them in the end. 

-safe Turn on safe numerical mode to avoid numerical underflow for large data sets with many sequences (typically in the order of thousands). This mode is automatically turned on when having more than 2000 sequences. 

-mem Specify maximal RAM usage, for example, -mem 64G to use at most 64 GB of RAM. By default, IQ-TREE will try to not to exceed the computer RAM size. 
 
Restarting:

Option

Usage and meaning

-redo Redo the entire analysis no matter if it was stopped or successful. WARNING: This option will overwrite all existing output files. 

-cptime Specify the minimum checkpoint time interval in seconds (default: 20s) 
	
	
Likelihood mapping analysis

Starting with version 1.4.0, IQ-TREE implements the likelihood mapping approach (Strimmer and von Haeseler, 1997) to assess the phylogenetic information of an input alignment. The detailed results will be printed to .iqtree report file. The likelihood mapping plots will be printed to .lmap.svg and .lmap.eps files.

Compared with the original implementation in TREE-PUZZLE, IQ-TREE is much faster and supports many more substitution models (including partition and mixture models).

Usage and meaning

-lmap Specify the number of quartets to be randomly drawn. If you specify -lmap ALL, all unique quartets will be drawn, instead. 

-lmclust Specify a NEXUS file containing taxon clusters (see below for example) for quartet mapping analysis. 

-wql Write quartet log-likelihoods into .lmap.quartetlh file (typically not needed). 

-n 0 Skip subsequent tree search, useful when you only want to assess the phylogenetic information of the alignment. 

Automatic model selection
The default model (e.g., HKY+F for DNA, LG for protein data) may not fit well to the data. Therefore, IQ-TREE allows to automatically determine the 
best-fit model via a series of -m TEST... option:

Usage and meaning

-m TESTONLY Perform standard model selection like jModelTest (for DNA) and ProtTest (for protein). Moreover, IQ-TREE also works for codon, binary and morphogical data. 
-m TEST Like -m TESTONLY but immediately followed by tree reconstruction using the best-fit model found. So this performs both model selection and tree inference within a single run. 
-m TESTNEWONLY or -m MF Perform an extended model selection that additionally includes FreeRate model compared with -m TESTONLY. Recommended as replacement for -m TESTONLY. Note that LG4X is a FreeRate model, but by default is not included because it is also a protein mixture model. To include it, use -madd option (see table below). 
-m TESTNEW or -m MFP Like -m MF but immediately followed by tree reconstruction using the best-fit model found. 
-m TESTMERGEONLY Select best-fit partitioning scheme like PartitionFinder. 
-m TESTMERGE Like -m TESTMERGEONLY but immediately followed by tree reconstruction using the best partitioning scheme found. 
-m TESTNEWMERGEONLY or -m MF+MERGE Like -m TESTMERGEONLY but additionally includes FreeRate model. 
-m TESTNEWMERGE or -m MFP+MERGE Like -m MF+MERGE but immediately followed by tree reconstruction using the best partitioning scheme found. 

“TIP: During model section run, IQ-TREE will write a file with suffix .model that stores information of all models tested so far. Thus, if IQ-TREE is interrupted for whatever reason, restarting the run will load this file to reuse the computation. Thus, this file acts like a checkpoint to resume the model selection.

Several parameters can be set to e.g. reduce computations:

Option

Usage and meaning

-rcluster Specify the percentage for the relaxed clustering algorithm (Lanfear et al., 2014). This is similar to -*rcluster-percent option of PartitionFinder. For example, with -rcluster 10 only the top 10% partition schemes are considered to save computations. 
-mset Specify the name of a program (raxml, phyml or mrbayes) to restrict to only those models supported by the specified program. Alternatively, one can specify a comma-separated list of base models. For example, -mset WAG,LG,JTT will restrict model selection to WAG, LG, and JTT instead of all 18 AA models to save computations. 
-msub Specify either nuclear, mitochondrial, chloroplast or viral to restrict to those AA models designed for specified source. 
-mfreq Specify a comma-separated list of frequency types for model selection. DEFAULT: -mfreq FU,F for protein models (FU = AA frequencies given by the protein matrix, F = empirical AA frequencies from the data), -mfreq ,F1x4,F3x4,F for codon models 
-mrate Specify a comma-separated list of rate heterogeneity types for model selection. DEFAULT: -mrate E,I,G,I+G for standard procedure, -mrate E,I,G,I+G,R for new selection procedure 
-cmin Specify minimum number of categories for FreeRate model. DEFAULT: 2 
-cmax Specify maximum number of categories for FreeRate model. It is recommended to increase if alignment is long enough. DEFAULT: 10 
-merit Specify either AIC, AICc or BIC for the optimality criterion to apply for new procedure. DEFAULT: all three criteria are considered 
-mtree Turn on full tree search for each model considered, to obtain more accurate result. Only recommended if enough computational resources are available. DEFAULT: fixed starting tree 
-mredo Ignore .model file computed earlier. DEFAULT: .model file (if exists) is loaded to reuse previous computations 
-madd Specify a comma-separated list of mixture models to additionally consider for model selection. For example, -madd LG4M,LG4X to additionally include these two protein mixture models. 
-mdef Specify a NEXUS model file to define new models. 

“NOTE: Some of the above options require a comma-separated list, which should not contain any empty space!

Example usages:

•Select best-fit model for alignment data.phy based on Bayesian information criterion (BIC):
  iqtree -s data.phy -m TESTONLY

•Select best-fit model for a protein alignment prot.phy using the new testing procedure and only consider WAG, LG and JTT matrix to save time:
  iqtree -s prot.phy -m MF -mset WAG,LG,JTT
  
Specifying substitution models
-m is a powerful option to specify substitution models, state frequency and rate heterogeneity type. The general syntax is:
-m MODEL+FreqType+RateType

where MODEL is a model name, +FreqType (optional) is the frequency type and +RateType (optional) is the rate heterogeneity type.

The following MODELs are available:

DataType

Model names
DNA JC/JC69, F81, K2P/K80, HKY/HKY85, TN/TrN/TN93, TNe, K3P/K81, K81u, TPM2, TPM2u, TPM3, TPM3u, TIM, TIMe, TIM2, TIM2e, TIM3, TIM3e, TVM, TVMe, SYM, GTR and 6-digit specification. See DNA models for more details. 
Protein BLOSUM62, cpREV, Dayhoff, DCMut, FLU, HIVb, HIVw, JTT, JTTDCMut, LG, mtART, mtMAM, mtREV, mtZOA, Poisson, PMB, rtREV, VT, WAG. 
Protein Mixture models: C10, …, C60 (CAT model) (Lartillot and Philippe, 2004), EX2, EX3, EHO, UL2, UL3, EX_EHO, LG4M, LG4X, CF4. See Protein models for more details. 
Codon MG, MGK, MG1KTS, MG1KTV, MG2K, GY, GY1KTS, GY1KTV, GY2K, ECMK07/KOSI07, ECMrest, ECMS05/SCHN05 and combined empirical-mechanistic models. See Codon models for more details. 
Binary JC2, GTR2. See Binary and morphological models for more details. 
Morphology MK, ORDERED. See Binary and morphological models for more details. 

The following FreqTypes are supported: FreqType

Meaning
+F Empirical state frequency observed from the data. 
+FO State frequency optimized by maximum-likelihood from the data. Note that this is with letter-O and not digit-0. 
+FQ Equal state frequency. 
+F1x4 See Codon frequencies. 
+F3x4 See Codon frequencies. 

Usage and meaning
-mwopt Turn on optimizing weights of mixture models. Note that for models like LG+C20+F+G this mode is automatically turned on, but not for LG+C20+G. 

Example usages:

•Infer an ML tree for a DNA alignment dna.phy under GTR+I+G model:
  iqtree -s dna.phy -m GTR+I+G


Rate heterogeneity - The following RateTypes are supported:
RateType

+I Allowing for a proportion of invariable sites. 
+G Discrete Gamma model (Yang, 1994) with default 4 rate categories. The number of categories can be changed with e.g. +G8. 
+I+G Invariable site plus discrete Gamma model (Gu et al., 1995). 
+R FreeRate model (Yang, 1995; Soubrier et al., 2012) that generalizes +G by relaxing the assumption of Gamma-distributed rates. The number of categories can be specified with e.g. +R6. DEFAULT: 4 categories 
+I+R invariable site plus FreeRate model. 

See Rate heterogeneity across sites for more details.

Further options:
Usage and meaning

-a Specify the Gamma shape parameter (default: estimate) 
-gmedian Perform the median approximation for Gamma rate heterogeneity instead of the default mean approximation (Yang, 1994) 
-i Specify the proportion of invariable sites (default: estimate) 
-*opt-gamma-inv Perform more thorough estimation for +I+G model parameters 
-wsr Write per-site rates to .rate file 

Optionally, one can specify Ascertainment bias correction by appending +ASC to the model string. Advanced mixture models can also be specified via MIX{...} and FMIX{...} syntax. Option -mwopt can be used to turn on optimizing weights of mixture models.

Partition model options - Partition models are used for phylogenomic data with multiple genes. You first have to prepare a partition file in NEXUS or RAxML-style format. Then use the following options to input the partition file:
Usage and meaning

-q Specify partition file for edge-equal partition model. That means, all partitions share the same set of branch lengths (like -q option of RAxML). 
-spp Like -q but allowing partitions to have different evolutionary speeds (edge-proportional partition model). 
-sp Specify partition file for edge-unlinked partition model. That means, each partition has its own set of branch lengths (like -M option of RAxML). This is the most parameter-rich partition model to accomodate heterotachy. 

Site-specific frequency model options - The site-specific frequency model is used to substantially reduce the time and memory requirement compared with full profile mixture models C10 to C60. For full details see site-specific frequency model. To use this model you have to specify a profile mixture model with e.g. -m LG+C20+F+G together with a guide tree or a site frequency file:

Option

Usage and meaning

-ft Specify a guide tree (in Newick format) to infer site frequency profiles. 
-fs Specify a site frequency file, e.g. the .sitefreq file obtained from -ft run. This will save memory used for the first phase of the analysis. 
-fmax Switch to posterior maximum mode for obtaining site-specific profiles. Default: posterior mean. 

With -fs option you can input a file containing your own site frequency profiles. The format of this file is that each line contains the site ID (starting from 1) and the state frequencies (20 for amino-acid) separated by white space. So it has as many lines as the number of sites in the alignment. The order of amino-acids is:
 A   R   N   D   C   Q   E   G   H   I   L   K   M   F   P   S   T   W   Y   V


Tree search parameters - The new IQ-TREE search algorithm (Nguyen et al., 2015) has several parameters that can be changed with:
Usage and meaning

-ninit Specify number of initial parsimony trees. DEFAULT: 100. Here the PLL library (Flouri et al., 2015) is used, which implements the randomized stepwise addition and parsimony subtree pruning and regafting (SPR). 
-ntop Specify number of top initial parsimony trees to optimize with ML nearest neighbor interchange (NNI) search to initialize the candidate set. DEFAULT: 20 
-nbest Specify number of trees in the candidate set to maintain during ML tree search. DEFAULT: 5 
-nstop Specify number of unsuccessful iterations to stop. DEFAULT: 100 
-n Specify number of iterations to stop. This option overrides -nstop criterion. 
-sprrad Specify SPR radius for the initial parsimony tree search. DEFAULT: 6 
-pers Specify perturbation strength (between 0 and 1) for randomized NNI. DEFAULT: 0.5 
-allnni Turn on more thorough and slower NNI search. It means that IQ-TREE will consider all possible NNIs instead of only those in the vicinity of previously applied NNIs. DEFAULT: OFF 
-djc Avoid computing ML pairwise distances and BIONJ tree. 
-g Specify a topological constraint tree file in NEWICK format. The constraint tree can be a multifurcating tree and need not to include all taxa. 

“NOTE: While the default parameters were empirically determined to work well under our extensive benchmark (Nguyen et al., 2015), it might not hold true for all data sets. If in doubt that tree search is still stuck in local optima, one should repeat analysis with at least 10 IQ-TREE runs. Moreover, our experience showed that -pers and -nstop are the most relevant options to change in such case. For example, data sets with many short sequences should be analyzed with smaller perturbation strength (e.g. -pers 0.2) and larger number of stop iterations (e.g. -nstop 500).

Example usages:

•Infer an ML tree for an alignment data.phy with increased stopping iteration of 500 and reduced perturbation strength of 0.2:
  iqtree -s data.phy -m TEST -nstop 500 -pers 0.2

•Infer an ML tree for an alignment data.phy obeying a topological constraint tree constraint.tree:
  iqtree -s data.phy -m TEST -g constraint.tree



Ultrafast bootstrap parameters - The ultrafast bootstrap (UFBoot) approximation (Minh et al., 2013) has several parameters that can be changed with:

Usage and meaning

-bb Specify number of bootstrap replicates (>=1000). 
-wbt Turn on writing bootstrap trees to .ufboot file. DEFAULT: OFF 
-wbtl Like -wbt but bootstrap trees written with branch lengths. DEFAULT: OFF 
-nm Specify maximum number of iterations to stop. DEFAULT: 1000 
-bcor Specify minimum correlation coefficient for UFBoot convergence criterion. DEFAULT: 0.99 
-nstep Specify iteration interval checking for UFBoot convergence. DEFAULT: every 100 iterations 
-beps Specify a small epsilon to break tie in RELL evaluation for bootstrap trees. DEFAULT: 0.5 
-bspec Specify the resampling strategies for partitioned analysis. By default, IQ-TREE resamples alignment sites within partitions. With -bspec GENE IQ-TREE will resample partitions. With -bspec GENESITE IQ-TREE will resample partitions and then resample sites within resampled partitions (Gadagkar et al., 2005). 

Example usages:

•Select best-fit model, infer an ML tree and perform ultrafast bootstrap with 1000 replicates:
  iqtree -s data.phy -m TEST -bb 1000

•Reconstruct ML and perform ultrafast bootstrap (5000 replicates) under a partition model file partition.nex:
  iqtree -s data.phy -spp partition.nex -m TEST -bb 5000

Nonparametric bootstrap - The slow standard nonparametric bootstrap (Felsenstein, 1985) can be run with:

Usage and meaning

-b Specify number of bootstrap replicates (recommended >=100). This will perform both bootstrap and analysis on original alignment and provide a consensus tree. 
-bc Like -b but omit analysis on original alignment. 
-bo Like -b but only perform bootstrap analysis (no analysis on original alignment and no consensus tree). 

Single branch tests - The following single branch tests are faster than all bootstrap analysis and recommended for extremely large data sets (e.g., >10,000 taxa):

-alrt Specify number of replicates (>=1000) to perform SH-like approximate likelihood ratio test (SH-aLRT) (Guindon et al., 2010). If number of replicates is set to 0 (-alrt 0), then the parametric aLRT test (Anisimova and Gascuel 2006) is performed, instead of SH-aLRT. 
-abayes Perform approximate Bayes test (Anisimova et al., 2011). 
-lbp Specify number of replicates (>=1000) to perform fast local bootstrap probability method (Adachi and Hasegawa, 1996). 

“TIP: One can combine all these tests (also including UFBoot -bb option) within a single IQ-TREE run. Each branch in the resulting tree will be assigned several support values separated by slash (/), where the order of support values is stated in the .iqtree report file.


Example usages:

•Infer an ML tree and perform SH-aLRT test as well as ultrafast bootstrap with 1000 replicates:
  iqtree -s data.phy -m TEST -alrt 1000 -bb 1000

Tree topology tests - IQ-TREE provides a number of tests for significant topological differences between trees:

Usage and meaning
-z Specify a file containing a set of trees. IQ-TREE will compute the log-likelihoods of all trees. 
-zb Specify the number of RELL (Kishino et al., 1990) replicates (>=1000) to perform several tree topology tests for all trees passed via -z. The tests include bootstrap proportion (BP), KH test (Kishino and Hasegawa, 1989), SH test (Shimodaira and Hasegawa, 1999) and expected likelihood weights (ELW) (Strimmer and Rambaut, 2002). 
-zw Used together with -zb to additionally perform the weighted-KH and weighted-SH tests. 
-au Used together with -zb to additionally perform the approximately unbiased (AU) test (Shimodaira, 2002). Note that you have to specify the number of replicates for the AU test via -zb. 
-n 0 Only estimate model parameters on an initial parsimony tree and ignore a full tree search to save time. 
-te Specify a fixed user tree to estimate model parameters. Thus it behaves like -n 0 but uses a user-defined tree instead of parsimony tree. 

“NOTE: The AU test implementation in IQ-TREE is much more efficient than the original CONSEL by supporting SSE, AVX and multicore parallelization. Moreover, it is more appropriate than CONSEL for partition analysis by bootstrap resampling sites within partitions, whereas CONSEL is not partition-aware.

Example usages:

•Given alignment data.phy, test a set of trees in data.trees using AU test with 10,000 replicates:
  iqtree -s data.phy -m GTR+G -n 0 -z data.trees -zb 10000 -au 

•Same above but for a partitioned data partition.nex and additionally performing weighted test:
  iqtree -s data.phy -spp partition.nex -n 0 -z data.trees -zb 10000 -au -zw


Constructing consensus tree - IQ-TREE provides a fast implementation of consensus tree construction for post analysis:
Usage and meaning

-t Specify a file containing a set of trees. 
-con Compute consensus tree of the trees passed via -t. Resulting consensus tree is written to .contree file. 
-net Compute consensus network of the trees passed via -t. Resulting consensus network is written to .nex file. 
-minsup Specify a minimum threshold (between 0 and 1) to keep branches in the consensus tree. -minsup 0.5 means to compute majority-rule consensus tree. DEFAULT: 0 to compute extended majority-rule consensus. 
-bi Specify a burn-in, which is the number of beginning trees passed via -t to discard before consensus construction. This is useful e.g. when summarizing trees from MrBayes analysis. 
-sup Specify an input “target” tree file. That means, support values are first extracted from the trees passed via -t, and then mapped onto the target tree. Resulting tree with assigned support values is written to .suptree file. This option is useful to map and compare support values from different approaches onto a single tree. 
-suptag Specify name of a node in -sup target tree. The corresponding node of .suptree will then be assigned with IDs of trees where this node appears. Special option -suptag ALL will assign such IDs for all nodes of the target tree. 

Computing Robinson-Foulds distance - IQ-TREE provides a fast implementation of Robinson-Foulds (RF) distance computation between trees:
Usage and meaning

-t Specify a file containing a set of trees. 
-rf Specify a second set of trees. IQ-TREE computes all pairwise RF distances between two tree sets passed via -t and -rf 
-rf_all Compute all-to-all RF distances between all trees passed via -t 
-rf_adj Compute RF distances between adjacent trees passed via -t 

Example usages:

•Compute the pairwise RF distances between 2 sets of trees:
  iqtree -rf tree_set1 tree_set2

•Compute the all-to-all RF distances within a set of trees:
  iqtree -rf_all tree_set

Generating random trees - IQ-TREE provides several random tree generation models:
Usage and meaning

-r Specify number of taxa. IQ-TREE will create a random tree under Yule-Harding model with specified number of taxa 
-ru Like -r, but a random tree is created under uniform model. 
-rcat Like -r, but a random caterpillar tree is created. 
-rbal Like -r, but a random balanced tree is created. 
-rcsg Like -r, bur a random circular split network is created. 
-rlen Specify three numbers: minimum, mean and maximum branch lengths of the random tree. DEFAULT: -rlen 0.001 0.1 0.999 

Example usages:

•Generate a 100-taxon random tree into the file 100.tree under the Yule Harding model:
  iqtree -r 100 100.tree 

•Generate 100-taxon random tree with mean branch lengths of 0.2 and branch lengths are between 0.05 and 0.3:
  iqtree -r 100 -rlen 0.05 0.2 0.3 100.tree 

•Generate a random tree under uniform model:
  iqtree -ru 100 100.tree 

•Generate a random tree where taxon labels follow an alignment:
  iqtree -s example.phy -r 17 example.random.tree 

Note that, you still need to specify the -r option being equal to the number of taxa in the alignment.

Miscellaneous options

Usage and meaning

-wt Turn on writing all locally optimal trees into .treels file. DEFAULT: OFF 
-fixbr Turn on fixing branch lengths of tree passed via -t or -te. This is useful to evaluate the log-likelihood of an input tree with fixed tolopogy and branch lengths. DEFAULT: OFF 
-wsl Turn on writing site log-likelihoods to .sitelh file in TREE-PUZZLE format. Such file can then be passed on to CONSEL for further tree tests. DEFAULT: OFF 
-wslg Turn on writing site log-likelihoods per rate category. DEFAULT: OFF 
-fconst Specify a list of comma-separated integer numbers. The number of entries should be equal to the number of states in the model (e.g. 4 for DNA and 20 for protein). IQ-TREE will then add a number of constant sites accordingly. For example, -fconst 10,20,15,40 will add 10 constant sites of all A, 20 constant sites of all C, 15 constant sites of all G and 40 constant sites of all T into the alignment. 





	-->
<!-- new rules from Wayne
Rules for running IQ-TREE on Comet via the CIPRES gateway

The runs use varying numbers of cores within a single node of Comet depending upon the
specified options and the data set.

- Check whether the -mtree option is specified.

- Ask the user for the number of partitions in his or her data set.

- Specify the Slurm partition, CIPRES threads, and value for -nt according to the
folowing table.

            Data       Slurm     CIPRES    -nt
 -mtree  partitions  partition  threads   value

   no       <=12      shared       12      AUTO
   no        >12      compute      24      AUTO
   yes      <=12      shared       12       12
   yes       >12      compute      24       24

- For example, for a run without -mtree and with no more than 12 partitions,
include the following in the run script.


  #SBATCH -p shared
  #SBATCH -*qos=cipres
  #SBATCH -N 1
  #SBATCH -*ntasks-per-node=12
  ...
  export MODULEPATH=/projects/ps-ngbt/opt/comet/modules:$MODULEPATH
  module load iqtree/1.6.2
  iqtree -nt AUTO ...
 -->
 <!-- #####################################################################################################  -->
 <!-- revised on 3/9/2018
 [pfeiffer@comet-ln2 rules]$ cat IQ-TREE-1.6.2.Comet.rules
Rules for running IQ-TREE 1.6.2 on Comet via the CIPRES gateway

The runs use varying numbers of cores within a single node of Comet depending upon
the data set.

- Ask the user whether his or her data set has more than 12 partitions.

- Ask the user whether his or her analysis needs more than 60 GB of memory.

- Specify the Slurm partition, CIPRES threads, and value for -nt according to the
following table.

 Data partitions      Slurm     CIPRES    -nt    Additional
  & memory size     partition  threads   value     option

  <=12 & <=60 GB      shared      12      AUTO
   >12 or >60 GB     compute      24      AUTO    -mem 116G

- Thus, for a run with no more than 12 partitions and that requires no more than
60 GB of memory, include the following in the run script.

  #SBATCH -p shared
  #SBATCH -*qos=cipres
  #SBATCH -N 1
  #SBATCH -*ntasks-per-node=12
  ...
  export MODULEPATH=/projects/ps-ngbt/opt/comet/modules:$MODULEPATH
  module load iqtree/1.6.2
  iqtree -nt AUTO ...

- On the other hand, for a run with more than 12 partitions or that requires more
than 60 GB of memory, include the following in the run script.

  #SBATCH -p compute
  #SBATCH -*qos=cipres
  #SBATCH -N 1
  #SBATCH -*ntasks-per-node=24
  ...
  export MODULEPATH=/projects/ps-ngbt/opt/comet/modules:$MODULEPATH
  module load iqtree/1.6.2
  iqtree -nt AUTO -mem 116G ...
  -->
 <!-- ####################################################################################################### -->
 <!-- new rules 4_16_2018 
Rules for running IQ-TREE 1.6.2 on Comet via the CIPRES gateway

The runs use varying numbers of cores within a single node of Comet depending upon
the data set.

- Ask the user whether his or her data set has more than 12 partitions.

- Check whether the -mem option is specified and, if so, what its value is in GB.
  If the value is >120, the job will not run.

- Specify the Slurm partition, CIPRES threads, and value for -nt according to
  the following table.

    Data       -mem       Slurm     CIPRES    -nt
 partitions   option    partition  threads   value

(note here that currently 1.6.2 does not support -mem for more than 1 partition)
    
    1           Blank     shared       12      AUTO
               or  <=60
    
    2<=12       blank     shared       12      AUTO
             
     >12        blank     compute      24      AUTO

     1          >60 &     compute      24      AUTO
               <=120

- For a run in the first row of the table, 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 iqtree/1.6.2
  iqtree -nt AUTO ...

- For a run in the second or third row of the table, 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 iqtree/1.6.2
  iqtree -nt AUTO ...

  
   -->

<parameters>
	
<!--  submission on comet  -->
					<parameter ismandatory="1" ishidden="1" type="String">
						<name>iqtree_invoke2</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>$which_iqtree eq "2"</code>
							</precond>
							<format>
								<language>perl</language>		
								<code>"iqtree_1.6.2_comet <!--  <![CDATA[/projects/ps-ngbt/opt/comet/iqtree-omp-1.5.4-Linux/bin/iqtree-omp]]>-->"</code>
							</format>
							<group>0</group>
						</attributes>
					</parameter>	
					
<!--  submission on comet  -->
					<parameter ismandatory="1" ishidden="1" type="String">
						<name>iqtree_invoke6</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>$which_iqtree eq "6"</code>
							</precond>
							<format>
								<language>perl</language>		
								<code>"iqtree_1.6.6_comet <!--  <![CDATA[/projects/ps-ngbt/opt/comet/iqtree-omp-1.5.4-Linux/bin/iqtree-omp]]>-->"</code>
							</format>
							<group>0</group>
						</attributes>
					</parameter>
					
<!--  submission on comet  -->
					<parameter ismandatory="1" ishidden="1" type="String">
						<name>iqtree_invoke7</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>$which_iqtree eq "7"</code>
							</precond>
							<format>
								<language>perl</language>		
								<code>"iqtree_1.6.7_comet <!--  <![CDATA[/projects/ps-ngbt/opt/comet/iqtree-omp-1.5.4-Linux/bin/iqtree-omp]]>-->"</code>
							</format>
							<group>0</group>
						</attributes>
					</parameter>	
					
<!--  submission on comet  -->
					<parameter ismandatory="1" ishidden="1" type="String">
						<name>iqtree_invoke9</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>$which_iqtree eq "9"</code>
							</precond>
							<format>
								<language>perl</language>		
								<code>"iqtree_1.6.9_comet <!--  <![CDATA[/projects/ps-ngbt/opt/comet/iqtree-omp-1.5.4-Linux/bin/iqtree-omp]]>-->"</code>
							</format>
							<group>0</group>
						</attributes>
					</parameter>
					
<!--  submission on comet  -->
					<parameter ismandatory="1" ishidden="1" type="String">
						<name>iqtree_invoke10</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>$which_iqtree eq "10"</code>
							</precond>
							<format>
								<language>perl</language>		
								<code>"iqtree_1.6.10_comet <!--  <![CDATA[/projects/ps-ngbt/opt/comet/iqtree-omp-1.5.4-Linux/bin/iqtree-omp]]>-->"</code>
							</format>
							<group>0</group>
						</attributes>
					</parameter>						
														
												
<!-- when run type = 1 -->
				<parameter type="String" ishidden="1" >
					<name>number_nodes1</name>
					<attributes>
						<group>2</group>
						<paramfile>scheduler.conf</paramfile>
						<precond>
							<language>perl</language>
							<code>$specify_runtype == 1 &amp;&amp; !$specify_autocores &amp;&amp; $specify_numparts &lt; 13 </code>
						</precond>
						<format>
							<language>perl</language>
							<code>
									"nodes=1\\n" .
									"node_exclusive=0\\n" .
									"threads_per_process=12\\n"
							</code>
						</format>
					</attributes>
				</parameter> 
				
<!-- when run type = 1 -->
				<parameter type="String" ishidden="1" >
					<name>number_nodes1b</name>
					<attributes>
						<group>2</group>
						<paramfile>scheduler.conf</paramfile>
						<precond>
							<language>perl</language>
							<code>$specify_runtype == 1 &amp;&amp; $specify_autocores </code>
						</precond>
						<format>
							<language>perl</language>
							<code>
									"nodes=1\\n" .
									"node_exclusive=1\\n" .
									"threads_per_process=24\\n"
							</code>
						</format>
					</attributes>
				</parameter>
				
								
				<parameter type="String" ishidden="1" >
					<name>number_nodes1d</name>
					<attributes>
						<group>2</group>
						<paramfile>scheduler.conf</paramfile>
 						<precond>
							<language>perl</language>
							<code>$specify_runtype == 1 &amp;&amp; !$specify_autocores &amp;&amp; $specify_numparts &gt; 12 </code>
						</precond>
						<format>
							<language>perl</language>
							<code>
									"nodes=1\\n" .
									"node_exclusive=1\\n" .
 									"threads_per_process=24\\n"  
							</code>
						</format>
					</attributes>
				</parameter>
				
<!-- when runtype = 2 this section defines the file scheduler.conf that accompanies the command line to the TG resource. It instructs the machine how to run the job. 	--> 							
				<parameter type="String" ishidden="1" >
					<name>number_nodes2</name>
					<attributes>
						<group>2</group>
						<paramfile>scheduler.conf</paramfile>
						<precond>
							<language>perl</language>
							<code>$specify_runtype == 2 &amp;&amp; $specify_numparts &lt; 13 &amp;&amp; $specify_numparts &gt; 1</code>
						</precond>
						<format>
							<language>perl</language>
							<code>
									"nodes=1\\n" .
									"node_exclusive=0\\n" .
									"threads_per_process=12\\n"
							</code>
						</format>
					</attributes>
				</parameter> 
				
				<parameter type="String" ishidden="1" >
					<name>number_nodes2b</name>
					<attributes>
						<group>2</group>
						<paramfile>scheduler.conf</paramfile>
						<precond>
							<language>perl</language>
							<code>$specify_runtype == 2 &amp;&amp; $specify_numparts == 1 &amp;&amp; $specify_mem &lt; 60</code>
						</precond>
						<format>
							<language>perl</language>
							<code>
									"nodes=1\\n" .
									"node_exclusive=0\\n" .
									"threads_per_process=12\\n"
							</code>
						</format>
					</attributes>
				</parameter> 
				
				<parameter type="String" ishidden="1" >
					<name>number_nodes2c</name>
					<attributes>
						<group>2</group>
						<paramfile>scheduler.conf</paramfile>
						<precond>
							<language>perl</language>
							<code>$specify_runtype == 2 &amp;&amp; $specify_numparts == 1 &amp;&amp; $specify_mem &gt; 60</code>
						</precond>
						<format>
							<language>perl</language>
							<code>
									"nodes=1\\n" .
									"node_exclusive=1\\n" .
									"threads_per_process=24\\n"
							</code>
						</format>
					</attributes>
				</parameter> 
				
				<parameter type="String" ishidden="1" >
					<name>number_nodes2d</name>
					<attributes>
						<group>2</group>
						<paramfile>scheduler.conf</paramfile>
 						<precond>
							<language>perl</language>
							<code>$specify_runtype == 2 &amp;&amp; $specify_numparts &gt; 12 </code>
						</precond>
						<format>
							<language>perl</language>
							<code>
									"nodes=1\\n" .
									"node_exclusive=1\\n" .
 									"threads_per_process=24\\n"  
							</code>
						</format>
					</attributes>
				</parameter>
<!-- end number of nodes  -->	
	
<!-- input file specification -->
	<parameter ismandatory="1" issimple="1" isinput="1" type="InFile"> 
	<name>infile</name>
		<attributes>
			<prompt>Input Alignment</prompt>
			<filenames>infile.txt</filenames>
   			<format>
				<language>perl</language>
				<code>"-s infile.txt"</code>
			</format>
			<group>1</group>
		</attributes>
	</parameter>	
	
<!-- begin visible parameters -->		
<!-- This section provides visible queries that help configure the interface  -->

<!-- this sets the run time -->
				<parameter type="Float" issimple="1" ismandatory="1">
					<name>runtime</name> 
					<attributes>
						<group>1</group>
						<paramfile>scheduler.conf</paramfile>
						<prompt>Maximum Hours to Run (up to 168 hours)</prompt>
						<vdef>
							<value>0.5</value>
						</vdef>
						<ctrls>
							<ctrl>
								<message>The maximum hours to run must be less than 168</message>
								<language>perl</language>
								<code>$runtime &gt; 168.0</code>
							</ctrl>
							<ctrl>
								<message>The maximum hours to run must be greater than 0.05</message>
								<language>perl</language>
								<code>$runtime &lt; 0.05</code>
							</ctrl>
						</ctrls>
						<format>
							<language>perl</language>
							<code>"runhours=$value\\n"</code>
						</format>

<!-- provide feedback on number of cpu hrs to be consumed; all runs are the same, but this must be keyed to a visible param, so here we make it conditional on a non-zero run time. -->
						<warns>
							<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>$specify_runtype == 1 </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_runtype == 2 &amp;&amp; $specify_numparts &gt; 12</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_runtype == 2 &amp;&amp; $specify_numparts == 1 &amp;&amp; $specify_mem &gt; 60</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>$specify_runtype == 2 &amp;&amp; $specify_numparts &lt; 13 &amp;&amp; !defined $specify_mem</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>$specify_runtype == 2 &amp;&amp; $specify_numparts == 1 &amp;&amp; defined $specify_mem &amp;&amp; $specify_mem &lt; 60</code>
							</warn>
						</warns>
						<comment>
<value>Estimate the maximum time your job will need to run. We recommend testing initially with a &lt; 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>
<!-- which iq tree -->	
	<parameter  issimple="1" type="Excl"> 
	<name>which_iqtree</name>
		<attributes>
			<prompt>Which version do you want to run</prompt>
			<vlist>
<!--  				<value>2</value>
				<label>1.6.2</label>
				<value>6</value>
				<label>1.6.6</label>
				<value>7</value>
				<label>1.6.7</label>-->
				<value>10</value>
				<label>1.6.10</label>
<!--  			<value>12</value>
				<label>1.6.12</label> -->	
			</vlist>
			<vdef>
				<value>10</value>
			</vdef>
		</attributes>
	</parameter>
				
<!-- $specify_numparts -->
	<parameter  issimple="1" type="Integer"> 
	<name>specify_numparts</name>
		<attributes>
			<prompt>How many partitions does your data set have</prompt>
<!--  			<precond>
				<language>perl</language>
				<code>$specify_runtype == 2</code>
			</precond>-->
			<ctrls>
				<ctrl>
					<message>Please specify the number of partitions</message>
					<language>perl</language>
					<code>!defined $specify_numparts</code>
				</ctrl>
				<ctrl>
					<message>The number of partitions must be greater than zero</message>
					<language>perl</language>
					<code>$specify_numparts &lt; 1</code>
				</ctrl>
				<ctrl>
					<message>Please specify the number of partitions</message>
					<language>perl</language>
					<code>!defined $specify_numparts</code>
				</ctrl>
			</ctrls>
		</attributes>
	</parameter>

	<parameter  issimple="1" type="Integer"> 
	<name>specify_mem</name>
		<attributes>
			<prompt>Memory required (in GB)</prompt>
			<precond>
				<language>perl</language>
				<code>$specify_runtype == 2 &amp;&amp; $specify_numparts == 1</code>
			</precond>
			<ctrls>
				<ctrl>
					<message>The run will not complete if -mem is greater than 120 GB, please contact us</message>
					<language>perl</language>
					<code>$specify_mem &gt; 120</code>
				</ctrl>
			</ctrls>
		</attributes>
	</parameter>
	
	<!--  -safe                Safe likelihood kernel to avoid numerical underflow -->
	<parameter  issimple="1" type="Switch"> 
	<name>specify_safe</name>
		<attributes>
			<prompt>Safe likelihood kernel to avoid numerical underflow (-safe)</prompt>
			<format>
				<language>perl</language>
				<code>($value) ? "-safe":""</code>
			</format>
		</attributes>
	</parameter>

<!-- use -auto when -mtree is not in force-->
	<parameter  issimple="1" ishidden= "1" type="String"> 
	<name>specify_twelvecores</name>
		<attributes>
			<precond>
				<language>perl</language>
				<code>$specify_runtype == 1 &amp;&amp; !$specify_autocores</code>
			</precond>
			<format>
				<language>perl</language>
				<code>"-nt 12"</code>
			</format>
			<group>3</group>
		</attributes>
	</parameter>

<!-- when -mtree is used, different rules apply -->
	<parameter  issimple="1" type="Switch"> 
	<name>specify_autocores</name>
		<attributes>
			<prompt>Automatically select number of threads</prompt>
			<precond>
				<language>perl</language>
				<code>$specify_runtype == 1</code>
			</precond>
			<format>
				<language>perl</language>
				<code>($value) ? "-nt AUTO":""</code>
			</format>
			<group>3</group>
		</attributes>
	</parameter>
	

<!-- 	<parameter  issimple="1" ishidden= "1" type="String"> 
	<name>specify_cores2</name>
		<attributes>
			<precond>
				<language>perl</language>
				<code>$specify_runtype == 2 &amp;&amp; $specify_numparts &lt; 12 &amp;&amp; !defined $specify_mem</code>
			</precond>
			<format>
				<language>perl</language>
				<code>"-nt AUTO "</code>
			</format>
			<group>3</group>
		</attributes>
	</parameter>  -->
	
	<parameter  issimple="1" ishidden= "1" type="String"> 
	<name>specify_cores3</name>
		<attributes>
			<precond>
				<language>perl</language>
				<code>$specify_runtype == 2</code>
			</precond>
			<format>
				<language>perl</language>
				<code>"-nt AUTO"</code>
			</format>
			<group>3</group>
		</attributes>
	</parameter>
	
	<parameter  issimple="1" ishidden= "1" type="String"> 
	<name>specify_cores4</name>
		<attributes>
			<precond>
				<language>perl</language>
				<code>$specify_runtype == 2 &amp;&amp; defined $specify_mem &amp;&amp; !defined $partition_file</code>
			</precond>
			<format>
				<language>perl</language>
				<code>"-mem $specify_mem$specify_g"</code>
			</format>
			<group>4</group>
		</attributes>
	</parameter>
	
	
	<parameter  issimple="1" ishidden= "1" type="String"> 
	<name>specify_g</name>
		<attributes>
			<precond>
				<language>perl</language>
				<code>$specify_runtype == 2 &amp;&amp; defined $specify_mem </code>
			</precond>
			<vdef>
				<value>G</value>
			</vdef>
		</attributes>
	</parameter>
	
	
	<!-- 	Specify run type. -->
	<parameter  issimple="1" ismandatory="1" type="Excl"> 
	<name>specify_runtype</name>
		<attributes>
			<prompt>Select the kind of run you need</prompt>
			<vlist>
				<value>1</value>
				<label>Model Selection</label>
				<value>2</value>
				<label>Tree Inference</label>
			</vlist>
			<ctrls>
				<ctrl>
					<message>Please specify whether the run is for Tree inference or Model Selection</message>
					<language>perl</language>
					<code>!defined $value </code>
				</ctrl>
			</ctrls>
			<group>3</group>
		</attributes>
	</parameter>
	
<!-- 	Sequence type
Specify sequence type as either of DNA, AA, BIN, MORPH, CODON or NT2AA for DNA, amino-acid, binary, 
morphological, codon or DNA-to-AA-translated sequences. This is only necessary if IQ-TREE did not detect 
the sequence type correctly. Note that -st CODON is always necessary when using codon models (otherwise, 
IQ-TREE applies DNA models) and you also need to specify a genetic code like this if differed from the 
standard genetic code. -st NT2AA tells IQ-TREE to translate protein-coding DNA into AA sequences and then 
subsequent analysis will work on the AA sequences. You can also use a genetic code like -st NT2AA5 for the 
Invertebrate Mitochondrial Code (see genetic code table).-->

	<parameter  issimple="1" ismandatory = "1" type="Excl"> 
	<name>sequence_type</name>
		<attributes>
			<prompt>Specify your sequence type (-st)</prompt>
			<precond>
				<language>perl</language>
				<code>!$mixed_sequence</code>
			</precond>
			<format>
				<language>perl</language>
				<code>($value ne "CODON" &amp;&amp; $value ne "NT2AA") ?  "-st $value":""</code>
			</format>
			<vlist>
				<value>DNA</value>
				<label>DNA</label>
				<value>AA</value>
				<label>Amino Acid</label>
				<value>BIN</value>
				<label>Binary</label>
				<value>MORPH</value>
				<label>Morphological</label>
				<value>CODON</value>
				<label>Codon</label>
				<value>NT2AA</value>
				<label>Translate DNA</label>
			</vlist>
			<vdef>
				<value>DNA</value>
			</vdef>
<!--		<ctrls>
				<ctrl>
					<message>Please enter a name for your output file</message>
					<language>perl</language>
					<code>!defined $name_output</code>
				</ctrl>
			</ctrls> -->
			<group>1</group>
		</attributes>
	</parameter>


<!-- 
CODON1 The Standard Code (same as -st CODON) 
CODON2 The Vertebrate Mitochondrial Code 
CODON3 The Yeast Mitochondrial Code 
CODON4 The Mold, Protozoan, and Coelenterate Mitochondrial Code and the Mycoplasma/Spiroplasma Code 
CODON5 The Invertebrate Mitochondrial Code 
CODON6 The Ciliate, Dasycladacean and Hexamita Nuclear Code 
CODON9 The Echinoderm and Flatworm Mitochondrial Code 
CODON10 The Euplotid Nuclear Code 
CODON11 The Bacterial, Archaeal and Plant Plastid Code 
CODON12 The Alternative Yeast Nuclear Code 
CODON13 The Ascidian Mitochondrial Code 
CODON14 The Alternative Flatworm Mitochondrial Code 
CODON16 Chlorophycean Mitochondrial Code 
CODON21 Trematode Mitochondrial Code 
CODON22 Scenedesmus obliquus Mitochondrial Code 
CODON23 Thraustochytrium Mitochondrial Code 
CODON24 Pterobranchia Mitochondrial Code 
CODON25 Candidate Division SR1 and Gracilibacteria Code 
 -->
	<parameter  issimple="1" ismandatory="1" type="Excl"> 
	<name>codon_type</name>
		<attributes>
			<prompt>Specify your Codon type</prompt>
			<precond>
				<language>perl</language>
				<code>$sequence_type eq "CODON"</code>
			</precond>
			<format>
				<language>perl</language>
				<code>"-st $value"</code>
			</format>
			<vlist>
				<value>CODON1</value>
				<label>The Standard Code</label>
				<value>CODON2</value>
				<label>The Vertebrate Mitochondrial Code</label>
				<value>CODON3</value>
				<label>The Yeast Mitochondrial Code</label>
				<value>CODON4</value>
				<label>Mold, Protozoan, Coelenterate, Mycoplasma/Spiroplasma </label>
				<value>CODON5</value>
				<label>The Invertebrate Mitochondrial Code</label>
				<value>CODON6</value>
				<label>The Ciliate, Dasycladacean and Hexamita Nuclear Code </label>
				<value>CODON9</value>
				<label>The Echinoderm and Flatworm Mitochondrial Code</label>
				<value>CODON10</value>
				<label>The Euplotid Nuclear Code</label>
				<value>CODON11</value>
				<label>The Bacterial, Archaeal and Plant Plastid Code</label>
				<value>CODON12</value>
				<label>The Alternative Yeast Nuclear Code</label>
				<value>CODON13</value>
				<label>The Ascidian Mitochondrial Code</label>
				<value>CODON14</value>
				<label>The Alternative Flatworm Mitochondrial Code</label>
				<value>CODON16</value>
				<label>Chlorophycean Mitochondrial Code</label>
				<value>CODON21</value>
				<label>Trematode Mitochondrial Code</label>
				<value>CODON22</value>
				<label>Scenedesmus obliquus Mitochondrial Code </label>
				<value>CODON23</value>
				<label>Thraustochytrium Mitochondrial Code</label>
				<value>CODON24</value>
				<label>Pterobranchia Mitochondrial Code</label>
				<value>CODON25</value>
				<label>Candidate Division SR1 and Gracilibacteria Code</label>
			</vlist>
			<vdef>
				<value>CODON1</value>
			</vdef>
<!--			<ctrls>
				<ctrl>
					<message>Please enter a name for your output file</message>
					<language>perl</language>
					<code>!defined $name_output</code>
				</ctrl>
			</ctrls> -->
			<group>3</group>
		</attributes>
	</parameter>
	
<!-- 
NT2AA1 The Standard Code (same as -st NT2AA) 
NT2AA2 The Vertebrate Mitochondrial Code 
NT2AA3 The Yeast Mitochondrial Code 
NT2AA4 The Mold, Protozoan, and Coelenterate Mitochondrial Code and the Mycoplasma/Spiroplasma Code 
NT2AA5 The Invertebrate Mitochondrial Code 
NT2AA6 The Ciliate, Dasycladacean and Hexamita Nuclear Code 
NT2AA9 The Echinoderm and Flatworm Mitochondrial Code 
NT2AA10 The Euplotid Nuclear Code 
NT2AA11 The Bacterial, Archaeal and Plant Plastid Code 
NT2AA12 The Alternative Yeast Nuclear Code 
NT2AA13 The Ascidian Mitochondrial Code 
NT2AA14 The Alternative Flatworm Mitochondrial Code 
NT2AA16 Chlorophycean Mitochondrial Code 
NT2AA21 Trematode Mitochondrial Code 
NT2AA22 Scenedesmus obliquus Mitochondrial Code 
NT2AA23 Thraustochytrium Mitochondrial Code 
NT2AA24 Pterobranchia Mitochondrial Code 
NT2AA25 Candidate Division SR1 and Gracilibacteria Code 
 -->
	<parameter  issimple="1" ismandatory="1" type="Excl"> 
	<name>nt2aa_type</name>
		<attributes>
			<prompt>Specify your translation table</prompt>
			<precond>
				<language>perl</language>
				<code>$sequence_type eq "NT2AA"</code>
			</precond>
			<format>
				<language>perl</language>
				<code>"-st $value"</code>
			</format>
			<vlist>
				<value>NT2AA1</value>
				<label>The Standard Code</label>
				<value>NT2AA2</value>
				<label>The Vertebrate Mitochondrial Code</label>
				<value>NT2AA3</value>
				<label>The Yeast Mitochondrial Code</label>
				<value>NT2AA4</value>
				<label>Mold, Protozoan, Coelenterate, Mycoplasma/Spiroplasma </label>
				<value>NT2AA5</value>
				<label>The Invertebrate Mitochondrial Code</label>
				<value>NT2AA6</value>
				<label>The Ciliate, Dasycladacean and Hexamita Nuclear Code </label>
				<value>NT2AA9</value>
				<label>The Echinoderm and Flatworm Mitochondrial Code</label>
				<value>NT2AA10</value>
				<label>The Euplotid Nuclear Code</label>
				<value>NT2AA11</value>
				<label>The Bacterial, Archaeal and Plant Plastid Code</label>
				<value>NT2AA12</value>
				<label>The Alternative Yeast Nuclear Code</label>
				<value>NT2AA13</value>
				<label>The Ascidian Mitochondrial Code</label>
				<value>NT2AA14</value>
				<label>The Alternative Flatworm Mitochondrial Code</label>
				<value>NT2AA16</value>
				<label>Chlorophycean Mitochondrial Code</label>
				<value>NT2AA21</value>
				<label>Trematode Mitochondrial Code</label>
				<value>NT2AA22</value>
				<label>Scenedesmus obliquus Mitochondrial Code </label>
				<value>NT2AA23</value>
				<label>Thraustochytrium Mitochondrial Code</label>
				<value>NT2AA24</value>
				<label>Pterobranchia Mitochondrial Code</label>
				<value>NT2AA25</value>
				<label>Candidate Division SR1 and Gracilibacteria Code</label>
			</vlist>
			<vdef>
				<value>NT2AA1</value>
			</vdef>
<!--			<ctrls>
				<ctrl>
					<message>Please enter a name for your output file</message>
					<language>perl</language>
					<code>!defined $name_output</code>
				</ctrl>
			</ctrls> -->
			<group>3</group>
		</attributes>
	</parameter>

<!-- partitioning -->
			<parameter type="Excl">
				<name>partition_type</name>
				<attributes>
					<prompt>Please specify your partition type</prompt>
					<vlist>
						<value>-q</value>
						<label>Edge-equal partition model (-q)</label>
						<value>-spp</value>
						<label>Allow partitions to have different speeds (-spp)</label>
						<value>-sp</value>
						<label>Edge-unlinked partition model (-sp)</label>
					</vlist>
					<format>
						<language>perl</language>
						<code>(defined $value) ? "$partition_type partition.txt":""</code>
					</format>
					<ctrls>
						<ctrl>
							<message>Please select a partition file</message>
							<language>perl</language>
							<code>defined $partition_type &amp;&amp; !defined $partition_file </code>
						</ctrl>
						<ctrl>
							<message>Sorry, a bug in this version will prevent the use of -sp with a partiton file, please use the -spp option</message>
							<language>perl</language>
							<code>$partition_type eq "-sp" &amp;&amp; $use_bnni &amp;&amp; $which_iqtree &lt;= 9 </code>
						</ctrl>
					</ctrls>
				</attributes>
			</parameter>
			
			<parameter type="InFile">
				<name>partition_file</name>
				<attributes>
					<prompt>Please select your partition file</prompt>
					<precond>
						<language>perl</language>
						<code>defined $partition_type</code>
					</precond>
					<filenames>partition.txt</filenames>
				</attributes>
			</parameter>
			
<!-- Yes! You can specify this via a NEXUS partition file. In fact, you can mix any data types supported in IQ-TREE,
 including also codon, binary and morphological data. To do so, each data type should be stored in a separate 
 alignment file (see also Partitioned analysis with mixed data). As an example, assuming dna.phy is a DNA alignment
 and and prot.phy is a protein alignment. Then a partition file mixing two types of data can be specified as follows:
 #nexus
begin sets;
    charset part1 = dna.phy: 1-100 201-300;
    charset part2 = dna.phy: 101-200;
    charset part3 = prot.phy: 1-150;
    charset part4 = prot.phy: 151-400;
    charpartition mine = HKY:part1, GTR+G:part2, WAG+I+G:part3, LG+G:part4;
end;
 -->
 
<parameter  ismandatory = "0" type="Switch"> 
	<name>mixed_sequence</name>
		<attributes>
			<prompt>I want to mix data types in a partitioned analysis</prompt>
			<precond>
				<language>perl</language>
				<code>defined $partition_type</code>
			</precond>
			<vdef>
				<value>0</value>
			</vdef>
		</attributes>
	</parameter>
	
	<parameter  ismandatory = "0" type="Excl"> 
	<name>num_mixedsequences</name>
		<attributes>
			<prompt>How many data types (files) in your partitioned analysis</prompt>
			<precond>
				<language>perl</language>
				<code>$mixed_sequence</code>
			</precond>
			<vlist>
				<value>2</value>
				<label>2</label>
				<value>3</value>
				<label>3</label>
				<value>4</value>
				<label>4</label>
				<value>5</value>
				<label>5</label>
			</vlist>
		</attributes>
	</parameter>
	
	<parameter ismandatory = "0" type="InFile"> 
	<name>datatype2_file</name>
		<attributes>
			<prompt>Select the file with your second datatype (partition_datatype2.phy)</prompt>
			<precond>
				<language>perl</language>
				<code>$num_mixedsequences &gt; 1 </code>
			</precond>
			<filenames>partition_datatype2.phy</filenames>
		</attributes>
	</parameter>
	
	<parameter ismandatory = "0" type="InFile"> 
	<name>datatype3_file</name>
		<attributes>
			<prompt>Select the file with your third datatype (partition_datatype3.phy)</prompt>
			<precond>
				<language>perl</language>
				<code>$num_mixedsequences &gt; 2 </code>
			</precond>
			<filenames>partition_datatype3.phy</filenames>
		</attributes>
	</parameter>
	
	<parameter ismandatory = "0" type="InFile"> 
	<name>datatype4_file</name>
		<attributes>
			<prompt>Select the file with your fourth datatype (partition_datatype4.phy)</prompt>
			<precond>
				<language>perl</language>
				<code>$num_mixedsequences &gt; 3 </code>
			</precond>
			<filenames>partition_datatype4.phy</filenames>
		</attributes>
	</parameter>
	
	<parameter ismandatory = "0" type="InFile"> 
	<name>datatype5_file</name>
		<attributes>
			<prompt>Select the file with your fifth datatype (partition_datatype5.phy)</prompt>
			<precond>
				<language>perl</language>
				<code>$num_mixedsequences &gt; 4 </code>
			</precond>
			<filenames>partition_datatype5.phy</filenames>
		</attributes>
	</parameter>

	
<!-- 	specify a starting tree -->
	<parameter  issimple="1" type="InFile"> 
	<name>starting_tree</name>
		<attributes>
			<prompt>Specify a starting (or other) tree file (-t)</prompt>
			<filenames>treefile.tre</filenames>
			<format>
				<language>perl</language>
				<code>(defined $value) ? "-t treefile.tre":""</code>
			</format>
			<group>3</group>
		</attributes>
	</parameter>

<!-- -t bionj starting tree -->
	<parameter  issimple="1" type="Switch"> 
	<name>use_nj</name>
		<attributes>
			<prompt>Use a NJ starting tree (-t BIONJ)</prompt>
			<precond>
				<language>perl</language>
				<code>!defined $starting_tree</code>
			</precond>
			<format>
				<language>perl</language>
				<code>($value) ? "-t BIONJ":"" </code>
			</format>
			<ctrls>
				<ctrl>
					<message>Sorry, you cannot choose both a random and a NJ starting tree</message>
					<language>perl</language>
					<code>$use_nj &amp;&amp; $use_random</code>
				</ctrl>
			</ctrls>
			<group>3</group>
		</attributes>
	</parameter>
	
	<!-- 	-t random starting tree -->
	<parameter  issimple="1" type="Switch"> 
	<name>use_random</name>
		<attributes>
			<prompt>Use a Random starting tree (-t RANDOM) </prompt>
			<precond>
				<language>perl</language>
				<code>!defined $starting_tree</code>
			</precond>
			<format>
				<language>perl</language>
				<code>($value) ? "-t RANDOM":""</code>
			</format>
			<group>3</group>			
		</attributes>
	</parameter>
	
<!-- 	-o Specify an outgroup. -->
	<parameter  issimple="1" type="String"> 
	<name>specify_outgroup</name>
		<attributes>
			<prompt>Specify the outgroup (-o)</prompt>
			<format>
				<language>perl</language>
				<code>(defined $value) ?  "-o $value":""</code>
			</format>
			<group>3</group>
		</attributes>
	</parameter>

<!-- -pre specify prefix for output files -->
	<parameter  issimple="1" type="String"> 
	<name>specify_prefix</name>
		<attributes>
			<prompt>Specify the prefix for output files (-pre)</prompt>
			<format>
				<language>perl</language>
				<code>(defined $value) ?  "-pre $value":""</code>
			</format>
			<vdef>
				<value>output</value>
			</vdef>
			<group>3</group>
		</attributes>
	</parameter>
	
<!-- -seed specify seed -->
	<parameter  issimple="1" type="Integer"> 
	<name>specify_seed</name>
		<attributes>
			<prompt>Specify the seed (-seed)</prompt>
			<format>
				<language>perl</language>
				<code>(defined $value) ?  "-seed $value":""</code>
			</format>
			<group>3</group>
		</attributes>
	</parameter>

<!-- -lmap Specify the number of quartets to be randomly drawn. If you specify -lmap ALL, all unique quartets will be drawn, instead. -->
	<parameter  issimple="1" type="Integer"> 
	<name>specify_quartets</name>
		<attributes>
			<prompt>Specify number of quartets (-lmap)</prompt>
			<format>
				<language>perl</language>
				<code>(defined $value) ? "-lmap $value":""</code>
			</format>
			<group>3</group>
		</attributes>
	</parameter>

<!-- autmoatic model selection  -->	
<parameter type="Paragraph">
	<paragraph>
		<name>model_selection</name>
		<prompt>Automatic Model Selection Parameters</prompt>
		<parameters>
<!-- Automatic model selection
The default model (e.g., HKY+F for DNA, LG for protein data) may not fit well to the data. Therefore, IQ-TREE allows to automatically determine the best-fit model via a series of -m TEST... option:
Usage and meaning
-m TESTONLY Perform standard model selection like jModelTest (for DNA) and ProtTest (for protein). Moreover, IQ-TREE also works for codon, binary and morphogical data. 
-m TEST Like -m TESTONLY but immediately followed by tree reconstruction using the best-fit model found. So this performs both model selection and tree inference within a single run. 
-m TESTNEWONLY or -m MF Perform an extended model selection that additionally includes FreeRate model compared with -m TESTONLY. Recommended as replacement for -m TESTONLY. Note that LG4X is a FreeRate model, but by default is not included because it is also a protein mixture model. To include it, use -madd option (see table below). 
-m TESTNEW or -m MFP Like -m MF but immediately followed by tree reconstruction using the best-fit model found. 
-m TESTMERGEONLY Select best-fit partitioning scheme like PartitionFinder. 
-m TESTMERGE Like -m TESTMERGEONLY but immediately followed by tree reconstruction using the best partitioning scheme found. 
-m TESTNEWMERGEONLY or -m MF+MERGE Like -m TESTMERGEONLY but additionally includes FreeRate model. 
-m TESTNEWMERGE or -m MFP+MERGE Like -m MF+MERGE but immediately followed by tree reconstruction using the best partitioning scheme found. 
  -->
  
			<parameter  issimple="0" type="Excl"> 
				<name>specify_model</name>
				<attributes>
					<prompt>Test for the best model (-m TEST)</prompt>
<!--  					<precond>
						<language>perl</language>
						<code>$specify_runtype == 1</code>
					</precond> -->
					<vlist>
						<value>TESTONLY</value>
						<label>TESTONLY</label>
						<value>TEST</value>
						<label>TEST</label>
						<value>TESTNEWONLY</value>
						<label>TESTNEWONLY</label>
						<value>TESTNEW</value>
						<label>TESTNEW</label>
						<value>TESTMERGEONLY</value>
						<label>TESTMERGEONLY</label>
						<value>TESTMERGE</value>
						<label>TESTMERGE</label>
						<value>TESTNEWMERGEONLY</value>
						<label>TESTNEWMERGEONLY</label>
						<value>TESTNEWMERGE</value>
						<label>TESTNEWMERGE</label>
					</vlist>
					<format>
						<language>perl</language>
						<code>(defined $value) ?  "-m $value":""</code>
					</format>
					<group>3</group>
				</attributes>
			</parameter>

<!-- -rcluster Specify the percentage for the relaxed clustering algorithm (Lanfear et al., 2014). This is similar to -*rcluster-percent option of PartitionFinder. For example, with -rcluster 10 only the 
top 10% partition schemes are considered to save computations.  -->	
			<parameter  issimple="0" type="Integer"> 
				<name>specify_rcluster</name>
				<attributes>
					<prompt>Specify the percentage for relaxed clustering algorithm (-rcluster)</prompt>
					<format>
						<language>perl</language>
						<code>(defined $value) ?  "-rcluster $value":""</code>
					</format>
					<group>3</group>
				</attributes>
			</parameter>
	
<!-- -mset Specify the name of a program (raxml, phyml or mrbayes) to restrict to only those models supported by the specified program. Alternatively, one can specify a comma-separated list of base models. 
For example, -mset WAG,LG,JTT will restrict model selection to WAG, LG, and JTT instead of all 18 AA models to save computations.  -->	
			<parameter  issimple="0" type="String"> 
				<name>specify_basemodels</name>
				<attributes>
					<prompt>Specify names of the base models or program (-mset)</prompt>
					<precond>
						<language>perl</language>
						<code>$specify_runtype == 1</code>
					</precond>
					<format>
						<language>perl</language>
						<code>(defined $value) ?  "-mset $value":""</code>
					</format>
					<group>3</group>
					<comment>
						<value>For -mset, specify the name of a program (raxml, phyml or mrbayes) to restrict to 
					only those models supported by the specified program. Alternatively, one can specify a 
					comma-separated list of base models. For example, -mset WAG,LG,JTT will restrict model 
					selection to WAG, LG, and JTT instead of all 18 AA models to save computations.
						</value>
					</comment>
				</attributes>
			</parameter>
	
<!-- -msub Specify either nuclear, mitochondrial, chloroplast or viral to restrict to those AA models designed for specified source.   -->	
			<parameter  issimple="0" type="Excl"> 
				<name>specify_aamodels</name>
				<attributes>
					<prompt>Specify nuclear, mitochondrial, chloroplast or viral (-msub, protein)</prompt>
					<precond>
						<language>perl</language>
						<code>$sequence_type eq "AA" &amp;&amp; $specify_runtype == 1 </code>
					</precond>
					<vlist>
						<value>nuclear</value>
						<label>Nuclear</label>
						<value>mitochondrial</value>
						<label>Mitochondrial</label>
						<value>chloroplast</value>
						<label>Chloroplast</label>
						<value>viral</value>
						<label>Viral</label>
					</vlist>
					<format>
						<language>perl</language>
						<code>(defined $value) ?  "-msub $value":""</code>
					</format>
					<group>3</group>
				</attributes>
			</parameter>
	
<!-- -mfreq Specify a comma-separated list of frequency types for model selection. DEFAULT: -mfreq FU,F for protein models (FU = AA frequencies given by the protein matrix, F = empirical AA frequencies
 from the data), -mfreq ,F1x4,F3x4,F for codon models   -->	
			<parameter  issimple="0" type="String"> 
				<name>specify_freqtypes</name>
				<attributes>
					<prompt>Specify a comma-separated list of frequency types for model selection (-mfreq)</prompt>
					<precond>
						<language>perl</language>
						<code>$specify_runtype == 1</code>
					</precond>
					<format>
						<language>perl</language>
						<code>(defined $value) ?  "-mfreq $value":""</code>
					</format>
					<group>3</group>
				</attributes>
			</parameter>
	
<!-- -mrate Specify a comma-separated list of rate heterogeneity types for model selection. DEFAULT: -mrate E,I,G,I+G for standard procedure, -mrate E,I,G,I+G,R for new selection procedure    -->	
			<parameter  issimple="0" type="String"> 
				<name>specify_ratehettypes</name>
				<attributes>
					<prompt>Specify a comma-separated list of rate heterogeneity types for model selection (-mrate)</prompt>
					<precond>
						<language>perl</language>
						<code>$specify_runtype == 1</code>
					</precond>
					<format>
						<language>perl</language>
						<code>(defined $value) ?  "-mrate $value":""</code>
					</format>
					<group>3</group>
				</attributes>
			</parameter>
	
<!-- -cmin Specify minimum number of categories for FreeRate model. DEFAULT: 2     -->	
			<parameter  issimple="0" type="Integer"> 
				<name>specify_mincat</name>
				<attributes>
					<prompt>Specify minimum number of categories for FreeRate model (-cmin)</prompt>
					<precond>
						<language>perl</language>
						<code>$specify_runtype == 1</code>
					</precond>
					<format>
						<language>perl</language>
						<code>(defined $value) ?  "-cmin $value":""</code>
					</format>
					<group>3</group>
				</attributes>
			</parameter>
	
<!-- -cmax Specify maximum number of categories for FreeRate model. It is recommended to increase if alignment is long enough. DEFAULT: 10     -->	
			<parameter  issimple="0" type="Integer"> 
			<name>specify_maxcat</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$specify_runtype == 1</code>
					</precond>
					<prompt>Specify maximum number of categories for FreeRate model (-cmax)</prompt>
					<format>
						<language>perl</language>
						<code>(defined $value) ?  "-cmax $value":""</code>
					</format>
					<group>3</group>
				</attributes>
			</parameter>
	
<!-- Specify either AIC, AICc or BIC for the optimality criterion to apply for new procedure. DEFAULT: all three criteria are considered    -->	
			<parameter  issimple="0" type="String"> 
			<name>specify_merit</name>
				<attributes>
					<prompt>Specify either AIC, AICc or BIC for the optimality criterion (-merit)</prompt>
					<precond>
						<language>perl</language>
						<code>$specify_runtype == 1</code>
					</precond>
					<format>
						<language>perl</language>
						<code>(defined $value) ?  "-merit $value":""</code>
					</format>
					<group>3</group>
				</attributes>
			</parameter>
	
<!-- Turn on full tree search for each model considered, to obtain more accurate result. Only recommended if enough computational resources are available. DEFAULT: fixed starting tree   -->	
			<parameter  issimple="0" type="Switch"> 
			<name>specify_fulltreesearch</name>
				<attributes>
					<prompt>Turn on full tree search for each model considered, to obtain more accurate result. (-mtree)</prompt>
					<precond>
						<language>perl</language>
						<code>$specify_runtype == 1</code>
					</precond>
					<format>
						<language>perl</language>
						<code>($value) ?  "-mtree":""</code>
					</format>
					<group>3</group>
				</attributes>
			</parameter>
	
<!-- -madd Specify a comma-separated list of mixture models to additionally consider for model selection. For example, -madd LG4M,LG4X to additionally include these two protein mixture models.    -->	
			<parameter  issimple="0" type="String"> 
			<name>specify_addlmodels</name>
				<attributes>
					<prompt>Specify a comma-separated list of mixture models to additionally consider for model selection. (-madd)</prompt>
					<precond>
						<language>perl</language>
						<code>$specify_runtype == 1</code>
					</precond>
					<format>
						<language>perl</language>
						<code>(defined $value) ?  "-madd $value":""</code>
					</format>
					<group>3</group>
				</attributes>
			</parameter>

<!-- -mdef Specify a NEXUS model file to define new models. Not supported yet. -->
		</parameters>
	</paragraph>
</parameter>  

<!-- Specifying substitution models -->
<parameter type="Paragraph">
	<paragraph>
		<name>specify_subst</name>
		<prompt>Specify Substitution Models</prompt>
			<parameters>
			
						
			<parameter  issimple="0" type="String"> 
					<name>freetextmodel</name>
					<attributes>
						<prompt>Specify any model using free text (-m)</prompt>
						<precond>
							<language>perl</language>
							<code> $specify_runtype == 2</code>
						</precond>
						<ctrls>
							<ctrl>
								<message>Sorry, you cant specify a DNA model and use the free text entry</message>
								<language>perl</language>
								<code>defined $freetextmodel &amp;&amp; defined $specify_dnamodel</code>
							</ctrl>
						</ctrls>
						<group>3</group>
				</attributes>
			</parameter>
			
				<parameter ishidden= "1" type="String">
					<name>dnamodel_string</name>
					<attributes>
						<precond>
							<language>perl</language>
							<code>$sequence_type eq "DNA" &amp;&amp; $specify_runtype == 2</code>
						</precond>
					<format>
						<language>perl</language>
						<code>(defined $specify_dnamodel) ? "-m $specify_dnamodel$specify_modelfreq$specify_modelrate$asc_bias":""</code>
					</format>
					</attributes>
				</parameter>
				
				<parameter ishidden= "1" type="String">
					<name>model_string2</name>
					<attributes>
						<precond>
							<language>perl</language>
							<code>$specify_runtype == 2</code>
						</precond>
					<format>
						<language>perl</language>
						<code>(defined $freetextmodel) ? "-m $freetextmodel":""</code>
					</format>
					</attributes>
				</parameter>
				
				<parameter  issimple="0" type="Excl"> 
					<name>specify_dnamodel</name>
					<attributes>
						<prompt>Specify a DNA model (-m )</prompt>
						<precond>
							<language>perl</language>
							<code>$sequence_type eq "DNA" &amp;&amp; $specify_runtype == 2</code>
						</precond>
						<vlist>
							<value>JC69</value>
							<label>JC/JC69</label>
							<value>F81</value>
							<label>F81</label>
							<value>K80</value>
							<label>K2P/K80</label>
							<value>HKY</value>
							<label>HKY/HKY85</label>
							<value>TN93</value>
							<label>TN/TrN/TN93</label>
							<value>TNe</value>
							<label>TNe</label>
							<value>K81</value>
							<label>K3P/K81</label>
							<value>K81u</value>
							<label>K81u</label>
							<value>TPM2</value>
							<label>TPM2</label>
							<value>TPM2u</value>
							<label>TPM2u</label>
							<value>TPM3</value>
							<label>TPM3</label>
							<value>TPM3u</value>
							<label>TPM3u</label>
							<value>TIM</value>
							<label>TIM</label>
							<value>TIMe</value>
							<label>TIMe</label>
							<value>TIM2</value>
							<label>TIM2</label>
							<value>TIM2e</value>
							<label>TIM2e</label>
							<value>TIM3</value>
							<label>TIM3</label>
							<value>TIM3e</value>
							<label>TIM3e</label>
							<value>TVM</value>
							<label>TVM</label>
							<value>TVMe</value>
							<label>TVMe</label>
							<value>SYM</value>
							<label>SYM</label>
							<value>GTR</value>
							<label>GTR</label>
						</vlist>
						<group>3</group>
						<ctrls>
							<ctrl>
								<message>Sorry, you cant specify a DNA model and run a model test </message>
								<language>perl</language>
								<code>defined $specify_model &amp;&amp; defined $value</code>
							</ctrl>
						</ctrls>
                    </attributes>
                </parameter>

				<parameter ishidden= "1" type="String">
					<name>aamodel_string</name>
					<attributes>
						<precond>
							<language>perl</language>
							<code>$sequence_type eq "AA" &amp;&amp; $specify_runtype == 2</code>
						</precond>
					<format>
						<language>perl</language>
						<code>(defined $specify_protmodel) ? "-m $specify_protmodel$specify_protmixture$specify_modelfreq$specify_modelrate":""</code>
					</format>
					</attributes>
				</parameter>
				
<!-- 			<parameter ishidden= "1" type="String">
					<name>aamodel_string2</name>
					<attributes>
						<precond>
							<language>perl</language>
							<code>$sequence_type eq "AA" &amp;&amp; $specify_runtype == 2 &amp;&amp; defined $freetextprotmodel</code>
						</precond>
					<format>
						<language>perl</language>
						<code>(defined $freetextprotmodel) ? "-m $freetextprotmodel":""</code>
					</format>
					</attributes>
				</parameter>  -->
					
				<parameter  issimple="0" type="Excl"> 
					<name>specify_protmodel</name>
					<attributes>
						<prompt>Specify a Protein model (-m )</prompt>
						<precond>
							<language>perl</language>
							<code>($sequence_type eq "AA" || $sequence_type eq "NT2AA") &amp;&amp; $specify_runtype == 2 </code>
						</precond>
						<vlist>
							<value>BLOSUM62</value>
							<label>BLOSUM62</label>
							<value>cpREV</value>
							<label>cpREV</label>
							<value>Dayhoff</value>
							<label>Dayhoff</label>
							<value>DCMut</value>
							<label>DCMut</label>
							<value>FLU</value>
							<label>FLU</label>
							<value>HIVb</value>
							<label>HIVb</label>
							<value>HIVw</value>
							<label>HIVw</label>
							<value>JTT</value>
							<label>JTT</label>
							<value>JTTDCMut</value>
							<label>JTTDCMut</label>
							<value>LG</value>
							<label>LG</label>
							<value>mtART</value>
							<label>mtART</label>
							<value>mtMAM</value>
							<label>mtMAM</label>
							<value>mtREV</value>
							<label>mtREV</label>
							<value>mtZOA</value>
							<label>mtZOA</label>
							<value>Poisson</value>
							<label>Poisson</label>
							<value>PMB</value>
							<label>PMB</label>
							<value>rtREV</value>
							<label>rtREV</label>
							<value>VT</value>
							<label>VT</label>
							<value>WAG</value>
							<label>WAG</label>
							<value>C10</value>
							<label>C10</label>
							<value>C20</value>
							<label>C20</label>
							<value>C30</value>
							<label>C30</label>
							<value>C40</value>
							<label>C40</label>
							<value>C50</value>
							<label>C50</label>
							<value>C60</value>
							<label>C60</label>
							<value>EX2</value>
							<label>EX2</label>
							<value>EX3</value>
							<label>EX3</label>
							<value>EHO</value>
							<label>EHO</label>
							<value>UL2</value>
							<label>UL2</label>
							<value>UL3</value>
							<label>UL3</label>
							<value>EX_EHO</value>
							<label>EX_EHO</label>
							<value>LG4M</value>
							<label>LG4M</label>
							<value>LG4X</value>
							<label>LG4X</label>
							<value>CF4</value>
							<label>CF4</label>
						</vlist>
						<ctrls>
							<ctrl>
								<message>Sorry, you cant specify a protein model and use the free text entry</message>
								<language>perl</language>
								<code>defined $freetextmodel &amp;&amp; defined $specify_protmodel</code>
							</ctrl>
						</ctrls>
						<group>3</group>
				</attributes>
			</parameter>

				<parameter  issimple="0" type="Excl"> 
					<name>specify_protmixture</name>
					<attributes>
						<prompt>Specify a Protein Profile mixture</prompt>
						<precond>
							<language>perl</language>
							<code>($sequence_type eq "AA" || $sequence_type eq "NT2AA") &amp;&amp; $specify_runtype == 2 &amp;&amp; defined $specify_protmodel</code>
						</precond>
						<vlist>
							<value>+C10</value>
							<label>C10</label>
							<value>+C20</value>
							<label>C20</label>
							<value>+C30</value>
							<label>C30</label>
							<value>+C40</value>
							<label>C40</label>
							<value>+C50</value>
							<label>C50</label>
							<value>+C60</value>
							<label>C60</label>
							<value>+EX2</value>
							<label>EX2</label>
							<value>+EX3</value>
							<label>EX3</label>
							<value>+EHO</value>
							<label>EHO</label>
							<value>+UL2</value>
							<label>UL2</label>
							<value>+UL3</value>
							<label>UL3</label>
							<value>+EX_EHO</value>
							<label>EX_EHO</label>
							<value>+LG4M</value>
							<label>LG4M</label>
							<value>+LG4X</value>
							<label>LG4X</label>
							<value>+CF4</value>
							<label>CF4</label>
						</vlist>
						
<!-- C10 to C60 10, 20, 30, 40, 50, 60-profile mixture models (Le et al., 2008a) as variants of the CAT model (Lartillot and Philippe, 2004) for ML. Note that these models assume Poisson AA replacement and implicitly include a Gamma rate heterogeneity among sites. 
EX2 Two-matrix model for exposed/buried AA sites (Le et al., 2008b). 
EX3 Three-matrix model for highly exposed/intermediate/buried AA sites (Le et al., 2008b). 
EHO Three-matrix model for extended/helix/other sites (Le et al., 2008b). 
UL2, UL3 Unsupervised-learning variants of EX2 and EX3, respectively. 
EX_EHO Six-matrix model combining EX2 and EHO (Le and Gascuel, 2010). 
LG4M Four-matrix model fused with Gamma rate heterogeneity (Le et al., 2012). 
LG4X Four-matrix model fused with FreeRate heterogeneity (Le et al., 2012). 
CF4 
 -->
						<group>3</group>
				</attributes>
			</parameter>
			
<!--  specify_protmodel		-->				
				
<!--  				<parameter  issimple="0" type="String"> 
					<name>freetextprotmodel</name>
					<attributes>
						<prompt>Specify Protein model using free text (-m)</prompt>
						<precond>
							<language>perl</language>
							<code>($sequence_type eq "AA" || $sequence_type eq "NT2AA") &amp;&amp; $specify_runtype == 2</code>
						</precond>
						<ctrls>
							<ctrl>
								<message>Sorry, you cant specify a protein model and use the free text entry</message>
								<language>perl</language>
								<code>defined $freetextprotmodel &amp;&amp; defined $specify_protmodel</code>
							</ctrl>
						</ctrls>
						<group>3</group>
				</attributes>
			</parameter>-->
			
<!-- 	specify a guide tree -->
	<parameter  type="InFile"> 
	<name>guide_tree</name>
		<attributes>
			<prompt>If you want to use PMSF, specify a guide tree file (-ft)</prompt>
			<filenames>guidetree.tre</filenames>
			<precond>
					<language>perl</language>
					<code>($sequence_type eq "AA" || $sequence_type eq "NT2AA") &amp;&amp; $specify_runtype == 2</code>
			</precond>
			<format>
				<language>perl</language>
				<code>(defined $value) ? "-ft guidetree.tre":""</code>
			</format>
			<group>3</group>
		</attributes>
	</parameter>
					
				<parameter ishidden= "1" type="String">
					<name>binmodel_string</name>
					<attributes>
						<precond>
							<language>perl</language>
							<code>$sequence_type eq "BIN" &amp;&amp; $specify_runtype == 2</code>
						</precond>
					<format>
						<language>perl</language>
						<code>(defined $specify_binmodel) ? "-m $specify_binmodel$specify_modelfreq$specify_modelrate":""</code>
					</format>
					</attributes>
				</parameter>
				
<!--  				<parameter ishidden= "1" type="String">
					<name>binmodel_string2</name>
					<attributes>
						<precond>
							<language>perl</language>
							<code>($sequence_type eq "BIN" || $sequence_type eq "MORPH") &amp;&amp; $specify_runtype == 2</code>
						</precond>
					<format>
						<language>perl</language>
						<code>(defined $freetextmodel) ? "-m $freetextmodel":""</code>
					</format>
					</attributes>
				</parameter> -->
			
			<parameter  issimple="0" type="Excl"> 
					<name>specify_binmodel</name>
					<attributes>
						<prompt>Specify a Binary/Morphological model (-m )</prompt>
						<precond>
							<language>perl</language>
							<code>($sequence_type eq "BIN" || $sequence_type eq "MORPH") &amp;&amp; $specify_runtype == 2</code>
						</precond>
<!-- JC2 Jukes-Cantor type model for binary data. GTR2 General time reversible model for binary data. 
MK Jukes-Cantor type model for morphological data. ORDERED Allowing exchange of neighboring states only. -->
						<vlist>
							<value>JC2</value>
							<label>JC2</label>
							<value>GTR2</value>
							<label>GTR2</label>
							<value>MK</value>
							<label>MK</label>
							<value>ORDERED</value>
							<label>Ordered</label>
						</vlist>
						<ctrls>
							<ctrl>
								<message>Sorry, you cant specify a BIN model and use the free text entry</message>
								<language>perl</language>
								<code>defined $freetextmodel &amp;&amp; defined $specify_binmodel</code>
							</ctrl>
						</ctrls>
						<group>3</group>
				</attributes>
			</parameter>
				
<!--  		<parameter  issimple="0" type="String"> 
					<name>freetextbinmodel</name>
					<attributes>
						<prompt>Specify Binary/Morphological model using free text (-m)</prompt>
						<precond>
							<language>perl</language>
							<code>($sequence_type eq "BIN" || $sequence_type eq "MORPH")  &amp;&amp; $specify_runtype == 2</code>
						</precond>
						<ctrls>
							<ctrl>
								<message>Sorry, you cant specify a BIN model and use the free text entry</message>
								<language>perl</language>
								<code>defined $freetextbinmodel &amp;&amp; defined $specify_binmodel</code>
							</ctrl>
						</ctrls>
						<group>3</group>
				</attributes>
			</parameter>			-->
													
				<parameter ishidden= "1" type="String">
					<name>codonmodel_string</name>
					<attributes>
						<precond>
							<language>perl</language>
							<code>$sequence_type eq "CODON" &amp;&amp; $specify_runtype == 2</code>
						</precond>
					<format>
						<language>perl</language>
						<code>(defined $specify_codonmodel) ? "-m $specify_codonmodel$specify_modelfreq$specify_modelrate":""</code>
					</format>
					</attributes>
				</parameter>
				
<!--			<parameter ishidden= "1" type="String">
					<name>codonmodel_string2</name>
					<attributes>
						<precond>
							<language>perl</language>
							<code>($sequence_type eq "CODON") &amp;&amp; $specify_runtype == 2</code>
						</precond>
					<format>
						<language>perl</language>
						<code>(defined $freetextcodonmodel) ? "-m $freetextcodonmodel":""</code>
					</format>
					</attributes>
				</parameter>	-->
			
				<parameter  issimple="0" type="Excl"> 
					<name>specify_codonmodel</name>
					<attributes>
						<prompt>Specify a Codon model (-m )</prompt>
						<precond>
							<language>perl</language>
							<code>$sequence_type eq "CODON" &amp;&amp; $specify_runtype == 2</code>
						</precond>
<!-- JC2 Jukes-Cantor type model for binary data. GTR2 General time reversible model for binary data. 
MK Jukes-Cantor type model for morphological data. ORDERED Allowing exchange of neighboring states only. -->
						<vlist>
							<value>MG</value>
							<label>MG</label>
							<value>MGK</value>
							<label>MGK</label>
							<value>MG1KTS</value>
							<label>MG1KTS</label>
							<value>MG1KTV</value>
							<label>MG1KTV</label>
							<value>MG2K</value>
							<label>MG2K</label>
							<value>GY</value>
							<label>GY</label>
							<value>GY1KTS</value>
							<label>GY1KTS</label>
							<value>GY1KTV</value>
							<label>GY1KTV</label>
							<value>GY2K</value>
							<label>GY2K</label>
							<value>KOSI07</value>
							<label>ECMK07/KOSI07</label>
							<value>ECMrest</value>
							<label>ECMrest</label>
							<value>SCHN05</value>
							<label>ECMS05/SCHN05</label>
						</vlist>
						<ctrls>
							<ctrl>
								<message>Sorry, you cant specify a CODON model and use the free text entry</message>
								<language>perl</language>
								<code>defined $freetextmodel &amp;&amp; defined $specify_codonmodel</code>
							</ctrl>
						</ctrls>
						<group>3</group>
				</attributes>
			</parameter>
			
<!--  		<parameter  issimple="0" type="String"> 
					<name>freetextcodonmodel</name>
					<attributes>
						<prompt>Specify Codon model using free text (-m)</prompt>
						<precond>
							<language>perl</language>
							<code>($sequence_type eq "CODON")  &amp;&amp; $specify_runtype == 2</code>
						</precond>
						<ctrls>
							<ctrl>
								<message>Sorry, you cant specify a CODON model and use the free text entry</message>
								<language>perl</language>
								<code>defined $freetextcodonmodel &amp;&amp; defined $specify_codonmodel</code>
							</ctrl>
						</ctrls>
						<group>3</group>
				</attributes>
			</parameter>	-->
			
<!-- +F Empirical state frequency observed from the data. 
+FO State frequency optimized by maximum-likelihood from the data. Note that this is with letter-O and not digit-0. 
+FQ Equal state frequency. 
+F1x4 See Codon frequencies. 
+F3x4 See Codon frequencies. 
 -->
 				<parameter  issimple="0" type="Excl"> 
					<name>specify_modelfreq</name>
					<attributes>
						<prompt>Specify model frequency</prompt>
<!-- JC2 Jukes-Cantor type model for binary data. GTR2 General time reversible model for binary data. 
MK Jukes-Cantor type model for morphological data. ORDERED Allowing exchange of neighboring states only. -->
						<precond>
							<language>perl</language>
							<code>$specify_runtype == 2</code>
						</precond>
						<vlist>
							<value>+F</value>
							<label>Empirical state frequency</label>
							<value>+FO</value>
							<label>State frequency optimized by maximum-likelihood</label>
							<value>+FQ</value>
							<label>Equal state frequency</label>
							<value>+F1x4</value>
							<label>+F1x4</label>
							<value>+F3x4</value>
							<label>+F3x4</label>
						</vlist>
						<group>3</group>
				</attributes>
			</parameter>

<!-- +I Allowing for a proportion of invariable sites. 
+G Discrete Gamma model (Yang, 1994) with default 4 rate categories. The number of categories can be changed with e.g. +G8. 
+I+G Invariable site plus discrete Gamma model (Gu et al., 1995). 
+R FreeRate model (Yang, 1995; Soubrier et al., 2012) that generalizes +G by relaxing the assumption of Gamma-distributed rates. The number of categories can be specified with e.g. +R6. DEFAULT: 4 categories 
+I+R invariable site plus FreeRate model. 
 -->
			 <parameter  issimple="0" type="Excl"> 
					<name>specify_modelrate</name>
					<attributes>
						<prompt>Specify rate heterogeneity</prompt>
<!-- JC2 Jukes-Cantor type model for binary data. GTR2 General time reversible model for binary data. 
MK Jukes-Cantor type model for morphological data. ORDERED Allowing exchange of neighboring states only. -->
						<precond>
							<language>perl</language>
							<code>$specify_runtype == 2</code>
						</precond>
						<vlist>
							<value>+I</value>
							<label>Invariable sites</label>
							<value>+G</value>
							<label>Discrete Gamma model</label>
							<value>+I+G</value>
							<label>Invariable site plus discrete Gamma model</label>
							<value>+R</value>
							<label>FreeRate model</label>
							<value>+I+R</value>
							<label>Invariable site plus FreeRate model</label>
						</vlist>
						<group>3</group>
				</attributes>
			</parameter>
			
<!-- Optionally, one can specify Ascertainment bias correction by appending +ASC to the model string. Advanced mixture models can also be specified via MIX{...} and FMIX{...} syntax. Option -mwopt can be used to turn on optimizing weights of mixture models.
 -->
					<parameter issimple="1" type="Excl">
					<name>asc_bias</name>
						<attributes>
							<prompt>Correct for Ascertainment bias (+ASC)</prompt>
						<precond>
							<language>perl</language>
							<code>$specify_runtype == 2</code>
						</precond>
							<vlist>
								<value>+ASC</value>
								<label>yes</label>
								<value></value>
								<label>no</label>
							</vlist>
							<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.</value>
							</comment>
						</attributes>
					</parameter>
			
<!-- -a Specify the Gamma shape parameter -->
				<parameter type="Float">
					<name>gamma_shape</name>
					<attributes>
						<prompt>Specify the Gamma shape parameter (-a)</prompt>
						<precond>
							<language>perl</language>
							<code>$specify_runtype == 2</code>
						</precond>
						<format>
							<language>perl</language>
							<code>(defined $value ) ? "-a $value":""</code>
						</format>
						<ctrls>
							<ctrl>
								<message>The gamma shape parameter must be greater than 0</message>
								<language>perl</language>
								<code>defined $gamma_shape &amp;&amp;  $gamma_shape &lt;= 0</code>
							</ctrl>
						</ctrls>
<!--  						<comment>
						<value>
Specify number of initial parsimony trees. DEFAULT: 100. Here the PLL library (Flouri et al., 2015) is used, which implements the randomized stepwise addition and parsimony subtree pruning and regafting (SPR).
						</value>
						</comment> -->
					</attributes>
				</parameter>
<!--  -gmedian Perform the median approximation for Gamma rate heterogeneity instead of the default mean approximation (Yang, 1994) -->
				<parameter type="Switch">
					<name>median_approximation</name>
					<attributes>
						<prompt>Perform the median approximation for Gamma rate heterogeneity (-gmedian)</prompt>
						<precond>
							<language>perl</language>
							<code>$specify_runtype == 2</code>
						</precond>
						<format>
							<language>perl</language>
							<code>($value ) ? "-gmedian":""</code>
						</format>
  						<comment>
						<value>
Perform the median approximation for Gamma rate heterogeneity instead of the default mean approximation (Yang, 1994)
						</value>
						</comment> 
					</attributes>
				</parameter>
				
<!-- -i Specify the proportion of invariable sites (default: estimate) -->
				<parameter type="Float">
					<name>invariable_sites</name>
					<attributes>
						<prompt>Specify the proportion of invariable sites (-i)</prompt>
						<precond>
							<language>perl</language>
							<code>$specify_runtype == 2</code>
						</precond> 
						<format>
							<language>perl</language>
							<code>(defined $value ) ? "-i $value":""</code>
						</format>
<!--   					<comment>
						<value>
Perform the median approximation for Gamma rate heterogeneity instead of the default mean approximation (Yang, 1994)
						</value>
						</comment> --> 
					</attributes>
				</parameter>
				
<!-- -*pt-gamma-inv Perform more thorough estimation for +I+G model parameters -->
				<parameter type="Switch">
					<name>thorough_estimation</name>
					<attributes>
						<prompt>Perform more thorough estimation for +I+G model parameters (--opt-gamma-inv)</prompt>
						<precond>
							<language>perl</language>
							<code>$specify_runtype == 2</code>
						</precond> 
						<format>
							<language>perl</language>
							<code>($value ) ? "--opt-gamma-inv":""</code>
						</format>
<!--   					<comment>
						<value>
Perform the median approximation for Gamma rate heterogeneity instead of the default mean approximation (Yang, 1994)
						</value>
						</comment> --> 
					</attributes>
				</parameter>
			
			</parameters>
	</paragraph>
</parameter>

<parameter type="Paragraph">
	<paragraph>
		<name>tree_search_params</name>
		<prompt>Tree Search Parameters</prompt>
			<parameters>
			
				<parameter type="Integer">
					<name>num_parstrees</name>
					<attributes>
						<prompt>Specify number of initial parsimony trees (-ninit)</prompt>
						<precond>
							<language>perl</language>
							<code>$specify_runtype == 2</code>
						</precond>
						<format>
							<language>perl</language>
							<code>(defined $value ) ? "-ninit $value":""</code>
						</format>
						<comment>
						<value>
Specify number of initial parsimony trees. DEFAULT: 100. Here the PLL library (Flouri et al., 2015) is used, which implements the randomized stepwise addition and parsimony subtree pruning and regafting (SPR).
						</value>
						</comment>
					</attributes>
				</parameter>
				
				<parameter type="Integer">
					<name>num_topparstrees</name>
					<attributes>
						<prompt>Specify number of top initial parsimony trees (-ntop)</prompt>
						<precond>
							<language>perl</language>
							<code>$specify_runtype == 2</code>
						</precond>
						<format>
							<language>perl</language>
							<code>(defined $value ) ? "-ntop $value":""</code>
						</format>
						<comment>
						<value>
Specify number of top initial parsimony trees to optimize with ML nearest neighbor interchange (NNI) search to initialize the candidate set. DEFAULT: 20
						</value>
						</comment>
					</attributes>
				</parameter>
				
				<parameter type="Integer">
					<name>num_besttrees</name>
					<attributes>
						<prompt>Number of trees in the candidate set to maintain (-nbest)</prompt>
						<precond>
							<language>perl</language>
							<code>$specify_runtype == 2</code>
						</precond>
						<format>
							<language>perl</language>
							<code>(defined $value ) ? "-nbest $value":""</code>
						</format>
						<comment>
						<value>
Specify number of trees in the candidate set to maintain during ML tree search. DEFAULT: 5
						</value>
						</comment>
					</attributes>
				</parameter>
				
				<parameter type="Integer">
					<name>num_unsucctostop</name>
					<attributes>
						<prompt>Number of unsuccessful iterations to stop (-nstop)</prompt>
						<precond>
							<language>perl</language>
							<code>$specify_runtype == 2</code>
						</precond>
						<format>
							<language>perl</language>
							<code>(defined $value ) ? "-nstop $value":""</code>
						</format>
						<comment>
						<value>
Specify number of unsuccessful iterations to stop. DEFAULT: 100
						</value>
						</comment>
					</attributes>
				</parameter>
				
				<parameter type="Integer">
					<name>num_tostop</name>
					<attributes>
						<prompt>Number of iterations to stop (-n)</prompt>
						<precond>
							<language>perl</language>
							<code>$specify_runtype == 2 &amp;&amp; $bootstrap_type ne "b" </code>
						</precond>
						<format>
							<language>perl</language>
							<code>(defined $value ) ? "-n $value":""</code>
						</format>
						<ctrls>
							<ctrl>
								<message>Sorry, the -n parameter cannot be used with Ultrafast Bootstrapping</message>
								<language>perl</language>
								<code>(defined $value) &amp;&amp; $bootstrap_type eq "bb"</code>
							</ctrl>
						</ctrls>
						<comment>
						<value>
Specify number of iterations to stop. This option overrides -nstop criterion. Use -n 0 to only estimate model parameters on an initial parsimony tree and ignore a full tree search to save time
						</value>
						</comment>
					</attributes>
				</parameter>
				
				<parameter type="Integer">
					<name>specify_radius</name>
					<attributes>
						<prompt>SPR radius for the initial search (-sprrad)</prompt>
						<precond>
							<language>perl</language>
							<code>$specify_runtype == 2</code>
						</precond>
						<format>
							<language>perl</language>
							<code>(defined $value ) ? "-sprrad $value":""</code>
						</format>
						<comment>
						<value>
Specify SPR radius for the initial parsimony tree search. DEFAULT: 6
						</value>
						</comment>
					</attributes>
				</parameter>
				
				<parameter type="Float">
					<name>perturb_strength</name>
					<attributes>
						<prompt>Perturbation strength (between 0 and 1) (-pers)</prompt>
						<precond>
							<language>perl</language>
							<code>$specify_runtype == 2</code>
						</precond>
						<format>
							<language>perl</language>
							<code>(defined $value ) ? "-pers $value":""</code>
						</format>
						<comment>
						<value>
Specify perturbation strength (between 0 and 1) for randomized NNI. DEFAULT: 0.5
						</value>
						</comment>
					</attributes>
				</parameter>
				
				<parameter type="Switch">
					<name>slower_NNI</name>
					<attributes>
						<prompt>Turn on more thorough and slower NNI search (-allnni)</prompt>
						<precond>
							<language>perl</language>
							<code>$specify_runtype == 2</code>
						</precond>
						<format>
							<language>perl</language>
							<code>($value ) ? "-allnni":""</code>
						</format>
						<comment>
						<value>
Turn on more thorough and slower NNI search. It means that IQ-TREE will consider all possible NNIs instead of only those in the vicinity of previously applied NNIs. DEFAULT: OFF
						</value>
						</comment>
					</attributes>
				</parameter>
				
				<parameter type="Switch">
					<name>no_mlpairwise</name>
					<attributes>
						<prompt>Avoid computing ML pairwise distances and BIONJ tree (-djc)</prompt>
						<precond>
							<language>perl</language>
							<code>$specify_runtype == 2</code>
						</precond>
						<format>
							<language>perl</language>
							<code>($value ) ? "-djc":""</code>
						</format>
						<comment>
						<value>
Avoid computing ML pairwise distances and BIONJ tree.
						</value>
						</comment>
					</attributes>
				</parameter>
				
				<parameter type="InFile">
					<name>constraint_file</name>
					<attributes>
						<prompt>Specify a topological constraint tree file in NEWICK format (-g)</prompt>
						<precond>
							<language>perl</language>
							<code>$specify_runtype == 2</code>
						</precond>
						<filenames>constraintfile.txt</filenames>
						<format>
							<language>perl</language>
							<code>(defined $value ) ? "-g constraintfile.txt":""</code>
						</format>
						<comment>
						<value>
Specify a topological constraint tree file in NEWICK format. The constraint tree can be a multifurcating tree and need not to include all taxa.
						</value>
						</comment>
					</attributes>
				</parameter>
				
			</parameters>
	</paragraph>
</parameter>

<parameter type="Paragraph">
	<paragraph>
		<name>ultrafast_search_params</name>
		<prompt>Bootstrap Search Parameters</prompt>
			<parameters>
				<parameter type = "Excl">
					<name>bootstrap_type</name>
					<attributes>
						<prompt>Bootstrap Type</prompt>
						<vlist>
							<value>bb</value>
							<label>Ultrafast</label>
							<value>b</value>
							<label>Non-Parametric (complete,b)</label>
							<value>bo</value>
							<label>Non-Parametric (bo)</label>
							<value>bc</value>
							<label>Non-Parametric (bc)</label>
						</vlist>
						<format>
							<language>perl</language>
							<code>(defined $value ) ? "-$value $num_bootreps":""</code>
						</format>
<!-- 					<vdef>
							<value>bb</value>
						</vdef>	 -->
					</attributes>				
				</parameter>
				
				<parameter type = "Switch">
					<name>use_bnni</name>
					<attributes>
						<prompt>Use bnni to reduce overestimating support (-bnni)</prompt>
						<precond>
							<language>perl</language>
							<code>$bootstrap_type eq "bb"</code>
						</precond>
						<format>
							<language>perl</language>
							<code>($value) ? "-bnni" : ""</code>
						</format>
						<vdef>
							<value>1</value>
						</vdef>	
					</attributes>				
				</parameter>
			
				<parameter type="Integer">
					<name>num_bootreps</name>
					<attributes>
						<prompt>Specify number of bootstrap replicates (>=1000 for ultrafast)</prompt>
						<precond>
							<language>perl</language>
							<code>defined $bootstrap_type</code>
						</precond>
						<ctrls>
							<ctrl>
								<message>Please enter a number of bootstraps</message>
								<language>perl</language>
								<code>defined $bootstrap_type &amp;&amp; !defined $num_bootreps</code>
							</ctrl>
							<ctrl>
								<message>For ultrafast, the value of bootstraps must be greater than or equal to 1,000</message>
								<language>perl</language>
								<code>$bootstrap_type eq "bb" &amp;&amp; $num_bootreps &lt; 1000</code>
							</ctrl>
						</ctrls>
						<comment>
<value>-b: Specify number of bootstrap replicates (recommended >=100; for ultrafact (-bb)>= 1000). This will perform both bootstrap and analysis on original alignment and provide a consensus tree. -bc Like -b but omit analysis on original alignment. 
-bo Like -b but only perform bootstrap analysis (no analysis on original alignment and no consensus tree). 
						</value>
						</comment>						
					</attributes>
				</parameter>
				
				<parameter type="Switch">
					<name>write_boottrees</name>
					<attributes>
						<prompt>Turn on writing bootstrap trees to .ufboot file (-wbt)</prompt>
						<precond>
							<language>perl</language>
							<code>defined $bootstrap_type</code>
						</precond>
						<format>
							<language>perl</language>
							<code>($value) ? "-wbt":""</code>
						</format>
						<vdef>
							<value>0</value>
						</vdef>
						<comment>
						<value>
Turn on writing bootstrap trees to .ufboot file. DEFAULT: OFF
						</value>
						</comment>
					</attributes>
				</parameter>
				
				<parameter type="Switch">
					<name>write_boottrees1</name>
					<attributes>
						<prompt>Turn on writing bootstrap trees with branch lengths (-wbtl)</prompt>
						<precond>
							<language>perl</language>
							<code>defined $bootstrap_type</code>
						</precond>
						<format>
							<language>perl</language>
							<code>($value) ? "-wbtl":""</code>
						</format>
						<vdef>
							<value>0</value>
						</vdef>
						<comment>
						<value>
Turn on writing bootstrap trees with branch lengths (-wbt1) DEFAULT: OFF
						</value>
						</comment>
					</attributes>
				</parameter>
				
				<parameter type="Integer">
					<name>max_iters</name>
					<attributes>
						<prompt>Specify maximum number of iterations to stop. (-nm)</prompt>
						<precond>
							<language>perl</language>
							<code>defined $bootstrap_type</code>
						</precond>
						<format>
							<language>perl</language>
							<code>(defined $value ) ? "-nm $value":""</code>
						</format>
						<comment>
						<value>
Specify maximum number of iterations to stop. DEFAULT: 1000
						</value>
						</comment>
					</attributes>
				</parameter>
				
				<parameter type="Float">
					<name>cc_ufboot</name>
					<attributes>
						<prompt>Minimum correlation coefficient for UFBoot convergence criterion (-bcor)</prompt>
						<precond>
							<language>perl</language>
							<code>defined $bootstrap_type</code>
						</precond>
						<format>
							<language>perl</language>
							<code>(defined $value ) ? "-bcor $value":""</code>
						</format>
						<comment>
						<value>
Specify minimum correlation coefficient for UFBoot convergence criterion. DEFAULT: 0.99
						</value>
						</comment>
					</attributes>
				</parameter>
				
				<parameter type="Integer">
					<name>iter_interval</name>
					<attributes>
						<prompt>Iteration interval checking for UFBoot convergence (-nstep)</prompt>
						<precond>
							<language>perl</language>
							<code>defined $bootstrap_type</code>
						</precond>
						<format>
							<language>perl</language>
							<code>(defined $value ) ? "-nstep $value":""</code>
						</format>
						<ctrls>
							<ctrl>
								<message>Step size must be a multiple of 2</message>
								<language>perl</language>
								<code>defined $iter_interval &amp;&amp; ((($iter_interval) % 2) != 0)</code>
							</ctrl>
							<ctrl>
								<message>Step size must be at least 10</message>
								<language>perl</language>
								<code>defined $iter_interval &amp;&amp; $iter_interval &lt; 10 </code>
							</ctrl>
						</ctrls>
						<comment>
						<value>
Specify iteration interval checking for UFBoot convergence. DEFAULT: every 100 iterations
						</value>
						</comment>
					</attributes>
				</parameter>
				
				<parameter type="Float">
					<name>specify_tiebreaker</name>
					<attributes>
						<prompt>SPR radius for the initial search (-beps)</prompt>
						<precond>
							<language>perl</language>
							<code>defined $bootstrap_type</code>
						</precond>
						<format>
							<language>perl</language>
							<code>(defined $value ) ? "-beps $value":""</code>
						</format>
						<comment>
						<value>
Specify a small epsilon to break tie in RELL evaluation for bootstrap trees. DEFAULT: 0.5
						</value>
						</comment>
					</attributes>
				</parameter>
				
				<parameter type="Excl">
					<name>part_resample</name>
					<attributes>
						<prompt>Resampling strategies for partitioned analysis (-bspec)</prompt>
						<vlist>
							<value>GENE</value>
							<label>GENE</label>
							<value>GENESITE</value>
							<label>GENESITE</label>
						</vlist>
						<format>
							<language>perl</language>
							<code>(defined $value ) ? "-bspec $value":""</code>
						</format>
						<comment>
						<value>
Specify the resampling strategies for partitioned analysis. By default, IQ-TREE resamples alignment sites within partitions. 
With -bspec GENE IQ-TREE will resample partitions. 
With -bspec GENESITE IQ-TREE will resample partitions and then resample sites within resampled partitions (Gadagkar et al., 2005).
						</value>
						</comment>
					</attributes>
				</parameter>
				
			</parameters>
	</paragraph>
</parameter>
				
<!-- The following single branch tests are faster than all bootstrap analysis and recommended for extremely large data sets (e.g., >10,000 taxa):

-alrt Specify number of replicates (>=1000) to perform SH-like approximate likelihood ratio test (SH-aLRT) (Guindon et al., 2010). If number of replicates is set to 0 (-alrt 0), then the parametric aLRT test (Anisimova and Gascuel 2006) is performed, instead of SH-aLRT. 
-abayes Perform approximate Bayes test (Anisimova et al., 2011). 
-lbp Specify number of replicates (>=1000) to perform fast local bootstrap probability method (Adachi and Hasegawa, 1996). 
 -->
 <parameter type="Paragraph">
 <paragraph>
 	<name>single_brancht</name>
 	<prompt>Single Branch Tests</prompt>
 		<parameters>
				
				<parameter type="Switch">
 					<name>sh_test</name>
 					<attributes>
 						<prompt>SH-Like Test (-alrt)</prompt>
 						<precond>
							<language>perl</language>
							<code>$bootstrap_type ne "b" &amp;&amp; $bootstrap_type ne "bo" &amp;&amp; $bootstrap_type ne "bc"</code>
						</precond>	
 						<format>
							<language>perl</language>
							<code>($value) ? "-alrt $num_replicates":""</code>
						</format>
 					</attributes>
 				</parameter>
 <!-- for the parametricaLRT test  -->
 				<parameter type="Switch">
 					<name>parametrical_test</name>
 					<attributes>
 						<prompt>Run the parametricaLRT test (-alrt 0)</prompt>
 						<precond>
							<language>perl</language>
							<code>$bootstrap_type ne "b" &amp;&amp; $bootstrap_type ne "bo" &amp;&amp; $bootstrap_type ne "bc"</code>
						</precond>	
 						<format>
							<language>perl</language>
							<code>($value) ? "-alrt 0":""</code>
						</format>
 					</attributes>
 				</parameter>
 								
				<parameter type="Switch">
 					<name>abayes_test</name>
 					<attributes>
 						<prompt>Approximate Bayes test (-abayes)</prompt>	
 						<precond>
							<language>perl</language>
							<code>$bootstrap_type ne "b" &amp;&amp; $bootstrap_type ne "bo" &amp;&amp; $bootstrap_type ne "bc"</code>
						</precond>
 						<format>
							<language>perl</language>
							<code>($value) ? "-abayes":""</code>
						</format>
 					</attributes>
 				</parameter>
 				
 				<parameter type="Switch">
 					<name>lbp_test</name>
 					<attributes>
 						<prompt>Fast local bootstrap probability (-lbp)</prompt>
 						<precond>
							<language>perl</language>
							<code>$bootstrap_type ne "b" &amp;&amp; $bootstrap_type ne "bo" &amp;&amp; $bootstrap_type ne "bc"</code>
						</precond>	
 						<format>
							<language>perl</language>
							<code>($value) ? "-lbp $num_replicates":""</code>
						</format>
 					</attributes>
 				</parameter>
 				
 				<parameter type="Integer">
					<name>num_replicates</name>
					<attributes>
						<prompt>Specify number of replicates (1000 or more)</prompt>
						<precond>
							<language>perl</language>
							<code>$sh_test || $lbp_test</code>
						</precond>
						<ctrls>
							<ctrl>
								<message>The value of replicates must be greater than or equal to 1,000</message>
								<language>perl</language>
								<code>defined $num_replicates &amp;&amp; $num_replicates &lt; 1000 &amp;&amp; $lbp_test</code>
							</ctrl>
							<ctrl>
								<message>The value of replicates must be greater than or equal to 1,000 for the SH- test </message>
								<language>perl</language>
								<code>defined $num_replicates &amp;&amp; $sh_test  &amp;&amp; $num_replicates &lt; 1000 </code>
							</ctrl>
							<ctrl>
								<message>Please enter a value for number of replicates </message>
								<language>perl</language>
								<code>!defined $num_replicates &amp;&amp; ($sh_test  || $lbp_test)</code>
							</ctrl>
						</ctrls>					
					</attributes>
				</parameter>

		</parameters>			
 	</paragraph>				
 </parameter>
 
<!-- Tree Topology Tests -->
 <parameter type="Paragraph">
 <paragraph>
 	<name>tree_topology</name>
 	<prompt>Tree Topology Tests</prompt>
 		<parameters>
 		
<!--  -z Specify a file containing a set of trees. IQ-TREE will compute the log-likelihoods of all trees. -->				
				<parameter type="InFile">
 					<name>specify_treefile</name>
 					<attributes>
 						<prompt>Specify a file containing a set of trees (-z)</prompt>
						<filenames>treefile1.tre</filenames>
 						<format>
							<language>perl</language>
							<code>(defined $value) ? "-z treefile1.tre":""</code>
						</format>
 					</attributes>
 				</parameter>
 				
<!-- -zb Specify the number of RELL (Kishino et al., 1990) replicates (>=1000) to perform several tree topology tests for all trees passed via -z. The tests include bootstrap proportion (BP), KH test (Kishino and Hasegawa, 1989), SH test (Shimodaira and Hasegawa, 1999) and expected likelihood weights (ELW) (Strimmer and Rambaut, 2002). -->  								
				<parameter type="Integer">
 					<name>num_rell</name>
 					<attributes>
 						<prompt>Specify the number of RELL replicates (-zb)</prompt>	
 						<format>
							<language>perl</language>
							<code>(defined $value) ? "-zb $value":""</code>
						</format>
						<ctrls>
							<ctrl>
								<message>Sorry, the number of RELL replicates cannot be less than 1,000</message>
								<language>perl</language>
								<code>defined $num_rell &amp;&amp; $num_rell &lt; 1000</code>
							</ctrl>
						</ctrls>
						<comment>
<value>-zb Specify the number of RELL (Kishino et al., 1990) replicates (>=1000) to perform several tree topology tests for all trees passed via -z. The tests include bootstrap proportion (BP), KH test (Kishino and Hasegawa, 1989), SH test (Shimodaira and Hasegawa, 1999) and expected likelihood weights (ELW) (Strimmer and Rambaut, 2002).</value>
						</comment>
 					</attributes>
 				</parameter>
 				
<!-- -zw Used together with -zb to additionally perform the weighted-KH and weighted-SH tests. -->
 				<parameter type="Switch">
 					<name>weighted_tests</name>
 					<attributes>
 						<prompt>Perform the weighted-KH and weighted-SH tests (-zw)</prompt>
 						<precond>
 							<language>perl</language>
 							<code>defined $num_rell</code>
 						</precond>	
 						<format>
							<language>perl</language>
							<code>($value) ? "-zw":""</code>
						</format>
 					</attributes>
 				</parameter>
 				
<!-- -au Used together with -zb to additionally perform the approximately unbiased (AU) test (Shimodaira, 2002). Note that you have to specify the number of replicates for the AU test via -zb. -->
  				<parameter type="Switch">
 					<name>unbiased_test</name>
 					<attributes>
 						<prompt>Perform the approximately unbiased (AU) test</prompt>
 						<precond>
 							<language>perl</language>
 							<code>defined $num_rell</code>
 						</precond>	
 						<format>
							<language>perl</language>
							<code>($value) ? "-au":""</code>
						</format>
 					</attributes>
 				</parameter>
 				
<!-- -te Specify a fixed user tree to estimate model parameters. Thus it behaves like -n 0 but uses a user-defined tree instead of parsimony tree. -->
 				<parameter type="InFile">
					<name>fixed_usertree</name>
					<attributes>
						<prompt>Specify a fixed user tree to estimate model parameters (-te)</prompt>
						<filenames>fixed_usertree.tre</filenames>
						<format>
							<language>perl</language>
							<code>($value) ? "-te fixed_usertree.tre":""</code>
						</format>
						<comment>
<value>-te Specify a fixed user tree to estimate model parameters. Thus it behaves like -n 0 but uses a user-defined tree instead of parsimony tree. 
						</value>
						</comment>						
					</attributes>
				</parameter>

		</parameters>			
 	</paragraph>				
 </parameter>
 				
 				
<!-- Constructing consensus tree IQ-TREE provides a fast implementation of consensus tree construction for post analysis: -->
 <parameter type="Paragraph">
 <paragraph>
 	<name>consensus_tree</name>
 	<prompt>Consesnsus Trees</prompt>
 		<parameters>
 		
<!--  -t Specify a file containing a set of trees.  -->				
				<parameter type="InFile">
 					<name>tree_file1</name>
 					<attributes>
 						<prompt>Specify a file containing a set of trees</prompt>
						<filenames>treefile1.tre</filenames>
 						<format>
							<language>perl</language>
							<code>(defined $value) ? "-t treefile1.tre":""</code>
						</format>
 					</attributes>
 				</parameter>
 				
<!--  -con Compute consensus tree of the trees passed via -t. Resulting consensus tree is written to .contree file.  -->  								
				<parameter type="Switch">
 					<name>compute_consensustree</name>
 					<attributes>
 						<prompt>Compute consensus tree of the trees passed via -t (-con)</prompt>	
 						<precond>
 							<language>perl</language>
 							<code>defined $tree_file1</code>
 						</precond>
 						<format>
							<language>perl</language>
							<code>($value) ? "-con":""</code>
						</format>
						<comment>
<value>-con Compute consensus tree of the trees passed via -t. Resulting consensus tree is written to .contree file.</value>
						</comment>
 					</attributes>
 				</parameter>
 				
<!--  -net Compute consensus network of the trees passed via -t. Resulting consensus network is written to .nex file.  -->
 				<parameter type="Switch">
 					<name>compute_consensusnetwork</name>
 					<attributes>
 						<prompt>Compute consensus network of the trees passed via -t (-net)</prompt>
 						<precond>
 							<language>perl</language>
 							<code>defined $tree_file1</code>
 						</precond>	
 						<format>
							<language>perl</language>
							<code>($value) ? "-net":""</code>
						</format>
 					</attributes>
 				</parameter>
 				
<!-- -minsup Specify a minimum threshold (between 0 and 1) to keep branches in the consensus tree. -minsup 0.5 means to compute majority-rule consensus tree. DEFAULT: 0 to compute extended majority-rule consensus. -->
  				<parameter type="Float">
 					<name>min_threshold</name>
 					<attributes>
 						<prompt>Specify a minimum threshold between 0 and 1 (-minsup)</prompt>
 						<precond>
 							<language>perl</language>
 							<code>defined $tree_file1</code>
 						</precond>	
 						<format>
							<language>perl</language>
							<code>($value) ? "-minsup":""</code>
						</format>
 					</attributes>
 				</parameter>
 				
<!--  -bi Specify a burn-in, which is the number of beginning trees passed via -t to discard before consensus construction. This is useful e.g. when summarizing trees from MrBayes analysis.  -->
  				<parameter type="Integer">
 					<name>burnin_value</name>
 					<attributes>
 						<prompt>Specify a burn-in (-bi)</prompt>
 						<precond>
 							<language>perl</language>
 							<code>defined $tree_file1</code>
 						</precond>	
 						<format>
							<language>perl</language>
							<code>(defined $value) ? "-bi ($value)":""</code>
						</format>
 					</attributes>
 				</parameter>
 				
<!--  -sup Specify an input “target” tree file. That means, support values are first extracted from the trees passed via -t, and then mapped onto the target tree. Resulting tree with assigned support values is written to .suptree file. This option is useful to map and compare support values from different approaches onto a single tree.  -->
 				<parameter type="InFile">
					<name>target_treefile</name>
					<attributes>
						<prompt>Specify an input “target” tree file (-sup)</prompt>
						<filenames>targetfile.tre</filenames>
						<format>
							<language>perl</language>
							<code>(defined $value) ? "-sup targetfile.tre":""</code>
						</format>
						<comment>
<value>-sup Specify an input “target” tree file. That means, support values are first extracted from the trees passed via -t, and then mapped onto the target tree. Resulting tree with assigned support values is written to .suptree file. This option is useful to map and compare support values from different approaches onto a single tree.
						</value>
						</comment>						
					</attributes>
				</parameter>

<!-- -suptag Specify name of a node in -sup target tree. The corresponding node of .suptree will then be assigned with IDs of trees where this node appears. Special option -suptag ALL will assign such IDs for all nodes of the target tree. --> 				
				<parameter type="String">
					<name>nodetarget_treefile</name>
					<attributes>
						<prompt>Specify name of a node in -sup target tree (-suptag)</prompt>
						<format>
							<language>perl</language>
							<code>(defined $value) ? "-suptag $value":""</code>
						</format>
						<comment>
						<value>
-suptag Specify name of a node in -sup target tree. The corresponding node of .suptree will then be assigned with IDs of trees where this node appears. Special option -suptag ALL will assign such IDs for all nodes of the target tree.
						</value>
						</comment>						
					</attributes>
				</parameter>

		</parameters>			
 	</paragraph>				
 </parameter>				

<!-- Computing Robinson-Foulds distance IQ-TREE provides a fast implementation of Robinson-Foulds (RF) distance computation between trees: -->

<!-- Constructing consensus tree IQ-TREE provides a fast implementation of consensus tree construction for post analysis: -->
 <parameter type="Paragraph">
 <paragraph>
 	<name>robinsons_fouldsdist</name>
 	<prompt>Computing Robinson's Foulds distances</prompt>
 		<parameters>
 		
<!--  -rf Specify a second set of trees. IQ-TREE computes all pairwise RF distances between two tree sets passed via -t and -rf  -->				
				<parameter type="InFile">
 					<name>tree_file2</name>
 					<attributes>
 						<prompt>Specify a second set of trees</prompt>
						<filenames>treefile2.tre</filenames>
 						<format>
							<language>perl</language>
							<code>(defined $value) ? "-rf treefile2.tre":""</code>
						</format>
 					</attributes>
 				</parameter>
 				
<!--  -rf_all Compute all-to-all RF distances between all trees passed via -t -->								
				<parameter type="Switch">
 					<name>compute_rfdistances_all</name>
 					<attributes>
 						<prompt>Compute all-to-all RF distances between all trees passed via -t (-rf_all)</prompt>	
 						<precond>
 							<language>perl</language>
 							<code>defined $tree_file1</code>
 						</precond>
 						<format>
							<language>perl</language>
							<code>($value) ? "-rf_all":""</code>
						</format>
 					</attributes>
 				</parameter>
 				
<!--  -rf_adj Compute RF distances between adjacent trees passed via -t -->
				<parameter type="Switch">
 					<name>compute_rfdistances_adj</name>
 					<attributes>
 						<prompt>Compute RF distances between adjacent trees passed via -t (-rf_adj)</prompt>	
 						<precond>
 							<language>perl</language>
 							<code>defined $tree_file1</code>
 						</precond>
 						<format>
							<language>perl</language>
							<code>($value) ? "-rf_adj":""</code>
						</format>
 					</attributes>
 				</parameter>

		</parameters>			
 	</paragraph>				
 </parameter>

<!-- Generating random trees: IQ-TREE provides several random tree generation models: -->

<!--  -r Specify number of taxa. IQ-TREE will create a random tree under Yule-Harding model with specified number of taxa -->
<!--  -ru Like -r, but a random tree is created under uniform model.  -->
<!--  -rcat Like -r, but a random caterpillar tree is created.  -->
<!--  -rbal Like -r, but a random balanced tree is created.  -->
<!--  -rcsg Like -r, bur a random circular split network is created.  -->
<!--  -rlen Specify three numbers: minimum, mean and maximum branch lengths of the random tree. DEFAULT:  -->
 
 <parameter type="Paragraph">
 <paragraph>
 	<name>generate_randomtrees</name>
 	<prompt>Generate Random Trees</prompt>
 		<parameters>
 		
<!--  -r Specify number of taxa. IQ-TREE will create a random tree under Yule-Harding model with specified number of taxa -->				
				<parameter type="Integer">
 					<name>num_taxa</name>
 					<attributes>
 						<prompt>Specify number of taxa for the tree (-r)</prompt>
 						<format>
							<language>perl</language>
							<code>(defined $value) ? "-r $value":""</code>
						</format>
 					</attributes>
 				</parameter>
 				
<!--  -ru Like -r, but a random tree is created under uniform model.  -->								
				<parameter type="Excl">
 					<name>choose_randomtype</name>
 					<attributes>
 						<prompt>Specify model for the trees</prompt>	
						<vlist>
 							<value>-r</value>
 							<label>Yule-Harding model</label>
 							<value>-ru</value>
 							<label>Uniform</label>
 							<value>-rcat</value>
 							<label>Caterpillar</label>
 							<value>-rbal</value>
 							<label>Balanced</label>
 							<value>-rcsg</value>
 							<label>Circular Split</label>
 						</vlist>
 					</attributes>
 				</parameter>
 				
<!--  -rlen Specify three numbers: minimum, mean and maximum branch lengths of the random tree. DEFAULT:  -->						
				<parameter type="String">
 					<name>specify_brlengths</name>
 					<attributes>

 						<format>
							<language>perl</language>
							<code>(defined $value) ? "-rcat $value":""</code>
						</format>
 					</attributes>
 				</parameter>
 				
		</parameters>			
 	</paragraph>				
 </parameter>

<!-- Miscellaneous options -->

<!-- -wt Turn on writing all locally optimal trees into .treels file. DEFAULT: OFF  -->
<!-- -fixbr Turn on fixing branch lengths of tree passed via -t or -te. This is useful to evaluate the log-likelihood of an input tree with fixed tolopogy and branch lengths. DEFAULT: OFF  -->
<!-- -wsl Turn on writing site log-likelihoods to .sitelh file in TREE-PUZZLE format. Such file can then be passed on to CONSEL for further tree tests. DEFAULT: OFF  -->
<!-- -wslg Turn on writing site log-likelihoods per rate category. DEFAULT: OFF  -->
<!-- -fconst Specify a list of comma-separated integer numbers. The number of entries should be equal to the number of states in the model (e.g. 4 for DNA and 20 for protein). IQ-TREE will then add a number of constant sites accordingly. For example, -fconst 10,20,15,40 will add 10 constant sites of all A, 20 constant sites of all C, 15 constant sites of all G and 40 constant sites of all T into the alignment. 
 -->
 
 <parameter type="Paragraph">
 <paragraph>
 	<name>misc_options</name>
 	<prompt>Miscellaneous Options</prompt>
 		<parameters>
 		
<!--   -wt Turn on writing all locally optimal trees into .treels file. DEFAULT: OFF  -->				
				<parameter type="Switch">
 					<name>write_locally_optimal</name>
 					<attributes>
 						<prompt>Turn on writing all locally optimal trees (-wt)</prompt>
 						<format>
							<language>perl</language>
							<code>($value) ? "-wt":""</code>
						</format>
 					</attributes>
 				</parameter>
 				
<!-- -fixbr Turn on fixing branch lengths of tree passed via -t or -te. This is useful to evaluate the log-likelihood of an input tree with fixed tolopogy and branch lengths. DEFAULT: OFF  -->								
				<parameter type="Switch">
 					<name>fix_brlengths</name>
 					<attributes>
 						<prompt>Turn on fixing branch lengths of tree passed via -t or -te (-fixbr)</prompt>
 						 <precond>
 							<language>perl</language>
 							<code>defined $tree_file1 || defined $fixed_usertree</code>
 						</precond>
 						<format>
							<language>perl</language>
							<code>($value) ? "-fixbr":""</code>
						</format>
						<comment>
<value> -fixbr Turn on fixing branch lengths of tree passed via -t or -te. This is useful to evaluate the log-likelihood of an input tree with fixed tolopogy and branch lengths.</value>
						</comment>
 					</attributes>
 				</parameter>
 				
 <!-- -wsr Write per-site rates to .rate file -->
				<parameter type="Switch">
					<name>per_sitefile</name>
					<attributes>
						<prompt>Write per-site rates to .rate file (-wsr)</prompt>
						<precond>
							<language>perl</language>
							<code>$specify_runtype == 2</code>
						</precond> 
						<format>
							<language>perl</language>
							<code>($value ) ? "-wsr":""</code>
						</format>
					</attributes>
				</parameter>

<!--   -wsl    Write site log-likelihoods to .sitelh file -->
				<parameter type="Switch">
					<name>per_sitewslfile</name>
					<attributes>
						<prompt>Write site log-liklihoods to .sitelh file (-wsl)</prompt>
						<precond>
							<language>perl</language>
							<code>$specify_runtype == 2</code>
						</precond> 
						<format>
							<language>perl</language>
							<code>($value ) ? "-wsl":""</code>
						</format> 
					</attributes>
				</parameter>  
  
  <!--  -wslr   Write site log-likelihoods per rate category -->
  				<parameter type="Switch">
					<name>per_sitewslrfile</name>
					<attributes>
						<prompt>Write site log-likelihoods per rate category (-wslr)</prompt>
						<precond>
							<language>perl</language>
							<code>$specify_runtype == 2</code>
						</precond> 
						<format>
							<language>perl</language>
							<code>($value ) ? "-wslr":""</code>
						</format> 
					</attributes>
				</parameter>  
  
  <!--   -wslm   Write site log-likelihoods per mixture class -->
  				<parameter type="Switch">
					<name>per_sitewslmfile</name>
					<attributes>
						<prompt> Write site log-likelihoods per mixture class (-wslm)</prompt>
						<precond>
							<language>perl</language>
							<code>$specify_runtype == 2</code>
						</precond> 
						<format>
							<language>perl</language>
							<code>($value ) ? "-wslm":""</code>
						</format> 
					</attributes>
				</parameter>  
				
<!--   -wspm  Write site probabilities per mixture class (-wspm)  -->
  				<parameter type="Switch">
  					<name>per_sitewspmfile</name>
					<attributes>
						<prompt>Write site probabilities per mixture class (-wspm)</prompt>
						<precond>
							<language>perl</language>
							<code>$specify_runtype == 2</code>
						</precond> 
						<format>
							<language>perl</language>
							<code>($value ) ? "-wspm":""</code>
						</format> 
					</attributes>
				</parameter>  
  
  <!--   -wspr  Write site probabilities per rate category -->
    		 	<parameter type="Switch">
    			<name>per_sitewsprfile</name>
					<attributes>
						<prompt> Write site probabilities per rate category (-wspr)</prompt>
						<precond>
							<language>perl</language>
							<code>$specify_runtype == 2</code>
						</precond> 
						<format>
							<language>perl</language>
							<code>($value ) ? "-wspr":""</code>
						</format> 
					</attributes>
				</parameter> 
  
  
  <!--  -wspmr  Write site probabilities per mixture+rate class -->
    			<parameter type="Switch">
      			<name>per_sitewspmrfile</name>
					<attributes>
						<prompt> Write site probabilities per rate category (-wspmr)</prompt>
						<precond>
							<language>perl</language>
							<code>$specify_runtype == 2</code>
						</precond> 
						<format>
							<language>perl</language>
							<code>($value ) ? "-wspmr":""</code>
						</format> 
					</attributes>
				</parameter> 
				
  <!-- -wpl  Write partition log-likelihoods to .partlh file -->
    				<parameter type="Switch">
        			<name>per_sitewplfile</name>
					<attributes>
						<prompt> Write partition log-likelihoods to .partlh file (-wpl)</prompt>
						<precond>
							<language>perl</language>
							<code>$specify_runtype == 2</code>
						</precond> 
						<format>
							<language>perl</language>
							<code>($value ) ? "-wpl":""</code>
						</format> 
					</attributes>
				</parameter> 
 <!-- 
  -fconst f1,...,fN    Add constant patterns into alignment (N=#nstates)
  -me <epsilon>        LogL epsilon for parameter estimation (default 0.01)
  -*no-outfiles        Suppress printing output files -->
 				 				
<!-- -wsl Turn on writing site log-likelihoods to .sitelh file in TREE-PUZZLE format. Such file can then be passed on to CONSEL for further tree tests. DEFAULT: OFF  -->					
				<parameter type="Switch">
 					<name>write_sitelikelihoods</name>
 					<attributes>
 						<prompt>Write log-likelihoods in TREE-PUZZLE format (-wsl)</prompt>	
 						<format>
							<language>perl</language>
							<code>($value) ? "-wsl":""</code>
						</format>
						<comment>
<value>Turn on writing site log-likelihoods to .sitelh file in TREE-PUZZLE format. Such file can then be passed on to CONSEL for further tree tests. DEFAULT: OFF </value>
						</comment>
 					</attributes>
 				</parameter>
 				
 <!-- -wslg Turn on writing site log-likelihoods per rate category. DEFAULT: OFF  -->
 				<parameter type="Switch">
 					<name>write_loglikelihoods</name>
 					<attributes>
 						<prompt>Write log-likelihoods per rate category (-wslg)</prompt>	
 						<format>
							<language>perl</language>
							<code>($value) ? "-wslg":""</code>
						</format>
						<comment>
<value>Turn on writing site log-likelihoods per rate category. DEFAULT: OFF </value>
						</comment>
 					</attributes>
 				</parameter>
 				
<!-- -fconst Specify a list of comma-separated integer numbers. The number of entries should be equal to the number of states in the model (e.g. 4 for DNA and 20 for protein). IQ-TREE will then add a number of constant sites accordingly. For example, -fconst 10,20,15,40 will add 10 constant sites of all A, 20 constant sites of all C, 15 constant sites of all G and 40 constant sites of all T into the alignment. 
 -->
  				<parameter type="InFile">
 					<name>list_csintegers</name>
 					<attributes>
 						<prompt>Specify a list of comma-separated integer numbers (-fconst)</prompt>
 						<filenames>integerfile.csv</filenames>	
 						<format>
							<language>perl</language>
							<code>(defined $value) ? "-const integerfile.csv":""</code>
						</format>
						<comment>
<value>Specify a list of comma-separated integer numbers. The number of entries should be equal to the number of states in the model (e.g. 4 for DNA and 20 for protein). IQ-TREE will then add a number of constant sites accordingly. For example, -fconst 10,20,15,40 will add 10 constant sites of all A, 20 constant sites of all C, 15 constant sites of all G and 40 constant sites of all T into the alignment.</value>
						</comment>
 					</attributes>
 				</parameter>
 						
		</parameters>			
 	</paragraph>				
 </parameter>


		<parameter ishidden="1" type="String">
			<name>restart</name>
			<attributes>
				<format>
					<language>perl</language>
					<code>($value) ? "-redo" : ""</code>
				</format>
				<group>4</group>
			</attributes>
		</parameter>


<parameter type="Results">
	<name>results</name>
	<attributes>
		<filenames>*</filenames>
	</attributes>
</parameter>

</parameters>
</pise>


