<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE pise PUBLIC "pise2.dtd" "pise2.dtd" >
<pise>
	<head>
		<title>RAxML-HPC v.8 on XSEDE</title>
		<version>8.2.12</version>
		<description>Phylogenetic tree inference using maximum likelihood/rapid bootstrapping run on XSEDE</description>
		<authors>Alexandros Stamatakis</authors>
		<reference>Stamatakis A. RAxML-VI-HPC: maximum likelihood-based phylogenetic analyses with thousands of taxa and mixed models.Bioinformatics. 2006 Nov 1;22(21):2688-90</reference>
		<category>Phylogeny / Alignment</category>
		<doclink>http://icwww.epfl.ch/~stamatak/index-Dateien/countManual7.0.0.php</doclink>
	</head>
	<command>raxmlhpc8_rest_xsede</command>
	<parameters>

 <!-- Move the jobs to Expanse, per Wayne Pfeiffer, as of 10/29/2020
 
Rules for running RAxML 8.2.12 on Expanse via the CIPRES gateway

All runs are on one standard node of Expanse.

- Ask the user for the following:

  whether the data set has amino acids (AAs) and
  how many patterns are in the data set.

  If the data set does not contain AA data, assume that it is DNA.

- Check whether -N is specified and, if so, what is value is.

- Specify the number of MPI processes (CIPRES_NP) and number of threads
  (CIPRES_THREADSPP) according to the following table.
  Runs with MPI processes use raxmlHPC-HYBRID-AVX, while
  runs with only threads use raxmlHPC-PTHREADS-AVX.

    Data             Data  MPI pro-                        Slurm    Slurm
    type         patterns    cesses  Threads    Cores  partition   memory

Analysis with -N >=10 or equal to autoMR or autoMRE or autoMRE_IGN 

     DNA          <10,000        10        4       40     shared      77G
     DNA    10,000-39,999         5       25      125    compute
     DNA   40,000-499,999         2       64      128    compute
     DNA        >=500,000                128      128    compute
	 
      AA           <3,000        10        4       40     shared      77G
      AA     3,000-11,999        10       12      120    compute
      AA    12,000-29,999         5       25      125    compute
      AA   30,000-199,999         2       64      128    compute
      AA        >=200,000                128      128    compute

Any other analysis

     DNA           <4,000                  8        8     shared      15G
     DNA     4,000-15,999                 16       16     shared      31G
     DNA    16,000-59,999                 24       24     shared      46G
     DNA   60,000-299,999                 48       48     shared      92G
     DNA        >=300,000                128      128    compute

      AA           <3,000                 12       12     shared      23G   
      AA      3,000-4,499                 24       24     shared      46G
      AA     4,500-14,999                 32       32     shared      61G
      AA    15,000-99,999                 64       64     shared     120G
      AA        >=100,000                128      128    compute
  -->

<!-- dhge10 = dna/hybrid runs; with mpi; greater than or equal to N=10 -->
<!--     Data             Data  MPI pro-                        Slurm    Slurm
    type         patterns    cesses  Threads    Cores  partition   memory

Analysis with -N >=10 or equal to autoMR or autoMRE or autoMRE_IGN 

     DNA          <10,000        10        4       40     shared      77G
     DNA    10,000-39,999         5       25      125    compute
     DNA   40,000-499,999         2       64      128    compute -->

<!-- hybrid when mpi used; not protein, and nchar is less than 500000 and -N >= 10 -->	
					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogicdhge10</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>$nchar &lt; 500000 &amp;&amp; $datatype ne "protein" &amp;&amp; ($choose_bootstop eq "bootstop" || $bootstrap_value &gt; 9 || $altrun_number  &gt; 9)</code>
							</precond>
							<format>
								<language>perl</language>
								<code>"raxmlHPC-HYBRID_8.2.12_expanse"</code>
							</format>
							<group>0</group>
						</attributes>
					</parameter>
					
<!-- pthreads when mpi not used; not protein, nchar is greater than or equal to 500000 and -N >= 10 -->					
					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogicdpge10</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>$nchar &gt; 499999 &amp;&amp; $datatype ne "protein" &amp;&amp; ($choose_bootstop eq "bootstop" || $bootstrap_value &gt; 9 || $altrun_number  &gt; 9)</code>
							</precond>
							<format>
								<language>perl</language>
								<code>"raxmlHPC-PTHREADS_8.2.12_expanse"</code>
							</format>
							<group>0</group>
						</attributes>
					</parameter>

<!--  hybrid when mpi used; protein, nchar is less than or equal to 200000 and -N >= 10 -->									
					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogicphge10</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>$nchar &lt; 200000 &amp;&amp; $datatype eq "protein" &amp;&amp; ($choose_bootstop eq "bootstop" || $bootstrap_value &gt; 9 || $altrun_number  &gt; 9)</code>
							</precond>
							<format>
								<language>perl</language>
								<code>"raxmlHPC-HYBRID_8.2.12_expanse"</code>
							</format>
							<group>0</group>
						</attributes>
					</parameter>
											
<!-- ppge10 =protein/pthreads runs, when patterns >= 200000 -->				
					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogicppge10</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>$nchar &gt; 199999 &amp;&amp; $datatype eq "protein" &amp;&amp; ($choose_bootstop eq "bootstop" || $bootstrap_value &gt; 9 || $altrun_number  &gt; 9)</code>
							</precond>
							<format>
								<language>perl</language>
								<code>"raxmlHPC-PTHREADS_8.2.12_expanse"</code>
							</format>
							<group>0</group>
						</attributes>
					</parameter>
					
<!-- when bootstraps or replicates are low; should also work if bootstraps and replicates are not chose, I think. -->						
					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogicallplt10</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>$bootstrap_value &lt; 10 &amp;&amp; $altrun_number  &lt; 10 &amp;&amp; $choose_bootstop ne "bootstop"</code>
							</precond>
							<format>
								<language>perl</language>
								<code>"raxmlHPC-PTHREADS_8.2.12_expanse"</code>
							</format>
							<group>0</group>
						</attributes>
					</parameter>
					
<!--     Data             Data  MPI pro-                        Slurm    Slurm
    type         patterns    cesses  Threads    Cores  partition   memory

Analysis with -N >=10 or equal to autoMR or autoMRE or autoMRE_IGN 

     DNA          <10,000        10        4       40     shared      77G
     DNA    10,000-39,999         5       25      125    compute
     DNA   40,000-499,999         2       64      128    compute-->
<!-- when time is less than = 2 hours run on a single processor -->
					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogicdhge10_scheduler1</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<precond>
								<language>perl</language>
								<code>$nchar &lt; 10000 &amp;&amp; $datatype ne "protein" &amp;&amp; ($choose_bootstop eq "bootstop" || $bootstrap_value &gt; 9 || $altrun_number  &gt; 9)</code>
							</precond>
							
							<format>
								<language>perl</language>
								<code>
									"jobtype=mpi\\n" .
									"mpi_processes=10\\n" .
									"threads_per_process=4\\n" .
									"cpus-per-task=4\\n" .
									"mem=77G\\n" .
									"node_exclusive=0\\n" .
									"nodes=1\\n"
								</code>
								</format>
							<group>0</group>
						</attributes>
					</parameter>
					
					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogicdhge10_scheduler2</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<precond>
								<language>perl</language>
								<code>$nchar &gt; 9999  &amp;&amp; $nchar &lt; 40000  &amp;&amp; $datatype ne "protein" &amp;&amp; ($choose_bootstop eq "bootstop" || $bootstrap_value &gt; 9 || $altrun_number  &gt; 9)</code>
							</precond>
							<format>
								<language>perl</language>
								<code>
									"jobtype=mpi\\n" .
									"mpi_processes=5\\n" .
									"threads_per_process=25\\n" .
									"cpus-per-task=25\\n" .
									"mem=243G\\n" .
									"node_exclusive=1\\n" .
									"nodes=1\\n"
								</code>
								</format>
							<group>0</group>
						</attributes>
					</parameter>
					
					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogicdhge10_scheduler3</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<precond>
								<language>perl</language>
								<code>$nchar &gt; 39999 &amp;&amp; $nchar &lt; 500000  &amp;&amp; $datatype ne "protein" &amp;&amp; ($choose_bootstop eq "bootstop" || $bootstrap_value &gt; 9 || $altrun_number  &gt; 9)</code>
							</precond>
							<format>
								<language>perl</language>
								<code>
									"jobtype=mpi\\n" .
									"mpi_processes=2\\n" .
									"threads_per_process=64\\n" .
									"cpus-per-task=64\\n" .
									"mem=243G\\n" .
									"node_exclusive=1\\n" .
									"nodes=1\\n"
								</code>
								</format>
							<group>0</group>
						</attributes>
					</parameter>
					
<!-- dna when there are no mpi processes 
     DNA        >=500,000                128      128    compute-->														
					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogicdpge10_scheduler</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<precond>
								<language>perl</language>
								<code>$nchar &gt; 499999 &amp;&amp; $datatype ne "protein" &amp;&amp; ($choose_bootstop eq "bootstop" || $bootstrap_value &gt; 9 || $altrun_number  &gt; 9)</code>
							</precond>
							<format>
								<language>perl</language>
								<code>
									"threads_per_process=128\\n" .
									"cpus-per-task=128\\n" .
									"node_exclusive=1\\n" .
									"mem=243G\\n" .
									"nodes=1\\n"
								</code>
								</format>
							<group>0</group>
						</attributes>
					</parameter>
					
<!-- using pthreads; dna, less than 9 for -N; or no bootstopping 
Any other analysis

     DNA           <4,000                  8        8     shared      15G
     DNA     4,000-15,999                 16       16     shared      30G
     DNA    16,000-59,999                 24       24     shared      46G
     DNA   60,000-299,999                 48       48     shared      92G
     DNA        >=300,000                128      128    compute -->
					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogicdplt10_scheduler1</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<precond>
								<language>perl</language>
								<code>$nchar &lt; 4000 &amp;&amp; $datatype ne "protein" &amp;&amp; $bootstrap_value &lt; 10 &amp;&amp; $altrun_number &lt; 10 &amp;&amp; $choose_bootstop ne "bootstop"</code>
							</precond>
							<format>
								<language>perl</language>
								<code>
									"threads_per_process=8\\n" .
									"cpus-per-task=8\\n" .
									"node_exclusive=0\\n" .
									"mem=15G\\n" .
									"nodes=1\\n"
								</code>
								</format>
							<group>0</group>
						</attributes>
					</parameter>
					
					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogicdplt10_scheduler2</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<precond>
								<language>perl</language>
								<code>$nchar &gt; 3999  &amp;&amp; $nchar &lt; 16000  &amp;&amp; $datatype ne "protein" &amp;&amp; $bootstrap_value &lt; 10 &amp;&amp; $altrun_number &lt; 10  &amp;&amp; $choose_bootstop ne "bootstop"</code>
							</precond>
							<format>
								<language>perl</language>
								<code>
									"threads_per_process=16\\n" .
									"cpus-per-task=16\\n" .
									"node_exclusive=0\\n" .
									"mem=30G\\n" .
									"nodes=1\\n"
								</code>
								</format>
							<group>0</group>
						</attributes>
					</parameter>
					
					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogicdplt10_scheduler3</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<precond>
								<language>perl</language>
								<code>$nchar &gt; 15999 &amp;&amp; $nchar &lt; 60000  &amp;&amp; $datatype ne "protein" &amp;&amp; $bootstrap_value &lt; 10 &amp;&amp; $altrun_number &lt; 10  &amp;&amp; $choose_bootstop ne "bootstop"</code>
							</precond>
							<format>
								<language>perl</language>
								<code>
									"threads_per_process=24\\n" .
									"cpus-per-task=24\\n" .
									"node_exclusive=0\\n" .
									"mem=46G\\n" .
									"nodes=1\\n"
								</code>
								</format>
							<group>0</group>
						</attributes>
					</parameter>
					
					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogicdplt10_scheduler4</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<precond>
								<language>perl</language>
								<code>$nchar &gt; 59999 &amp;&amp; $nchar &lt; 300000  &amp;&amp; $datatype ne "protein" &amp;&amp; $bootstrap_value &lt; 10 &amp;&amp; $altrun_number &lt; 10 &amp;&amp; $choose_bootstop ne "bootstop"</code>
							</precond>
							<format>
								<language>perl</language>
								<code>
									"threads_per_process=48\\n" .
									"cpus-per-task=48\\n" .
									"node_exclusive=0\\n" .
									"mem=92G\\n" .
									"nodes=1\\n"
								</code>
								</format>
							<group>0</group>
						</attributes>
					</parameter>
					
<!-- dna when there are no mpi processes 
     DNA        >=300,000                128      128    compute-->														
					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogicdplt10_scheduler</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<precond>
								<language>perl</language>
								<code>$nchar &gt; 299999 &amp;&amp; $datatype ne "protein" &amp;&amp; $bootstrap_value &lt; 10 &amp;&amp; $altrun_number &lt; 10  &amp;&amp; $choose_bootstop ne "bootstop"</code>
							</precond>
							<format>
								<language>perl</language>
								<code>
									"threads_per_process=128\\n" .
									"cpus-per-task=128\\n" .
									"node_exclusive=1\\n" .
									"mem=243G\\n" .
									"nodes=1\\n"
								</code>
								</format>
							<group>0</group>
						</attributes>
					</parameter>
	 
	 
<!-- When the -N >= 10

	  AA           <3,000        10        4       40     shared      77G
      AA     3,000-11,999        10       12      120    compute
      AA    12,000-29,999         5       25      125    compute
      AA   30,000-199,999         2       64      128    compute
      AA        >=200,000                128      128    compute	--> 										
					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogicphge10_scheduler1</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<precond>
								<language>perl</language>
								<code>$nchar &lt; 3000 &amp;&amp; $datatype eq "protein" &amp;&amp; ($choose_bootstop eq "bootstop" || $bootstrap_value &gt; 9 || $altrun_number &gt; 9)</code>
							</precond>
							<format>
								<language>perl</language>
								<code>
									"jobtype=mpi\\n" .
									"mpi_processes=10\\n" .
									"threads_per_process=4\\n" .
									"cpus-per-task=4\\n" .
									"mem=77G\\n" .
									"node_exclusive=0\\n" .
									"nodes=1\\n"
								</code>
								</format>
						</attributes>
					</parameter>
					
				<parameter ishidden="1" type="String">					
					<name>raxmlhpc_hybridlogicphge10_scheduler2</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<precond>
								<language>perl</language>
								<code>$nchar &gt; 2999 &amp;&amp; $nchar &lt; 12000 &amp;&amp; $datatype eq "protein" &amp;&amp; ($choose_bootstop eq "bootstop" || $bootstrap_value &gt; 9 || $altrun_number &gt; 9)</code>
							</precond>
							<format>
								<language>perl</language>
								<code>
									"jobtype=mpi\\n" .
									"mpi_processes=10\\n" .
									"threads_per_process=12\\n" .
									"cpus-per-task=12\\n" .
									"mem=243G\\n" .
									"node_exclusive=1\\n" .
									"nodes=1\\n"
								</code>
								</format>
						</attributes>
					</parameter>
											
				<parameter ishidden="1" type="String">					
					<name>raxmlhpc_hybridlogicphge10_scheduler3</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<precond>
								<language>perl</language>
								<code>$nchar &gt; 11999 &amp;&amp; $nchar &lt; 30000 &amp;&amp; ($choose_bootstop eq "bootstop" || $bootstrap_value &gt; 9 || $altrun_number &gt; 9)</code>
							</precond>
							<format>
								<language>perl</language>
								<code>
									"jobtype=mpi\\n" .
									"mpi_processes=5\\n" .
									"threads_per_process=25\\n" .
									"cpus-per-task=25\\n" .
									"mem=243G\\n" .
									"node_exclusive=1\\n" .
									"nodes=1\\n"
								</code>
								</format>
						</attributes>
					</parameter>
																	
				<parameter ishidden="1" type="String">					
					<name>raxmlhpc_hybridlogicphge10_scheduler4</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<precond>
								<language>perl</language>
								<code>$nchar &gt; 29999 &amp;&amp; $nchar &lt; 200000 &amp;&amp; $datatype eq "protein" &amp;&amp; ($choose_bootstop eq "bootstop" || $bootstrap_value &gt; 9 || $altrun_number &gt; 9)</code>
							</precond>
							<format>
								<language>perl</language>
								<code>
									"jobtype=mpi\\n" .
									"mpi_processes=2\\n" .
									"threads_per_process=64\\n" .
									"cpus-per-task=64\\n" .
									"mem=243G\\n" .
									"node_exclusive=1\\n" .
									"nodes=1\\n"
								</code>
								</format>
						</attributes>
					</parameter>
																					
				<parameter ishidden="1" type="String">					
					<name>raxmlhpc_hybridlogicppge10_scheduler</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<precond>
								<language>perl</language>
								<code>$nchar &gt; 199999 &amp;&amp; $datatype eq "protein" &amp;&amp; ($choose_bootstop eq "bootstop" || $bootstrap_value &gt; 9 || $altrun_number &gt; 9)</code>
							</precond>
							<format>
								<language>perl</language>
								<code>
									"threads_per_process=128\\n" .
									"cpus-per-task=128\\n" .
									"mem=243G\\n" .
									"node_exclusive=1\\n" .
									"nodes=1\\n"
								</code>
								</format>
						</attributes>
					</parameter>

<!--  When the -N < 10
	  AA           <3,000                 12       12     shared      23G   
      AA      3,000-4,499                 24       24     shared      46G
      AA     4,500-14,999                 32       32     shared      61G
      AA    15,000-99,999                 64       64     shared     123G
      AA        >=100,000                128      128    compute -->
					<parameter ishidden="1" type="String">
						<name>raxmlhpc_hybridlogicpplt10_scheduler1</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<precond>
								<language>perl</language>
								<code>$nchar &lt; 3000 &amp;&amp; $datatype eq "protein" &amp;&amp; $bootstrap_value &lt; 10 &amp;&amp; $altrun_number &lt; 10  &amp;&amp; $choose_bootstop ne "bootstop"</code>
							</precond>
							<format>
								<language>perl</language>
								<code>
									"threads_per_process=12\\n" .
									"cpus-per-task=12\\n" .
									"node_exclusive=0\\n" .
									"mem=23G\\n" .
									"nodes=1\\n"
								</code>
								</format>
						</attributes>
					</parameter>
					
				<parameter ishidden="1" type="String">					
					<name>raxmlhpc_hybridlogicpplt10_scheduler2</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<precond>
								<language>perl</language>
								<code>$nchar &gt; 2999 &amp;&amp; $nchar &lt; 4500 &amp;&amp; $datatype eq "protein" &amp;&amp; $bootstrap_value &lt; 10 &amp;&amp; $altrun_number &lt; 10  &amp;&amp; $choose_bootstop ne "bootstop"</code>
							</precond>
							<format>
								<language>perl</language>
								<code>
									"threads_per_process=24\\n" .
									"cpus-per-task=24\\n" .
									"node_exclusive=0\\n" .
									"mem=46G\\n" .
									"nodes=1\\n"
								</code>
								</format>
						</attributes>
					</parameter>
											
				<parameter ishidden="1" type="String">					
					<name>raxmlhpc_hybridlogicpplt10_scheduler3</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<precond>
								<language>perl</language>
								<code>$nchar &gt; 4499 &amp;&amp; $nchar &lt; 15000 &amp;&amp; $datatype eq "protein" &amp;&amp; $bootstrap_value &lt; 10 &amp;&amp; $altrun_number &lt; 10  &amp;&amp; $choose_bootstop ne "bootstop"</code>
							</precond>
							<format>
								<language>perl</language>
								<code>
									"threads_per_process=32\\n" .
									"cpus-per-task=32\\n" .
									"node_exclusive=0\\n" .
									"mem=61G\\n" .
									"nodes=1\\n"
								</code>
								</format>
						</attributes>
					</parameter>
																	
				<parameter ishidden="1" type="String">					
					<name>raxmlhpc_hybridlogicpplt10_scheduler4</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<precond>
								<language>perl</language>
								<code>$nchar &gt; 14999 &amp;&amp; $nchar &lt; 100000 &amp;&amp; $datatype eq "protein" &amp;&amp; $bootstrap_value &lt; 10 &amp;&amp; $altrun_number &lt; 10  &amp;&amp; $choose_bootstop ne "bootstop"</code>
							</precond>
							<format>
								<language>perl</language>
								<code>
									"threads_per_process=64\\n" .
									"cpus-per-task=64\\n" .
									"node_exclusive=0\\n" .
									"mem=123G\n" .
									"nodes=1\\n"
								</code>
								</format>
						</attributes>
					</parameter>
																					
				<parameter ishidden="1" type="String">					
					<name>raxmlhpc_hybridlogicpplt10_scheduler</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<precond>
								<language>perl</language>
								<code>$nchar &gt; 99999 &amp;&amp; $datatype eq "protein" &amp;&amp; $bootstrap_value &lt; 10 &amp;&amp; $altrun_number &lt; 10 &amp;&amp; $choose_bootstop ne "bootstop"</code>
							</precond>
							<format>
								<language>perl</language>
								<code>
									"threads_per_process=128\\n" .
									"cpus-per-task=128\\n" .
									"node_exclusive=1\\n" .
									"mem=243G\\n" .
									"nodes=1\\n"
								</code>
								</format>
						</attributes>
					</parameter>

							
<!-- required input file -->
					<parameter ismandatory="1" issimple="1" isinput="1" type="InFile">
						<name>infile</name>
						<attributes>
							<prompt>Sequences File (relaxed phylip format) (-s)</prompt>
							<group>1</group>
							<filenames>infile.txt</filenames>
						</attributes>
					</parameter>
		
<!-- required input file, when the -J option is not used -->
					<parameter ismandatory="1" ishidden="1" type="String">
						<name>infile_regular</name>
						<attributes>
							<prompt>Sequences File (relaxed phylip format) (-z)</prompt>
 							<precond>
								<language>perl</language>
								<code>$select_analysis ne "J"</code>
							</precond>
							<format>
								<language>perl</language>
								<code>"-s infile.txt"</code>
							</format>
							<group>1</group>
						</attributes>
					</parameter>
		
<!-- required input file, only when the -J option is used -->
					<parameter ismandatory="1" ishidden="1" type="String">
						<name>infile_Joption</name>
						<attributes>
							<prompt>Collection of trees file (-z)</prompt>
  						<precond>
								<language>perl</language>
								<code>$select_analysis eq "J"</code>
							</precond> 
							<format>
								<language>perl</language>
								<code>" -z infile.txt"</code>
							</format>
							<group>1</group>
						</attributes>
					</parameter>
		
<!-- catchall to route std out to a log file -->
<!--	the logfile isnt used on teragrid, it is replaced with std out
		<parameter type="String" ishidden="1">
			<name>out_logifle</name>
			<attributes>
				<format>
					<language>perl</language>
					<code>" > output.txt"</code>
				</format>
				<group>99</group>
			</attributes>
		</parameter> -->
	
<!-- Parameters with visible controls start here -->
		<parameter type="Float" issimple="1" ismandatory="1">
			<name>runtime</name>
			<attributes>
				<group>1</group>
				<paramfile>scheduler.conf</paramfile>
				<prompt>Maximum Hours to Run (click here for help setting this correctly)</prompt>
				<vdef>
					<value>0.25</value>
				</vdef>
				<ctrls>
					<ctrl>
						<message>Maximum Hours to Run must be less than 168</message>
						<language>perl</language>
						<code>$runtime &gt; 168.0</code>
					</ctrl>
					<ctrl>
						<message>Maximum Hours to Run must be greater than 0.1</message>
						<language>perl</language>
						<code>$runtime &lt; 0.1</code>
					</ctrl>
				</ctrls>
				<format>
					<language>perl</language>
					<code>"runhours=$value\\n"</code>
				</format>
<!-- added by mamiller to provide feedback on number of cpu hrs to be consumed -->
							<warns>
					<warn>
						<message>The job will run on 40 processors as configured. If it runs for the entire configured time, it will consume 40 x $runtime cpu hours</message>
						<language>perl</language>
						<code>$nchar &lt; 10000 &amp;&amp; $datatype ne "protein" &amp;&amp; ($choose_bootstop eq "bootstop" || $bootstrap_value &gt; 9 || $altrun_number  &gt; 9)</code>
					</warn>
					<warn>
						<message>The job will run on 125 processors as configured. If it runs for the entire configured time, it will consume 125 x $runtime cpu hours</message>
						<language>perl</language>
						<code>$nchar &gt; 9999  &amp;&amp; $nchar &lt; 40000  &amp;&amp; $datatype ne "protein" &amp;&amp; ($choose_bootstop eq "bootstop" || $bootstrap_value &gt; 9 || $altrun_number  &gt; 9)</code>
					</warn>
					<warn>
						<message>The job will run on 128 processors as configured. If it runs for the entire configured time, it will consume 128 x $runtime cpu hours</message>
						<language>perl</language>
						<code>$nchar &gt; 39999 &amp;&amp; $nchar &lt; 500000  &amp;&amp; $datatype ne "protein" &amp;&amp; ($choose_bootstop eq "bootstop" || $bootstrap_value &gt; 9 || $altrun_number  &gt; 9)</code>
					</warn>
					<warn>
						<message>The job will run on 128 processors as configured. If it runs for the entire configured time, it will consume 128 x $runtime cpu hours</message>
						<language>perl</language>
						<code>$nchar &gt; 499999 &amp;&amp; $datatype ne "protein" &amp;&amp; ($choose_bootstop eq "bootstop" || $bootstrap_value &gt; 9 || $altrun_number  &gt; 9)</code>
					</warn>
					<warn>
						<message>The job will run on 8 processors as configured. If it runs for the entire configured time, it will consume 8 x $runtime cpu hours</message>
						<language>perl</language>
						<code>$nchar &lt; 4000 &amp;&amp; $datatype ne "protein" &amp;&amp; $bootstrap_value &lt; 10 &amp;&amp; $altrun_number &lt; 10  &amp;&amp; $choose_bootstop ne "bootstop"</code>
					</warn>
					<warn>
						<message>The job will run on 16 processors as configured. If it runs for the entire configured time, it will consume 16 x $runtime cpu hours</message>
						<language>perl</language>
						<code>$nchar &gt; 3999  &amp;&amp; $nchar &lt; 16000  &amp;&amp; $datatype ne "protein" &amp;&amp; $bootstrap_value &lt; 10 &amp;&amp; $altrun_number &lt; 10 &amp;&amp; $choose_bootstop ne "bootstop"</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>$nchar &gt; 15999 &amp;&amp; $nchar &lt; 60000  &amp;&amp; $datatype ne "protein" &amp;&amp; $bootstrap_value &lt; 10 &amp;&amp; $altrun_number &lt; 10 &amp;&amp; $choose_bootstop ne "bootstop"</code>
					</warn>
					<warn>
						<message>The job will run on 48 processors as configured. If it runs for the entire configured time, it will consume 48 x $runtime cpu hours</message>
						<language>perl</language>
						<code>$nchar &gt; 59999 &amp;&amp; $nchar &lt; 300000  &amp;&amp; $datatype ne "protein" &amp;&amp; $bootstrap_value &lt; 10 &amp;&amp; $altrun_number &lt; 10 &amp;&amp; $choose_bootstop ne "bootstop"</code>
					</warn>
					<warn>
						<message>The job will run on 128 processors as configured. If it runs for the entire configured time, it will consume 128 x $runtime cpu hours</message>
						<language>perl</language>
						<code>$nchar &gt; 299999 &amp;&amp; $datatype ne "protein" &amp;&amp; $bootstrap_value &lt; 10 &amp;&amp; $altrun_number &lt; 10 &amp;&amp; $choose_bootstop ne "bootstop"</code>
					</warn>
					<warn>
						<message>The job will run on 40 processors as configured. If it runs for the entire configured time, it will consume 40 x $runtime cpu hours</message>
						<language>perl</language>
						<code>$nchar &lt; 3000 &amp;&amp; $datatype eq "protein" &amp;&amp; ($choose_bootstop eq "bootstop" || $bootstrap_value &gt; 9 || $altrun_number &gt; 9)</code>
					</warn>
					<warn>
						<message>The job will run on 120 processors as configured. If it runs for the entire configured time, it will consume 120 x $runtime cpu hours</message>
						<language>perl</language>
						<code>$nchar &gt; 2999 &amp;&amp; $nchar &lt; 12000 &amp;&amp; $datatype eq "protein" &amp;&amp; ($choose_bootstop eq "bootstop" || $bootstrap_value &gt; 9 || $altrun_number &gt; 9)</code>
					</warn>
					<warn>
						<message>The job will run on 125 processors as configured. If it runs for the entire configured time, it will consume 125 x $runtime cpu hours</message>
						<language>perl</language>
						<code>$nchar &gt; 11999 &amp;&amp; $nchar &lt; 30000  &amp;&amp; $datatype eq "protein" &amp;&amp; ($choose_bootstop eq "bootstop" || $bootstrap_value &gt; 9 || $altrun_number &gt; 9)</code>
					</warn>
					<warn>
						<message>The job will run on 128 processors as configured. If it runs for the entire configured time, it will consume 128 x $runtime cpu hours</message>
						<language>perl</language>
						<code>$nchar &gt; 29999 &amp;&amp; $nchar &lt; 200000 &amp;&amp; $datatype eq "protein" &amp;&amp; ($choose_bootstop eq "bootstop"|| $bootstrap_value &gt; 9 || $altrun_number  &gt; 9)</code>
					</warn>
					<warn>
						<message>The job will run on 128 processors as configured. If it runs for the entire configured time, it will consume 128 x $runtime cpu hours</message>
						<language>perl</language>
						<code>$nchar &gt; 199999 &amp;&amp; $datatype eq "protein" &amp;&amp; ($choose_bootstop eq "bootstop" || $bootstrap_value &gt; 9 || $altrun_number &gt; 9)</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>$nchar &lt; 3000 &amp;&amp; $datatype eq "protein" &amp;&amp; $bootstrap_value &lt; 10 &amp;&amp; $altrun_number &lt; 10 &amp;&amp; $choose_bootstop ne "bootstop"</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>$nchar &gt; 2999 &amp;&amp; $nchar &lt; 4500 &amp;&amp; $datatype eq "protein" &amp;&amp; $bootstrap_value &lt; 10 &amp;&amp; $altrun_number &lt; 10 &amp;&amp; $choose_bootstop ne "bootstop"</code>
					</warn>
					<warn>
						<message>The job will run on 32 processors as configured. If it runs for the entire configured time, it will consume 32 x $runtime cpu hours</message>
						<language>perl</language>
						<code>$nchar &gt; 4499 &amp;&amp; $nchar &lt; 15000 &amp;&amp; $datatype eq "protein" &amp;&amp; $bootstrap_value &lt; 10 &amp;&amp; $altrun_number &lt; 10 &amp;&amp; $choose_bootstop ne "bootstop"</code>			
					</warn>
					<warn>
						<message>The job will run on 64 processors as configured. If it runs for the entire configured time, it will consume 64 x $runtime cpu hours</message>
						<language>perl</language>
						<code>$nchar &gt; 14999 &amp;&amp; $nchar &lt; 100000 &amp;&amp; $datatype eq "protein" &amp;&amp; $bootstrap_value &lt; 10 &amp;&amp; $altrun_number &lt; 10 &amp;&amp; $choose_bootstop ne "bootstop"</code>
					</warn>
					<warn>
						<message>The job will run on 128 processors as configured. If it runs for the entire configured time, it will consume 128 x $runtime cpu hours</message>
						<language>perl</language>
						<code>$nchar &gt; 99999 &amp;&amp; $datatype eq "protein" &amp;&amp; $bootstrap_value &lt; 10 &amp;&amp; $altrun_number &lt; 10 &amp;&amp; $choose_bootstop ne "bootstop"</code>
					</warn>
	
							</warns>
							<comment>
<value>Estimate the maximum time your job will need to run. We recommend testing initially with a time less than 0.5hr test run because Jobs set for 0.5 h or less depedendably run immediately in the "debug" queue. 
Once you are sure the configuration is correct, you then increase the time. The reason is that jobs &gt; 0.5 h are submitted to the "normal" queue, where jobs configured for 1 or a few hours times may
run sooner than jobs configured for the full 168 hours. 
</value>
							</comment>
			</attributes>
		</parameter>

<!-- is it protein or dna input ? -->
		
					<parameter type="Excl" issimple="0" ismandatory="1">
						<name>datatype</name>
						<attributes>
							<prompt>Please select the Data Type</prompt>
							<vlist>
								<value>protein</value>
								<label>Protein</label>
								<value>dna</value>
								<label>Nucleotide</label>
								<value>rna</value>
								<label>RNA Structure</label>
								<value>binary</value>
								<label>Binary Morphological</label>
								<value>multi</value>
								<label>Multi-State Morphological</label>
							</vlist>
							<vdef>
								<value>dna</value>
							</vdef>
							<group>2</group>
						</attributes>
					</parameter>

<!-- use a text string with the -n argument to specify output file suffix; this is  is required -->
		<parameter type="String" issimple="1" >
			<name>outsuffix</name>
			<attributes>
				<prompt>Set a name for output files (-n)</prompt>
				<format>
					<language>perl</language>
					<code>"-n $value"</code>
				</format>
				<vdef>
					<value>result</value>
				</vdef> 
				<ctrls>
					<ctrl>
						<message>Please enter a name for the output files (-n)</message>
						<language>perl</language>
						<code>!defined $outsuffix</code>
					</ctrl>
				</ctrls>
				<group>1</group>
			</attributes>
		</parameter>
		
<!-- specify_nchar -->
		<parameter type="Integer" issimple="1" >
			<name>nchar</name>
			<attributes>
				<prompt>How many patterns in your data set?</prompt>
				<vdef>
					<value>1000</value>
				</vdef> 
				<ctrls>
					<ctrl>
						<message>Please enter the number of patterns in your data set</message>
						<language>perl</language>
						<code>!defined $nchar</code>
					</ctrl>
				</ctrls>
				<comment>
				<value>				Knowing the number of characters in your dataset helps us determine the most efficient way to run raxml.
						The number of patterns is the number of unique columns in the multiple sequence alignment matrix. You can get this number from the output of the intermediate results once a job begins. Entering the number of characters per taxon in your matirx, or 1000 as the number of patterns is an ok start.
						Look at the intermediate results, and see if that is reasonably close. If it is not, kill the job, and adjust the number.</value>
				</comment>
				<group>1</group>
			</attributes>
		</parameter>
		
<!-- enable ML tree searches under CAT instead of GAMMA  -->
					<parameter type="Switch" issimple="1" >
						<name>MLsearch_CAT</name>
						<attributes>
							<prompt>Enable ML searches under CAT (-F)</prompt>
<!-- -F not allowed with bootstrapping -->
							<precond>
								<language>perl</language>
								<code>$choose_bootstrap ne "x" &amp;&amp; $choose_bootstrap ne "b" <!-- &amp;&amp; $select_analysis ne "fa"   --></code>
							</precond>
							<format>
								<language>perl</language>
								<code>($value)? " -F " : "" </code>
							</format>
							<vdef>
								<value>0</value>
							</vdef>
							<comment>
<value>This option allows one to enable tree searches under CAT for very large trees, as this saves memory. This option can also be used under GAMMA models
	to avoid thorough optimization of the best scoring ML tree at the end of the run.	 
								</value>
							</comment>
						</attributes>
					</parameter>		
			
		<!-- outgroup (-o) -->
		<parameter type="String" issimple="1">
			<name>outgroup</name>
			<attributes>
				<prompt>Outgroup (-o) ()one or more comma-separated outgroups, see comment for syntax)</prompt>
				<format>
					<language>perl</language>
					<code>(defined $value)? " -o $value " : "" </code>
				</format>
				<group>10</group>
				<comment>
<value>The correct syntax for the box is outgroup1,outgroup2,outgroupn. If white space is introduced (e.g. outgroup1, outgroup2, outgroupn) the program will fail with the message
"Error, you must specify a model of substitution with the '-m' option"
</value>					
				</comment>
			</attributes>
		</parameter>
		
		<!-- rev 2 -->
		<!--category (-c) -->
					<parameter type="Integer" issimple="1" ismandatory="1">
						<name>number_cats</name>
						<attributes>
							<prompt>Specify the number of distinct rate categories (-c)</prompt>
							<format>
								<language>perl</language>
								<code>(defined $value)? " -c $value" : "" </code>
							</format>
							<vdef>
								<value>25</value>
							</vdef>
							<group>2</group>
							<precond>
								<language>perl</language>
								<code>($datatype eq "dna" &amp;&amp; $dna_gtrcat eq "GTRCAT") || ($datatype eq "protein" &amp;&amp; $prot_sub_model eq "PROTCAT") || ($datatype eq "binary" &amp;&amp; $bin_model eq "BINCAT")</code>
							</precond>
							<comment>
					<value>This option allows you to specify the number of distinct rate categories, into which the individually optimized rates for each individual site are thrown under -m GTRCAT. The default of -c 25 works fine in most practical cases.
</value>
							</comment>
						</attributes>
					</parameter>
		
<!-- Disable rate heterogeneity (-V) -->
					<parameter type="Switch" issimple="1" ismandatory="1">
						<name>disable_ratehet</name>
						<attributes>
							<prompt>Disable Rate Heterogeneity  (-V)</prompt>
							<format>
								<language>perl</language>
								<code>($value)? " -V " : "" </code>
							</format>
							<vdef>
								<value>0</value>
							</vdef>
							<group>2</group>
							<precond>
								<language>perl</language>
								<code>($datatype eq "dna" &amp;&amp; $dna_gtrcat eq "GTRCAT") || ($datatype eq "protein" &amp;&amp; $prot_sub_model eq "PROTCAT") || ($datatype eq "binary" &amp;&amp; $bin_model eq "BINCAT")</code>
							</precond>
							<comment>
					<value>This option allows you to disable rate heterogeneity anong the sites. Valid for CAT model only.
</value>
							</comment>
						</attributes>
					</parameter>
		<!-- user supplied starting tree (-t) -->
		
					<parameter issimple="1" type="InFile">
						<name>treetop</name>
						<attributes>
							<prompt>Supply a tree (Not available when doing rapid bootstrapping, -x) (-t)</prompt>
							<precond>
								<language>perl</language>
								<code>$choose_bootstrap ne "x"</code>
							</precond>
							<format>
								<language>perl</language>
								<code>" -t tree.tre"</code>
							</format>
							<group>2</group>
							<filenames>tree.tre</filenames>
							<comment>
<value>Specifies a user starting tree file in Newick format. Not available when doing rapid bootstrapping. Branch lengths of that tree will be ignored. Note that you can also specify a non-comprehensive (not containing all taxa in the alignment) starting tree now. This might be useful if newly aligned/sequenced taxa have been added to your alignment. Initially, taxa will be added to the tree using the MP criterion. The comprehensive tree will then be optimized
under ML.</value>
							</comment>
						</attributes>
					</parameter>

					<!--PARSIMONY SEED VALUE FOR CONSTANT STARTING TREE-->
					<!-- I split the seeds  into invocation, and number entry, due to command line conflicts -->
					<parameter type="Switch" issimple="1" ismandatory="1">
						<name>provide_parsimony_seed</name>
						<attributes>
							<prompt>Specify a random seed value for parsimony inferences (-p)</prompt>
							  <precond>
								<language>perl</language>
								<code>$select_analysis ne "fe" &amp;&amp; $select_analysis ne "fA"</code>
							</precond>
							<vdef>
								<value>1</value>
							</vdef>
							<ctrls>
								<ctrl>
									<message>Please provide a parsimony seed (-p)</message>
									<language>perl</language>
									<code>$altrun_number &amp;&amp; !defined $parsimony_seed_val</code>
								</ctrl>
								<ctrl>
									<message>Please provide a parsimony seed (-p)</message>
									<language>perl</language>
									<code>$startingtreeonly &amp;&amp; !defined $parsimony_seed_val</code>
								</ctrl>
  						    	<ctrl>
									<message>Sorry, you cannot specify a starting tree (via the -t option above) and a random seed value (via -p)  with the -f x option</message>
									<language>perl</language>
									<code>defined $treetop &amp;&amp; $provide_parsimony_seed &amp;&amp; $select_analysis eq "fx"</code>
								</ctrl> 
							</ctrls> 
							<comment>
								<value>Specify a random number seed. The -p option allows you and others to reproduce your results (reproducible/verifiable experiments) and will help Alexis debug the program. Do not use this option if you want to generate multiple different starting trees.</value>
							</comment>
						</attributes>
					</parameter>

					<parameter type="Integer" issimple="1"  ismandatory="1">
						<name>parsimony_seed_val</name>
						<attributes>
							<prompt>Enter a random seed value for parsimony inferences (-p "value" gives reproducible results from random starting tree)</prompt>
							<precond>
								<language>perl</language>
								<code>$provide_parsimony_seed</code>
							</precond>
							<format>
								<language>perl</language>
								<code>($value) ? " -p $value" : ""</code>
							</format>
							<vdef>
								<value>12345</value>
							</vdef>
							<group>2</group>
							<ctrls>
								<ctrl>
									<message>Please enter a random seed for the -p option (eg 12345)</message>
									<language>perl</language>
									<code>$provide_parsimony_seed &amp;&amp; !defined $parsimony_seed_val</code>
								</ctrl>
							</ctrls>
						</attributes>
					</parameter>

		<!-- rearrangement (-i) INVOCATION AND SPECIFICATION -->
					<parameter type="Switch" issimple="1" ismandatory="1">
						<name>rearrangement_yes</name>
						<attributes>
							<prompt>Specify an initial rearrangement setting (-i)</prompt>
							<vdef>
								<value>0</value>
							</vdef>
						</attributes>
					</parameter>
					
					<parameter type="Integer" issimple="1" ismandatory="1">
						<name>number_rearrange</name>
						<attributes>
							<prompt>Specify the distance from original pruning point (-i)</prompt>
							<format>
								<language>perl</language>
								<code>(defined $value)? " -i $value" : "" </code>
							</format>
							<vdef>
								<value>10</value>
							</vdef>
							<precond>
								<language>perl</language>
								<code>$rearrangement_yes</code>
							</precond>
							<ctrls>
								<ctrl>
									<message>Please specify the distance from original pruning point (-i) (default would be 10). </message>
									<language>perl</language>
									<code>$rearrangement_yes &amp;&amp; !defined $number_rearrange</code>
								</ctrl>
							</ctrls>
							<group>2</group>
							<comment>
<value>This option allows you to specify an initial rearrangement setting for the initial phase of the search algorithm. If you specify e.g. -i 10; the pruned subtrees will be inserted up to a distance of 10 nodes away from their original pruning point. If you dont specify -i; a "good" initial rearrangement setting will automatically be determined by RAxML.
</value>
							</comment>
						</attributes>
					</parameter>
		<!-- rev 2 -->
		<!-- constraint (-g) -->
					<parameter type="InFile" issimple="1">
						<name>constraint</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>!defined $binary_backbone &amp;&amp; $select_analysis ne "y"</code>
							</precond>
							<prompt>Constraint (-g)</prompt>
							<filenames>constraint.tre</filenames>
							<format>
								<language>perl</language>
					<!-- 
						parameters of type Results are always processed so we need to check
						whether we actually got a value entered.
					-->
								<code>defined $value ? " -g constraint.tre" : ""</code>
							</format>
							<group>2</group>
<comment>
					<value> This option allows you to specify an incomplete or comprehensive multifurcating constraint 
					tree for the RAxML search in NEWICK format. Initially, multifurcations are resolved 
					randomly. If the tree is incomplete (does not contain all taxa) the remaining taxa are added by 
					using the MP criterion. Once a comprehensive (containing all taxa) bifurcating tree 
					is computed, it is further optimized under ML respecting the given constraints. Important: If you 
					specify a non-comprehensive constraint, e.g., a constraint tree that does not contain all taxa, 
					RAxML will assume that any taxa that not found in the constraint topology 
					are unconstrained, i.e., these taxa can be placed in any part of the tree.  As an example 
					consider an alignment with 10 taxa: Loach, Chicken, Human, Cow, Mouse, Whale, Seal, Carp, 
					Rat, Frog.  If, for example you would like Loach, Chicken, Human, Cow to be monophyletic you 
					would specify the constraint tree as follows: </value>
					<value> ((Loach, Chicken, Human, Cow),(Mouse, Whale, Seal, Carp, Rat, Frog)); </value>
					<value> Moreover, if you would like Loach, Chicken, Human, Cow to be monophyletic and in 
					addition Human, Cow to be monophyletic within that clade you could specify: </value>
					<value> ((Loach, Chicken, (Human, Cow)),(Mouse, Whale, Seal, Carp, Rat, Frog)); </value>
					<value> If you specify an incomplete constraint: </value>
					<value> ((Loach, Chicken, Human, Cow),(Mouse, Whale, Seal, Carp)); </value>
					<value> the two groups Loach, Chicken, Human, Cow and Mouse, Whale, Seal, Carp will be 
					monophyletic, while Rat and Frog can end up anywhere in the tree.  </value>
				</comment>
						</attributes>
					</parameter>
		
		<!-- binary backbone (-r) -->
					<parameter type="InFile" issimple="1">
						<name>binary_backbone</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>!defined $constraint</code>
							</precond>
							<prompt>Binary Backbone (-r)</prompt>
							<filenames>binary_backbone.tre</filenames>
							<format>
								<language>perl</language>
<!--  parameters of type Results are always processed so we need to check
						whether we actually got a value entered.   -->
								<code>(defined $value) ? " -r binary_backbone.tre" : ""</code>
							</format>
							<group>2</group>
							<comment>
<value>This option allows you to pass a binary/bifurcating constraint/backbone tree in NEWICK format to RAxML. Note that using this option only makes sense if this tree contains fewer taxa than the input alignment. The remaining taxa will initially be added by using the MP criterion. Once a comprehensive tree with all taxa has been obtained it will be  optimized under ML respecting the restrictions of the constraint tree.
</value>
							</comment>
						</attributes>
					</parameter>
		
		<!-- Optional mixed  model file -->
		<!-- If user doesn't enter a value the partition parameter won't be in the map that the web app sends the command renderer (which evaluates the perl for parameters that are present), so we don't need to worry about making the format code conditional since this parameter just won't be evaluated. Command renderer evaluates 3 types of parameters: 1) those that appear in the map coming from the gui, those that are	hidden, 3) those that are of type OutFile or Result. -->
					<parameter type="InFile" issimple="1">
						<name>partition</name>
						<attributes>
							<prompt>Use a mixed/partitioned model? (-q)</prompt>
							<format>
								<language>perl</language>
								<code>" -q part.txt"</code>
							</format>
							<group>2</group>
							<filenames>part.txt</filenames>
							<comment>
					<value>This parameter allows you to upload a file that specifies the regions of your alignment for which an individual model of nucleotide substitution should be estimated. This will typically be used to infer trees for long (in terms of base pairs) multi-gene alignments. If DNA and protein mixed models are used together (for example) you should choose a model option based on the model of rate heterogeneity you want to use. If you specify either -m GTRCAT or PROTCAT, the CAT model will be used, if you specify -m GTRGAMMA or -m BINGAMMA, the GAMMA model will be used ....
For example, if -m GTRGAMMA is used, individual alpha-shape parameters, GTR-rates, and empirical base frequencies will be estimated and optimized for each partition. Since Raxml can now handles mixed Amino Acid and DNA alignments, you must specify the data type in the partition file, before the partition name. For DNA, this means you have to add DNA to each line in the partition. For AA data you must specify the transition matrices for each partition: 
The AA substitution model must be the first entry in each line and must be separated by a comma from the gene name, just like the DNA token above. You can not assign different models of rate heterogeneity to different partitions, i.e. it will be either CAT, GAMMA, GAMMAI etc. for all partitions, as specified with -m. Finally, if you have a concatenated DNA and AA alignments, with DNA data at positions 1 - 500 and AA data at 501-1000 with the WAG model the partition file should look as follows:</value>
<value>DNA, gene1 = 1-500</value> 
<value>WAG gene2 = 501-1000</value>
							</comment>
						</attributes>
					</parameter>
					
					
		<!-- -M Switch on estimation of individual per-partition branch lengths. Only has effect when used in combination
with -q and an alignment partition file. Branch lengths for individual partitions will be printed to separate
files. A weighted average of the branch lengths is also computed by using the respective partition lengths
(number of columns per partition). Note that, this does not take into account the "gappyness" of partitions,
but I am currently not sure how to solve this problem. By default the -M option is turned off for partitioned
analyses, i.e., RAxML will compute a joined branch length estimate.
Example: raxmlHPC - alg -m GTRGAMMA -q part -M -n TEST.-->

					<parameter type="Switch" issimple="1" ismandatory="1">
						<name>estimate_perpartbrlen</name>
						<attributes>
							<prompt>Estimate individual per-partition branch lengths (-M)</prompt>
							<precond>
								<language>perl</language>
								<code>defined $partition</code>
							</precond>
							<format>
								<language>perl</language>
								<code>($value) ? " -M" : "" </code>
							</format>
							<vdef>
								<value>0</value>
							</vdef>
							<comment>
								<value>The -M option switches on estimation of individual per-partition branch lengths. Only has effect when used in combination with -q and an alignment partition file. Branch lengths for individual partitions will be printed to separate files. A weighted average of the branch lengths is also computed by using the respective partition lengths (number of columns per partition). Note that, this does not take into account the "gappyness" of partitions, but I am currently not sure how to solve this problem. By default RAxML will compute a joined branch length estimate.</value>
							</comment>
						</attributes>
					</parameter>
				<!-- rev 5 -->
		<!-- Estimate proportion of invariable sites, mlsearch is a precondition  -->
		<!-- The control should be of type switch, but I need the value of the parameter
		to be either "I" or "", so I made it type Excl instead. -->
		<!-- disabled 5/5/2009 based on information in the manual -->
					<parameter issimple="1" type="Excl" >
						<name>specify_ML</name>
						<attributes>
							<prompt>Specify an ML estimate of base frequencies (GTRGAMMA + X)</prompt>
							<vlist>
								<value>X</value>
								<label>yes</label>
								<value></value>
								<label>no</label>
							</vlist>
							<vdef>
								<value></value>
							</vdef>
							<group>2</group>
						</attributes>
					</parameter>

		<!-- rev 5 -->
		<!-- Estimate proportion of invariable sites, mlsearch is a precondition  -->
		<!-- The control should be of type switch, but I need the value of the parameter
		to be either "I" or "", so I made it type Excl instead. -->
		<!-- disabled 5/5/2009 based on information in the manual -->
					<parameter issimple="1" type="Excl" >
						<name>invariable</name>
						<attributes>
							<prompt>Estimate proportion of invariable sites (GTRGAMMA + I)</prompt>
							<vlist>
								<value>I</value>
								<label>yes</label>
								<value></value>
								<label>no</label>
							</vlist>
							<vdef>
								<value></value>
							</vdef>
							<warns>
								<warn>
									<message>The invariable option is not recommended by the developer of RAxML. Please see the manual for details.</message>
									<language>perl</language>
									<code>$invariable</code>
								</warn>
							</warns>
							<group>2</group>
							<comment>
								<value>This option is not recommended by the developer of RAxML</value>
							</comment>
						</attributes>
					</parameter>
					
		<!-- Substitution matrix for protein datatype, datatype=protein is a precondition -->
		<!-- Is used to build the -m model string -->
		<!-- A value must be selected when datatype=protein, so I added a vdef, so users wont have a job fail accidentally; this also highlights where the value needs to be set by populating the box with text-->

		<!-- Optional excludes these characters -->
		<!-- If user doesn't enter a value, the parameter won't be in the map that the web app sends the command renderer (which evaluates the perl for parameters that are present), so we don't need to worry about making the format code conditional; if null, this parameter just won't be evaluated. Command renderer evaluates 3 types of parameters: 1) those that appear in the map coming from the gui, those that are hidden, 3) those that are of type OutFile or Result. -->
			<parameter type="InFile" issimple="1">
						<name>exclude_file</name>
						<attributes>
							<prompt>Choose an input file that excludes the range of positions specifed in this file (-E)</prompt>
							<format>
								<language>perl</language>
								<code>" -E excl"</code>
							</format>
							<group>2</group>
				<filenames>excl</filenames>
				<comment>
					<value>This option is used to excludes specific positions in the matrix. For example, uploading a file
					that contains the text: 100-200 300-400 will create a file that excludes all columns between positions
					100 and 200 as well as all columns between positions 300 and 400. Note that the boundary numbers (positions 100, 200, 300, 
					and 400) will also be excluded. To exclude a single column write (100-100). This option does not 
					run an analysis but just prints an alignment file without the excluded columns. Save this file to your 
					data area, and then run the real analysis. If you use a mixed model, an appropriately adapted model file 
					will also be written. The ntax element of the phylip files is automatically corrected Example: raxmlHPC -E excl
						-s infile -m GTRCAT -q part -n TEST. In this case the files with columns excluded will be named
						infile.excl and part.excl. </value>
				</comment>
						</attributes>
			</parameter>
					
			<parameter type="InFile" issimple="1">
				<name>set_weights</name>
				<attributes>
					<prompt>Weight characters as specifed in this file (-a)</prompt>
						<format>
							<language>perl</language>
							<code>" -a weights"</code>
						</format>
						<group>2</group>
					<filenames>weights</filenames>
				<comment>
<value>This option alows you to specify a column weight file name to assign individual weights to each
column of the alignment. Those weights must be integers separated by any type and number of whitespaces
within a separate file. There must, of course, be as many weights as there are columns in your
alignment. The contents of an example weight file could look like this:
5 1 1 2 1 1 1 1 1 1 1 2 1 1 3 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 4 1 1 1 4 1 1 </value>
				</comment>
				</attributes>
			</parameter>
			
<!-- add the -O option to disable checking for sequences with no values in them  
      -O      Disable check for completely undetermined sequence in alignment.
              The program will not exit with an error message when "-O" is specified.-->				
					<parameter type="Switch" issimple="1" ishidden="0">
						<name>disable_seqcheck</name>
						<attributes>
							<prompt>Disable checking for sequences with no values (-O)</prompt>
							<format>
								<language>perl</language>
								<code>($value) ? "-O" : ""</code>
							</format>
							<vdef>
								<value>0</value>
							</vdef>
							<warns>
								<warn>
									<message>Please use the -O option with caution. It disables the check to see if sequences are completely devoid of information. See the RAxML manual for guidance</message>
									<language>perl</language>
									<code>$disable_seqcheck</code>
								</warn>
							</warns>
						<group>54</group>
						</attributes>
					</parameter>
					
<!-- add the -mesquite option for David Maddison mesquite
Print output files that can be parsed by Mesquite.
DEFAULT: Off
Example: raxmlHPC -p 12345 -s alg -*mesquite -n TEST -m GTRGAMMA-->				
					<parameter type="Switch" issimple="1" ishidden="0">
						<name>mesquite_output</name>
						<attributes>
							<prompt>Print output files that can be parsed by Mesquite. (-mesquite)</prompt>
							<precond>
								<language>perl</language>
								<code>$choose_bootstrap ne "x" &amp;&amp; $choose_bootstrap ne "b" &amp;&amp; !$altrun_number</code>
							</precond>
							<format>
								<language>perl</language>
								<code>($value) ? "--mesquite" : ""</code>
							</format>
							<vdef>
								<value>0</value>
							</vdef>
						<group>54</group>
						</attributes>
					</parameter>			

<!-- Nucleotides as sequences (not secondary structure -->
<parameter type="Paragraph">
	<paragraph>
		<name>nucleic_opts</name>
		<prompt>Nucleic Acid Options</prompt>
		<parameters>
<!--               NUCLEOTIDES:

                "-m GTRCAT"         : GTR + Optimization of substitution rates + Optimization of site-specific
                                      evolutionary rates which are categorized into numberOfCategories distinct 
                                      rate categories for greater computational efficiency.  Final tree might be evaluated
                                      under GTRGAMMA, depending on the tree search option
  NOT SUPPORTED "-m GTRCAT_FLOAT"   : Same as above but uses single-precision floating point arithmetics instead of double-precision
                                      Usage only recommend for testing, the code will run slower, but can save almost 50% of memory.
                                      If you have problems with phylogenomic datasets and large memory requirements you may give it a shot.
                                      Keep in mind that numerical stability seems to be okay but needs further testing.
  NOT SUPPORTED "-m GTRCATI"        : GTR + Optimization of substitution rates + Optimization of site-specific
                                      evolutionary rates which are categorized into numberOfCategories distinct 
                                      rate categories for greater computational efficiency.  Final tree might be evaluated
                                      under GTRGAMMAI, depending on the tree search option
                "-m GTRGAMMA"       : GTR + Optimization of substitution rates + GAMMA model of rate 
                                      heterogeneity (alpha parameter will be estimated)
				
  NOT SUPPORTED "-m GTRGAMMA_FLOAT" : Same as GTRGAMMA, but also with single-precision arithmetics, same cautionary notes as for  
                                      GTRCAT_FLOAT apply.
  NOT SUPPORTED "-m GTRGAMMAI"      : Same as GTRGAMMA, but with estimate of proportion of invariable sites -->
                
					<parameter type="Excl">
						<name>dna_gtrcat</name>
						<attributes>
							<prompt>Choose model for bootstrapping phase</prompt>
							<precond>
								<language>perl</language>
								<code>$datatype eq "dna" || $datatype eq "rna"</code>
							</precond>
							<vlist>
								<value>GTRCAT</value>
								<label>GTRCAT</label>
				                <value>GTRGAMMA</value>
								<label>GTRGAMMA</label>
							</vlist>
							<format>
								<language>perl</language>
								<code>"-m $ascertainment$value$invariable$specify_ML"</code>
							</format>
							<vdef>
								<value>GTRCAT</value>
							</vdef>
							<group>2</group>
							<ctrls>
								<ctrl>
									<message>Please choose a DNA model</message>
									<language>perl</language>
									<code>($datatype eq "dna" || $datatype eq "rna") &amp;&amp; $dna_gtrcat ne "GTRCAT" &amp;&amp; $dna_gtrcat ne "GTRGAMMA"</code>
									</ctrl> 
<!--  we only want this evalauted when dataype is dna  -->
								<ctrl>
									<message>Sorry, the -f x option is valid only with GAMMA models</message>
									<language>perl</language>
									<code> $select_analysis eq "fx" &amp;&amp; $dna_gtrcat ne "GTRGAMMA"</code>
								</ctrl>
							</ctrls>
							<comment>
								<value>The meaning of the model name GTRGAMMA used by RAxML 7.2.0 is exactly opposite that 
									used in RAxML 7.0.4, so we have eliminated selection by model name. Instead we use a 
									description of the  model analysis. This selection gives GTR + Optimization of substitution
									 rates + Optimization of site-specific evolutionary rates which are categorized into "numberOfCategories" distinct
									 rate categories for greater computational efficiency.  Final tree is evaluated under GTRGAMMA. 
									GTRMIX  and GTRCAT_GAMMA have been eliminated as options. FLOAT options that are native in RAxML 7.2.3 are currently not supported here.
								</value>
							</comment>
						</attributes>
					</parameter>
					
					<parameter type="Excl" issimple="0" >
						<name>partitionUnder</name>
						<attributes>
							<prompt>Evaluate DNA partitions only under this model</prompt>
							<precond>
								<language>perl</language>
								<code>$datatype eq "dna"</code>
							</precond>
							<vlist>
								<value>HKY85</value>
								<label>HKY85</label>
								<value>K80</value>
								<label>K80</label>
								<value>JC69</value>
								<label>JC69</label>
							</vlist>
							<format>
								<language>perl</language>
								<code>(defined $value) ? " --$value":""</code>
							</format>
							<group>2</group>
							<comment>
					<value>This option specifies that all DNA partitions will evolve under the HKY85 model, this
overrides all other model specifications for DNA partitions. Note that, the output of the program might look a bit
weird, since unlike in the definition of the model, RAxML actually estimates the rates from A - G and C - T while all other rates
are set to 1.0. Note that, this does not matter, since the rates in the rate matrix are relative rates; the results
(likelihoods) will be the same</value>	</comment>
						</attributes>
					</parameter>
				
		</parameters>
	</paragraph>
</parameter>
						
			<parameter type="Paragraph">
				<paragraph>
					<name>protein_opts</name>
					<prompt>Protein Analysis Options</prompt>
					<parameters>		 
					
<!--               AMINO ACIDS:

                "-m PROTCATmatrixName[F]"         : specified AA matrix + Optimization of substitution rates + Optimization of site-specific
                                                    evolutionary rates which are categorized into numberOfCategories distinct 
                                                    rate categories for greater computational efficiency.   Final tree might be evaluated
                                                    automatically under PROTGAMMAmatrixName[f], depending on the tree search option
                "-m PROTCATmatrixName[F]_FLOAT"   : PROTCAT with single precision arithmetics, same cautionary notes as for GTRCAT_FLOAT apply
                "-m PROTCATImatrixName[F]"        : specified AA matrix + Optimization of substitution rates + Optimization of site-specific
                                                    evolutionary rates which are categorized into numberOfCategories distinct 
                                                    rate categories for greater computational efficiency.   Final tree might be evaluated
                                                    automatically under PROTGAMMAImatrixName[f], depending on the tree search option
                "-m PROTGAMMAmatrixName[F]"       : specified AA matrix + Optimization of substitution rates + GAMMA model of rate 
                                                    heterogeneity (alpha parameter will be estimated)
                "-m PROTGAMMAmatrixName[F]_FLOAT" : PROTGAMMA with single precision arithmetics, same cautionary notes as for GTRCAT_FLOAT apply
                "-m PROTGAMMAImatrixName[F]"      : Same as PROTGAMMAmatrixName[F], but with estimate of proportion of invariable sites 

                Available AA substitution models: DAYHOFF, DCMUT, JTT, MTREV, WAG, RTREV, CPREV, VT, BLOSUM62, MTMAM, LG, GTR
                With the optional "F" appendix you can specify if you want to use empirical base frequencies
                Please note that for mixed models you can in addition specify the per-gene AA model in
                the mixed model file (see manual for details). Also note that if you estimate AA GTR parameters on a partitioned
                dataset, they will be linked (estimated jointly) across all partitions to avoid over-parameterization -->
   
<!-- not sure if we should support cat or not -->             		
					<parameter type="Excl" ismandatory="1">
						<name>prot_sub_model</name>
						<attributes>
							<prompt>Choose GAMMA or CAT model:</prompt>
							<precond>
								<language>perl</language>
								<code>$datatype eq "protein"</code>
							</precond>
							<vlist>
								<value>PROTGAMMA</value>
								<label>Protein GAMMA</label>
								<value>PROTCAT</value>
								<label>Protein CAT</label>
							</vlist>
<!--change for invariable option -->
							<format>
								<language>perl</language>
								<code>"-m $ascertainment$value$invariable$prot_matrix_spec$use_emp_freqs$use_ml_freqs$specify_ML"</code>
							</format>
							<vdef>
								<value>PROTCAT</value>
							</vdef>
							<group>2</group>
							<ctrls>
								<ctrl>
									<message>Please choose a protein model</message>
									<language>perl</language>
									<code>$datatype eq "protein" &amp;&amp; $prot_sub_model ne "PROTGAMMA" &amp;&amp; $prot_sub_model ne "PROTCAT" </code>
								</ctrl>
								<ctrl>
									<message>Sorry, the -f x option is valid only with GAMMA models</message>
									<language>perl</language>
									<code>$select_analysis eq "fx"  &amp;&amp; $prot_sub_model ne "PROTGAMMA"</code>
								</ctrl>
							</ctrls>
						</attributes>
					</parameter> 
		
				<parameter type="Excl" ismandatory="1">
						<name>prot_matrix_spec</name>
						<attributes>
							<prompt>Protein Substitution Matrix</prompt>
							<precond>
								<language>perl</language>
								<code>$datatype eq "protein"</code>
							</precond>
<!--New AA substitution models: MTART, MTZOA, PMB, HIVB, HIVW, JTTDCMUT, FLU 10/4/2010-->
							<vlist>
								<value>DAYHOFF</value>
								<label>DAYHOFF</label>
								<value>DCMUT</value>
								<label>DCMUT</label>
								<value>JTT</value>
								<label>JTT</label>
								<value>MTREV</value>
								<label>MTREV</label>
								<value>WAG</value>
								<label>WAG</label>
								<value>RTREV</value>
								<label>RTREV</label>
								<value>CPREV</value>
								<label>CPREV</label>
								<value>VT</value>
								<label>VT</label>
								<value>BLOSUM62</value>
								<label>BLOSUM62</label>
								<value>MTMAM</value>
								<label>MTMAM</label>
								<value>LG</value>
								<label>LG</label>
								<value>MTART</value>
								<label>MTART</label>
								<value>MTZOA</value>
								<label>MTZOA</label>
								<value>PMB</value>
								<label>PMB</label>
								<value>HIVB</value>
								<label>HIVB</label>
								<value>HIVW</value>
								<label>HIVW</label>
								<value>JTTDCMUT</value>
								<label>JTTDCMUT</label>
								<value>FLU</value>
								<label>FLU</label>
								<value>DUMMY</value>
								<label>DUMMY</label>
								<value>DUMMY2</value>
								<label>DUMMY2</label>
								<value>AUTO</value>
								<label>AUTO</label>
								<value>LG4M</value>
								<label>LG4M</label>
								<value>LG4X</value>
								<label>LG4X</label>
								<value>PROT_FILE</value>
								<label>PROT_FILE</label>
								<value>GTR_UNLINKED</value>
								<label>GTR_UNLINKED</label>
								<value>GTR</value>
								<label>GTR</label>
							</vlist>
							<vdef>
								<value>DAYHOFF</value>
							</vdef>
							<comment>
<value>Note: FLOAT and invariable sites (I) options are not exposed here. If you require this option, please contact mmiller@sdsc.edu.</value>
<value>-m PROTCATmatrixName: analyses using the specified AA matrix + Optimization of substitution rates + Optimization of site-specific evolutionary rates which are categorized into numberOfCategories distinct rate categories for greater computational efficiency. Final tree might be evaluated automatically under PROTGAMMAmatrixName[f], depending on the tree search option.
</value>
<value>-m PROTGAMMAmatrixName[F] analyses use the specified AA matrix + Optimization of substitution rates + GAMMA model of rate heterogeneity (alpha parameter will be estimated)</value>
<value>Available AA substitution models: DAYHOFF, DCMUT, JTT, MTREV, WAG, RTREV, CPREV, VT, BLOSUM62, MTMAM, LG, GTR. You can specify if you want to use empirical base frequencies. Please note that for mixed models you can in addition specify the per-gene AA model in the mixed model file (see manual for details). Also note that if you estimate AA GTR parameters on a partitioned dataset, they will be linked (estimated jointly) across all partitions to avoid over-parametrization.</value>
							</comment>
						</attributes>
					</parameter>

<!--[-P proteinModel] Specify the file name of a user-defined AA (Protein) substitution model. This file must contain 420 entries, the first 400 being the AA substitution rates (this must be a symmetric matrix) and the last 20 are the empirical base frequencies -->

					<parameter type="InFile" >
						<name>user_prot_matrix</name>
						<attributes>
							<prompt>Upload a Custom Protein Substitution Matrix (-P)</prompt>
							<precond>
								<language>perl</language>
								<code>$datatype eq "protein"</code>
							</precond>
							<format>
								<language>perl</language>
								<code>"-P Userproteinmatrix.txt"</code>
							</format>
							<group>2</group>
							<filenames>Userproteinmatrix.txt</filenames>
							<comment>
<value>Specify a file containing a user-defined Protein substitution model. This file must contain 420 entries, the first 400 entires are the AA substitution rates (this matrix must be symmetric) and the last 20 entries are the empirical base frequencies</value>
							</comment>
						</attributes>
					</parameter>
						
<!-- user requested option for multiple protein matrices-->	
					<parameter type="Switch">
						<name>mulcustom_aa_matrices</name>
						<attributes>
							<prompt>Use a Partition file that specifies AA Matrices</prompt>
							<precond>
								<language>perl</language>
								<code>$datatype eq "protein"</code>
							</precond>
							<ctrls>
								<ctrl>
									<message>Please choose a partition file specifying up to 5 partitions</message>
									<language>perl</language>
									<code>$mulcustom_aa_matrices &amp;&amp; !defined $partition</code>
								</ctrl>
							</ctrls>
							<comment>
								<value>This option can be used to specify multiple custom matrices via a partition file. The filenames must be specified as firstpartition, secondpartition, thirdpartition, fourthpartition, and fifthpartition, in order, </value>
							</comment>
						</attributes>
					</parameter>
										
<!--  This option has never received much attention in the RAxML manual and
tutorials, but I think it is available since one or two years. That's how it works in a local implementation.

Files needed:
data.phy
matrix1
matrix2
matrix3
partitions

The "matrix" files have a specific format, the same as if you use only
custom one. The "partitions" file is similar to the one used in regular partitioned
analyses. It is different only in that each line begins with the name of
the matrix file (with path if needed, between square brackets) instead of
the name of the model. The -q options tells the software to read this file.

A small "partition" file:
[/home/fn/Desktop/raxml776/mat582], firstpartition = 1-20
[/home/fn/Desktop/raxml776/mat1414], secondpartition = 21-30
[/home/fn/Desktop/raxml776/mat657], thirdpartition = 31-50


Then the command is:
./raxmlHPC -m PROTGAMMAMTREV -q partitions -p 123 -s smallprotein.phy -n
test 

The software takes the fact that we are talking about proteins (PROT) and
the among site rate variation part (GAMMA) from the PROTGAMMAMTREV token,
discarding the r-matrix (MTREV) part. The r-matrices are in turn taken
(differently for each partition) from the matrix files, whose location is
indicated in the partiton file. The among site rate variation has to be the
same for all partitions (not much of a problem). -->
	
					<parameter type="InFile" >
						<name>user_prot_matrixq1</name>
						<attributes>
							<prompt>Select the First Protein Substitution Matrix Called in Your Partition File</prompt>
							<precond>
								<language>perl</language>
								<code>$mulcustom_aa_matrices</code>
							</precond>
							<filenames>firstpartition</filenames>
							<comment>
<value>This option allows the user to upload a Protein subsitution matrix</value>
							</comment>
						</attributes>
					</parameter>
					
					<parameter type="InFile" >
						<name>user_prot_matrixq2</name>
						<attributes>
							<prompt>Select the Second Protein Substitution Matrix Called in Your Partition File</prompt>
							<precond>
								<language>perl</language>
								<code>$mulcustom_aa_matrices &amp;&amp; defined $user_prot_matrixq1</code>
							</precond>
							<filenames>secondpartition</filenames>
							<comment>
<value>This option allows the user to upload a second Protein subsitution matrix</value>
							</comment>
						</attributes>
					</parameter>
						
					<parameter type="InFile" >
						<name>user_prot_matrixq3</name>
						<attributes>
							<prompt>Select the Third Protein Substitution Matrix Called in Your Partition File</prompt>
							<precond>
								<language>perl</language>
								<code>$mulcustom_aa_matrices &amp;&amp; defined $user_prot_matrixq2</code>
							</precond>
							<filenames>thirdpartition</filenames>
							<comment>
<value>This option allows the user to upload a third Protein subsitution matrix</value>
							</comment>
						</attributes>
					</parameter>

					<parameter type="InFile" >
						<name>user_prot_matrixq4</name>
						<attributes>
							<prompt>Select the Fourth Protein Substitution Matrix Called in Your Partition File</prompt>
							<precond>
								<language>perl</language>
								<code>$mulcustom_aa_matrices &amp;&amp; defined $user_prot_matrixq3</code>
							</precond>
							<filenames>fourthpartition</filenames>
							<comment>
<value>This option allows the user to upload a fourth Protein subsitution matrix</value>
							</comment>
						</attributes>
					</parameter>	
						
					<parameter type="InFile" >
						<name>user_prot_matrixq5</name>
						<attributes>
							<prompt>Select the Fifth Protein Substitution Matrix Called in Your Partition File</prompt>
							<precond>
								<language>perl</language>
								<code>$mulcustom_aa_matrices &amp;&amp; defined $user_prot_matrixq4</code>
							</precond>
							<filenames>fifthpartition</filenames>
							<comment>
<value>This option allows the user to upload a fifth Protein subsitution matrix</value>
							</comment>
						</attributes>
					</parameter>

		<!-- Empirical Base Frequencies -->		
					<parameter type="Excl">
						<name>use_emp_freqs</name>
						<attributes>
							<prompt>Use empirical frequencies? [F]</prompt>
							<precond>
								<language>perl</language>
								<code>$datatype eq "protein"</code>
							</precond>
							<vlist>
								<value>F</value>
								<label>Yes</label>
								<value></value>
								<label>No</label>
							</vlist>
						</attributes>
					</parameter> 

		<!-- datatype=protein is a precondition, adds -F to end of -m model string -->
					<parameter type="Excl">
						<name>use_ml_freqs</name>
						<attributes>
							<prompt>Make an ML estimate of frequencies [X]</prompt>
							<precond>
								<language>perl</language>
								<code>$datatype eq "protein"</code>
							</precond>
							<vlist>
								<value>X</value>
								<label>Yes</label>
								<value></value>
								<label>No</label>
							</vlist>
							<ctrls>
								<ctrl>
									<message>Sorry you cant use bot the X and F optionsm, please choose one or the other</message>
									<language>perl</language>
									<code>$use_ml_freqs &amp;&amp; $use_emp_freqs </code>
								</ctrl>
							</ctrls>
						</attributes>
					</parameter> 
				
				</parameters>
			</paragraph>
		</parameter>
		
		<parameter type="Paragraph">
			<paragraph>
				<name>Sec_structure_opts</name>
				<prompt>RNA Secondary Structure Options</prompt>
				<parameters>
<!--***************************************************************************************************************************************************************************-->
<!-- ******************************THESE FEATURES ARE READY TO GO, BUT WHO KNOWS IF THEY WORK************************************************-->
<!-- 	[-S secondaryStructureFile] Specify the name of a secondary structure file. The file can contain "." for  alignment columns that do not form part of a stem and characters. "()<>[]{}" to define stem regions and pseudoknots -->
		 
					<parameter type="InFile" >
						<name>sec_str_file</name>
						<attributes>
						<precond>
								<language>perl</language>
								<code>$datatype eq "rna"</code>
							</precond> 
							<prompt>Upload a Secondary Structure File (-S)</prompt>
							<filenames>sec_structure.txt</filenames>
							<format>
								<language>perl</language>
								<code>(defined $value) ? " -S sec_structure.txt" : ""</code>
							</format>
							<group>2</group>
							<comment>
<value>This option allows you to provide a secondary structure file. The file can contain "." for  alignment columns that do not form part of a stem and characters, while  "(), [], and {}" are used to define stem regions and pseudoknots.</value>
							</comment>
						</attributes>
					</parameter>	 
		 
<!--     [-A secondaryStructureSubstModel] 	Specify one of the RNA secondary structure substitution models implemented in RAxML.
			The same nomenclature as in the PHASE manual is used, available models: 
			S6A, S6B, S6C, S6D, S6E, S7A, S7B, S7C, S7D, S7E, S7F, S16, S16A, S16B
			DEFAULT: 16-state GTR model (S16)
			6 state model nomenclature: http://www.cs.manchester.ac.uk/ai/Software/phase/manual/node101.html 
			7 state model nomenclature http://www.cs.manchester.ac.uk/ai/Software/phase/manual/node107.html
			16 state model nomenclature http://www.cs.manchester.ac.uk/ai/Software/phase/manual/node114.html -->
														  
 			<parameter type="Excl" ismandatory="1">
						<name>rna_model</name>
						<attributes>
							<prompt>Use an RNA Secondary Structure Substitution Model (-A)</prompt>
							<precond>
								<language>perl</language>
								<code>defined $sec_str_file</code>
							</precond>
							<vlist>
								<value>S6A</value>
								<label>Six State Model A</label>
								<value>S6B</value>
								<label>Six State Model B</label>
								<value>S6C</value>
								<label>Six State Model C</label>
								<value>S6D</value>
								<label>Six State Model D</label>
								<value>S6E</value>
								<label>Six State Model E</label>
								<value>S7A</value>
								<label>Seven State Model A</label>
								<value>S7B</value>
								<label>Seven State Model B</label>
								<value>S7C</value>
								<label>Seven State Model C</label>
								<value>S7D</value>
								<label>Seven State Model D</label>
								<value>S7E</value>
								<label>Seven State Model E</label>
								<value>S7F</value>
								<label>Seven State Model F</label>
								<value>S16A</value>
								<label>Sixteen State Model A</label>
								<value>S16B</value>
								<label>Sixteen State Model B</label>
							</vlist>
							<vdef>
								<value>S16A</value>
							</vdef>
							<format>
								<language>perl</language>
								<code>"-A $value"</code>
							</format>
							<group>2</group>
							<comment>
<value>Use this option to specify one of the 6, 7, or 16 state RNA secondary structure substitution models.The nomenclature is identical to that used in the program PHASE. For more information, see PHASE documentation: 6 state model nomenclature: http://www.cs.manchester.ac.uk/ai/Software/phase/manual/node101.html; 7 state model nomenclature http://www.cs.manchester.ac.uk/ai/Software/phase/manual/node107.html; 16 state model nomenclature http://www.cs.manchester.ac.uk/ai/Software/phase/manual/node114.html</value>
							</comment> 
					</attributes> 
					</parameter>
		
				</parameters>
			</paragraph>
		</parameter>
		
		<parameter type="Paragraph">
			<paragraph>
				<name>bin_opts</name>
				<prompt>Binary Matrix Options</prompt>
				<parameters>
						<!-- -m argument to specify substitution model is required -->
<!-- mmiller changed the way this is done  I exposed the other nucleic acid model options on 8/3/2009 -->
		<!--             [ -m      Model of Binary (Morphological), Nucleotide or Amino Acid Substitution]: 

            BINARY: (NEW for 7.2.0)

                "-m BINCAT"         : Optimization of site-specific
                                      evolutionary rates which are categorized into numberOfCategories distinct 
                                      rate categories for greater computational efficiency. Final tree might be evaluated
                                      automatically under BINGAMMA, depending on the tree search option
                "-m BINCATI"        : Optimization of site-specific
                                      evolutionary rates which are categorized into numberOfCategories distinct 
                                      rate categories for greater computational efficiency. Final tree might be evaluated
                                      automatically under BINGAMMAI, depending on the tree search option 
                "-m BINGAMMA"       : GAMMA model of rate heterogeneity (alpha parameter will be estimated)
                "-m BINGAMMAI"      : Same as BINGAMMA, but with estimate of proportion of invariable sites

The I option is not added in this interface                                                                 -->
					<parameter type="Excl" ismandatory="1">
						<name>bin_model</name>
						<attributes>
							<prompt>Binary data model (-m)</prompt>
							<precond>
								<language>perl</language>
								<code>$datatype eq "binary"</code>
							</precond> 
							<vlist>
								<value>BINCAT</value>
								<label>Binary CAT</label>
								<value>BINGAMMA</value>
								<label>Binary GAMMA</label>
							</vlist>
							<vdef>
								<value>BINCAT</value>
							</vdef>
							<format>
								<language>perl</language>
								<code>"-m $ascertainment$value$invariable$specify_ML"</code>
							</format>
							<group>2</group>
							<ctrls>
								<ctrl>
									<message>Please choose a binary model</message>
									<language>perl</language>
									<code>$datatype eq "binary" &amp;&amp; $bin_model ne "BINCAT" &amp;&amp; $bin_model ne "BINGAMMA" </code>
								</ctrl>
								<ctrl>
									<message>Sorry, the -f x option is valid only with GAMMA models</message>
									<language>perl</language>
									<code> $select_analysis eq "fx" &amp;&amp; $bin_model ne "BINGAMMA"</code>
								</ctrl>
							</ctrls>
							<comment>
<value>Binary data is handled in RAXML 7.2.0. Binary CAT use optimization of site-specific evolutionary rates, which are categorized into numberOfCategories (option -c) distinct  rate categories for greater computational efficiency. Final tree might be evaluatedautomatically under BINGAMMA, depending on the tree search option. </value>
<value>Binary GAMMA uses the GAMMA model of rate heterogeneity (alpha parameter will be estimated). The option for invariable sites is not provided at this time. The program's author supports the use of Gamma models.</value>
							</comment> 
						</attributes>
					</parameter>
				</parameters>
			</paragraph>
		</parameter>

		<parameter type="Paragraph">
			<paragraph>
				<name>multi_opts</name>
				<prompt>Multiple State Morphological Matrix Options</prompt>
				<parameters>
<!--             MULTI-STATE:

                 "-m MULTICAT"         Optimization of site-specific evolutionary rates which are categorized into numberOfCategories distinct
                                       rate categories for greater computational efficiency. Final tree might be evaluated automatically under MULTIGAMMA,
	                                   depending on the tree search option
                 "-m MULTICATI"        : Optimization of site-specific evolutionary rates which are categorized into numberOfCategories distinct
                                       rate categories for greater computational efficiency. Final tree might be evaluated automatically under MULTIGAMMAI, depending on the 
	                                   tree search option
                 "-m MULTIGAMMA"       : GAMMA model of rate heterogeneity (alpha parameter will be estimated)
                 "-m MULTIGAMMAI"      : Same as MULTIGAMMA, but with estimate of proportion of invariable sites
	                                     You can use up to 32 distinct characters to encode multi-state regions, they must be used in the following 
	                                     order:0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V
                                         i.e., if you have 6 distinct characters you would use 0, 1, 2, 3, 4, 5 to encode these.
                                         The substitution model for the multi-state regions can be selected via the "-K" option-->
					<parameter type="Excl" ismandatory="1">
						<name>multi_model</name>
						<attributes>
							<prompt>Multiple State Data Model (-m)</prompt>
							<precond>
								<language>perl</language>
								<code>$datatype eq "multi"</code>
							</precond> 
							<vlist>
								<value>MULTICAT</value>
								<label>Multi-state CAT</label>
								<value>MULTIGAMMA</value>
								<label>Multi-state GAMMA</label>
							</vlist>
							<vdef>
								<value>MULTICAT</value>
							</vdef>
							<format>
								<language>perl</language>
								<code>"-m $ascertainment$value$invariable$specify_ML"</code>
							</format>
							<group>2</group>
							<ctrls>
								<ctrl>
									<message>Please choose a Multi-State model</message>
									<language>perl</language>
									<code>$datatype eq "multi" &amp;&amp; $multi_model ne "MULTICAT" &amp;&amp; $multi_model ne "MULTIGAMMA" </code>
								</ctrl>
							</ctrls>
							<comment>
<value>Multi-state morphological data are handled in RAXML at V. 7.3.0 and above. Multi-state CAT uses optimization of site-specific evolutionary rates which are categorized
into numberOfCategories distinct rate categories for greater computational efficiency. Final tree might be evaluated automatically under MULTIGAMMA depending on the tree search option </value>
<value>Mutli-state GAMMA uses the GAMMA model of rate heterogeneity (alpha parameter will be estimated). Invariable sites (I) options are not exposed here. 
	If you require this option, please contact mmiller@sdsc.edu.</value>
							</comment> 
						</attributes>
					</parameter>
					
<parameter type="Excl" ismandatory="1">
<!--	[-K] syntax?(not yet supported)Specify one of the multi-state substitution models (max 32 states) implemented in RAxML.
              Available models are: ORDERED, MK, GTR
              DEFAULT: GTR model -->
						<name>choose_multi_model</name>
						<attributes>
							<prompt>Select a Multiple state data model (-K)</prompt>
  						<precond>
								<language>perl</language>
								<code>$datatype eq "multi"</code>
							</precond>
							<vlist>
								<value>ORDERED</value>
								<label>Ordered</label>
								<value>MK</value>
								<label>MK</label>
								<value>GTR</value>
								<label>GTR</label>
							</vlist>
							<vdef>
								<value>GTR</value>
							</vdef>
							<format>
								<language>perl</language>
								<code>"-K $value"</code>
							</format>
							<group>2</group>
							<ctrls>
								<ctrl>
									<message>Please choose a Multi-State data model</message>
									<language>perl</language>
									<code>$datatype eq "multi" &amp;&amp; $choose_multi_model ne "ORDERED" &amp;&amp; $choose_multi_model ne "MK" &amp;&amp; $choose_multi_model ne "GTR" </code>
								</ctrl>
							</ctrls>
							<comment>
<value>Multi-state morphological data are handled in RAXML 7.3.0 and above. Multi-state CAT uses optimization of site-specific evolutionary rates which are categorized
into numberOfCategories distinct rate categories for greater computational efficiency. Final tree might be evaluated automatically under MULTIGAMMA depending on the tree search option </value>
<value>Mutli-state GAMMA uses the GAMMA model of rate heterogeneity (alpha parameter will be estimated). The program's author supports the use of Gamma models.</value>
							</comment> 
						</attributes>
					</parameter>
					
					
				</parameters>
			</paragraph>
		</parameter>
		
		<parameter type="Paragraph">
			<paragraph>
				<name>set_analysis</name>
				<prompt>Configure the Analysis</prompt>
				<parameters>
					<parameter ismandatory="1" type="Excl">
						<name>select_analysis</name>
						<attributes>
							<prompt>Select the Analysis Type</prompt>
							<vlist>
								<value>fa</value>
								<label>Rapid bootstrap analysis / search for best-scoring ML tree (-f a)</label>
								<value>fd</value>
								<label>Use the default, faster rapid hill-climbing algorithm (-f d)</label>
								<value>fD</value>
								<label>Rapid hillclimbing searches that also generate RELL bootstraps (-f D)</label>									
								<value>fb</value>
								<label>Draw bipartitions onto a single tree topology. (-f b)</label>								
								<value>fA</value>
								<label>Compute Marginal Ancestral States using a rooted reference tree. (-f A)</label>
								<value>fJ</value>
								<label>Compute SH-like support values on a given tree passed via -t (-f J)</label>
								<value>fe</value>
								<label>Optimize model parameters+branch lengths for given input tree (-f e)</label>		
<!-- 
-fg compute per site log Likelihoods for one or more trees passed via z and write them to a file in treepuzzle format that can be read by CONSEL
The model parameters will be estimated on the first tree only!
Example: raxmlHPC f g s alg GTRGAMMA z trees n TEST 
-f G compute per site log Likelihoods for one or more trees passed via z and write them to a file in treepuzzle format that can be read by CONSEL.
The model parameters will be reestimated for each tree!
Example: raxmlHPC -f G -s alg -m -GTRGAMMA -z trees -n TEST -->
								<value>fg</value>
								<label>Compute per site log Likelihoods for one or more trees passed via z (-f g)</label>
								<value>fG</value>
								<label>Compute per site log Likelihoods for one or more trees passed via z (-f G)</label>
								<value>fh</value>
								<label>Compute a log likelihood test (-f h)</label>								
								<value>fT</value>
								<label>Do A Final Optimization of ML Tree (-f T)</label>								
								<value>fx</value>
								<label>Compute pair-wise ML distances (-f x; GAMMA models only)</label>
								<value>fk</value>
								<label>Fix long branch lengths in partitioned data sets with missing data (-f k)</label>								
								<value>fE</value>
								<label>Very fast experimental tree search(-f E)</label>								
								<value>fu</value>
								<label>Morphological weight calibration using maximum likelihood (-f u)</label>								
								<value>fv</value>
								<label>Classify a bunch of environmental sequences into a reference tree using thorough read insertions(-f v)</label>
								<value>fo</value>
								<label>Use the old and slower rapid hillclimbing without the heuristic cutoff (-f o)</label>
								<value>I</value>
								<label>Use a posteriori boostopping (-I)</label>
								<value>J</value>
								<label>Compute majority rule consensus tree (-J)</label>															
								<value>y</value>
								<label>Only compute a randomized parsimony starting tree (-y)</label>
							</vlist>
							<flist>
								<value>fa</value>
								<code>"-f a"</code>
								<value>fd</value>
								<code>""</code>	
								<value>fD</value>
								<code>"-f D"</code>						
								<value>fb</value>
								<code>"-f b"</code>								
								<value>fA</value>
								<code>"-f A"</code>
								<value>fJ</value>
								<code>"-f J"</code>	
								<value>fe</value>
								<code>"-f e"</code>	
								<value>fg</value>
								<code>"-f g"</code>	
								<value>fG</value>
								<code>"-f G"</code>							
								<value>fh</value>
								<code>"-f h"</code>							
								<value>fT</value>
								<code>"-f T"</code>								
								<value>fx</value>
								<code>"-f x"</code>	
								<value>fE</value>
								<code>"-f k"</code>								
								<value>fE</value>
								<code>"fk"</code>								
								<value>fu</value>
								<code>"-f u"</code>							
								<value>fv</value>
								<code>"-f v"</code>
								<value>fo</value>
								<code>"-f o"</code>
								<value>I</value>
								<code>"-I $aposterior_bootstopping"</code>
								<value>J</value>
								<code>"-J $specify_mr"</code>														
								<value>y</value>
								<code>"-y"</code>
							</flist>
							<vdef>
								<value>fd</value>
							</vdef>
							<ctrls>
								<ctrl>
									<message>To use the -f a option, please select Rapid Bootstrapping (-x)</message>
									<language>perl</language>
									<code>$choose_bootstrap ne "x" &amp;&amp; $select_analysis eq "fa"</code>
								</ctrl>
								<ctrl>
									<message>To use the -f A option please specify a best tree with "-t"</message>
									<language>perl</language>
									<code> $select_analysis eq "fA" &amp;&amp; !defined $treetop</code>
								</ctrl>
								<ctrl>
									<message>To use the -f J option, please specify a tree with "-t"</message>
									<language>perl</language>
									<code>$select_analysis eq "fJ" &amp;&amp; !defined $treetop</code>
								</ctrl>
								<ctrl>
									<message>To use the -f e option, please specify a tree with "-t"</message>
									<language>perl</language>
									<code>$select_analysis eq "fe" &amp;&amp; !defined $treetop</code>
								</ctrl>
								<ctrl>
									<message>To use the -f b option, please specify a best tree with "-t" and file containing multiple trees with the "-z" option</message>
									<language>perl</language>
									<code>$select_analysis eq "fb" &amp;&amp; ( !defined $bunchotops || !defined $treetop)</code>
								</ctrl>
								<ctrl>
									<message>Sorry, you cannot compute a log likelihood test (-f g) with GTRCAT models, please use "GTRGAMMA for the bootstrapping phase and GTRGAMMA for the final tree"</message>
									<language>perl</language>
									<code>($datatype eq "dna" || $datatype eq "rna" ) &amp;&amp; $select_analysis eq "fg" &amp;&amp; $dna_gtrcat eq "GTRCAT"</code>
								</ctrl>
								<ctrl>
									<message>To use the -f g option, please specify a file containing one or more trees with the "-z" option</message>
									<language>perl</language>
									<code>$select_analysis eq "fg" &amp;&amp; !defined $bunchotops</code>
								</ctrl>
								<ctrl>
									<message>Sorry, you cannot compute a log likelihood test (-f G) with GTRCAT models, please use "GTRGAMMA for the bootstrapping phase and GTRGAMMA for the final tree"</message>
									<language>perl</language>
									<code>($datatype eq "dna" || $datatype eq "rna" ) &amp;&amp; $select_analysis eq "fG" &amp;&amp; $dna_gtrcat eq "GTRCAT"</code>
								</ctrl>
								<ctrl>
									<message>To use the -f G option, please specify a file containing one or more trees with the "-z" option</message>
									<language>perl</language>
									<code>$select_analysis eq "fG" &amp;&amp; !defined $bunchotops</code>
								</ctrl>
								<ctrl>
									<message>Sorry, you cannot compute a log likelihood test (-f h) with GTRCAT models, please use "GTRGAMMA for the bootstrapping phase and GTRGAMMA for the final tree"</message>
									<language>perl</language>
									<code>($datatype eq "dna" || $datatype eq "rna" ) &amp;&amp; $select_analysis eq "fh" &amp;&amp; $dna_gtrcat eq "GTRCAT"</code>
								</ctrl>
								<ctrl>
									<message>To use the compute a log likelihood test option (-f h), please specify a best tree with "-t" and file containing multiple trees with the "-z" option</message>
									<language>perl</language>
									<code>$select_analysis eq "fh" &amp;&amp; (!defined $bunchotops || !defined $treetop)</code>
								</ctrl>
								<ctrl>
									<message>Sorry, you cannot compute a log likelihood test (-f h) with GTRCAT models, please select PROTGAMMA for the model</message>
									<language>perl</language>
									<code>$datatype eq "protein" &amp;&amp; $select_analysis eq "fh" &amp;&amp; $prot_sub_model eq "PROTCAT"</code>
								</ctrl>
								<ctrl>
									<message>Sorry, you cannot compute a log likelihood test (-f h) with GTRCAT models, please select PROTGAMMA for the model</message>
									<language>perl</language>
									<code>$datatype eq "protein" &amp;&amp; $select_analysis eq "fh" &amp;&amp; $prot_sub_model eq "PROTCAT"</code>
								</ctrl>
								<ctrl>
									<message>Sorry, you cannot compute a log likelihood test (-f h)  with GTRCAT models, please select BINGAMMA for the model</message>
									<language>perl</language>
									<code>$datatype eq "binary" &amp;&amp; $select_analysis eq "fh" &amp;&amp; $bin_model eq "BINCAT"</code>
								</ctrl>
								<ctrl>
									<message>Please specify a tree (via the -t option above) to use the -f T option</message>
									<language>perl</language>
									<code>$select_analysis eq "fT" &amp;&amp; !defined $treetop</code>
								</ctrl>
								<ctrl>
									<message>Sorry, to use the -f k option you must provide a tree (-t) a partition (-q) and estimate per partition branch lengths (-M) option</message>
									<language>perl</language>
									<code>$select_analysis eq "fk" &amp;&amp; (!defined $partition || !$estimate_perpartbrlen  || !defined $treetop)</code>
								</ctrl>								
								<ctrl>
									<message>Please specify a tree (via the -t option above) to use the -f u option</message>
									<language>perl</language>
									<code>$select_analysis eq "fu" &amp;&amp; !defined $treetop</code>
								</ctrl>
								<ctrl>
									<message>Please specify a non-comprehensive reference tree (via the -t option above) to use the -f v option</message>
									<language>perl</language>
									<code>$select_analysis eq "fv" &amp;&amp; !defined $treetop</code>
								</ctrl>
								<ctrl>
									<message>Sorry, you cannot use a posteriori bootstrapping with the -b or -x options</message>
									<language>perl</language>
									<code>$use_apobootstopping &amp;&amp; ($choose_bootstrap eq "x" || $choose_bootstrap eq "b")</code>
								</ctrl>		
								<ctrl>
									<message>In order to use the a posteriori bootstrapping option (-I), you must supply a file with topologies for a posteriori bootstopping (-z)</message>
									<language>perl</language>
									<code>$select_analysis eq "I" &amp;&amp; !defined $aposterior_topologies &amp;&amp; !defined $bunchotops</code>
								</ctrl>
								<ctrl>
									<message>Sorry, you cant use the -y option and provide a starting tree using -t.</message>
									<language>perl</language>
									<code>$select_analysis eq "y" &amp;&amp; defined $treetop</code>
								</ctrl>
							</ctrls>
							<warns>
								<warn>
									<message>The -J option requires a tree file containing several UNROOTED trees as input. If you provide anything else, the job will not progress, but it will use all of the configured run time. Please be sure you use a correct input file.</message>
									<language>perl</language>
									<code>$select_analysis eq "J"</code>
								</warn>
							</warns>
							<comment>
								<value>-f d This is the default RAxML tree search algorithm and is substantially faster than the original search algorithm. 
								It takes some shortcuts, but yields trees that are almost as good as the ones obtained from the full search algorithm.</value>
							</comment>
							<comment>
								<value>When -f b is specified, RAxML draws the bipartitions using a bunch of topologies (typically boot-strapped trees) specified with -z onto a single tree topology specified by -t (typically the best-scoring ML tree). </value>
							</comment>
							<comment>
								<value>When -f A is specified, RAxML computes marginal ancestral states/sequences on a given, fixed,and rooted reference
							tree. If you don't know what marginal ancestral states are please read  Ziheng Yang's book on Computational Molecular Evolution.. </value>
							</comment>
							<comment>
								<value>The -f h option computes a log likelihood test (SHtest) between the best tree passed via -t and a bunch of other trees passed via -z. The model parameters will be estimated on the first tree only!</value>
							</comment>
							<comment>
								<value>The -f T option allows the user to do a more thorough tree search that uses the 
									less lazy, i.e. more exhaustive SPR moves, in a stand alone mode. This algorithm is typically executed in the very end of a search done by -f a.</value>
							</comment>
							<comment>
								<value>If you use the -f o option you will typically get slightly better likelihood scores while the run times are expected to increase by factor 2 to 3. </value>
							</comment>
							<comment>
								<value>The -y option computes a randomized parsimony starting tree with RAxML and not execute an ML analysis of the tree specify -y. The program will exit after computation of the starting tree. This option can be useful if you want to assess the impact of randomized MP and Neighbor Joining starting trees on your search algorithm. They can also be used e.g. as starting trees for Derrick Zwickls GARLI program for ML inferences, which needs comparatively good starting trees to work well above approximately 500 taxa. </value>
							</comment>
						</attributes>
					</parameter>	
						
<!-- -#|-N numberOfRuns Specifies the number of alternative runs on distinct starting trees, e.g., if -# 10 or -N 10 is specfied RAxML
will compute 10 distinct ML trees starting from 10 distinct randomized maximum parsimony starting trees. -->
					<parameter type="Switch" ismandatory="1">
						<name>specify_runs</name>
						<attributes>
							<prompt>Specify the number alternative runs on distinct starting trees? (-N)</prompt>
							 <precond>
								<language>perl</language>
								<code>$select_analysis ne "J" &amp;&amp; $select_analysis ne "fg" &amp;&amp; $select_analysis ne "fG" &amp;&amp; $select_analysis ne "fh" &amp;&amp; $select_analysis ne "fT" &amp;&amp; $select_analysis ne "fE" &amp;&amp; $select_analysis ne "fA"  &amp;&amp; $choose_bootstrap ne "x" &amp;&amp; $choose_bootstrap ne "b" &amp;&amp; $select_analysis ne "fb" &amp;&amp; $select_analysis ne "y" &amp;&amp; $select_analysis ne "fv"</code>
							</precond>
							<comment>
								<value>This option specifies the number of alternative runs on distinct starting trees. For example, if  -N 10 is specfied, RAxML
will compute 10 distinct ML trees starting from 10 distinct randomized maximum parsimony starting trees. </value>
							</comment>
						</attributes>
					</parameter>
					
					<parameter type="Integer" ismandatory="1">
						<name>altrun_number</name>
						<attributes>
							<prompt>Enter number of number alternative runs (-N)</prompt>
							<precond>
								<language>perl</language>
								<code>$specify_runs</code>
							</precond>
							<format>
								<language>perl</language>
								<code>"-N $value"</code>
							</format>
							<vdef>
								<value>10</value>
							</vdef>
							<group>15</group>
							<ctrls>
								<ctrl>
									<message>Please specify how many runs you wish to execute with the -N option (eg 10)</message>
									<language>perl</language>
									<code>$specify_runs &amp;&amp; !defined $altrun_number</code>
								</ctrl>
								<ctrl>
									<message>Sorry, the value for alternative runs must 1000 or less for -N</message>
									<language>perl</language>
									<code>$altrun_number &gt; 1000</code>				
								</ctrl>		
							</ctrls>
							<comment>
								<value>if  -N 10 is specfied, RAxML will compute 10 distinct ML trees starting from 10 distinct randomized maximum parsimony starting trees.</value>
							</comment>
						</attributes>
					</parameter>
					
					<parameter type="InFile">
						<name>bunchotops</name>
						<attributes>
							<prompt>File with topologies for bipartitions (-z)</prompt>
							<precond>
								<language>perl</language>
								<code> ($select_analysis eq "fb" || $select_analysis eq "fh" || $select_analysis eq "fG" || $select_analysis eq "fg") &amp;&amp; !defined $aposterior_topologies</code>
							</precond>
								<format>
									<language>perl</language>
									<code>" -z topologies_file.tre"</code>
								</format>
							<group>2</group>
							<filenames>topologies_file.tre</filenames>
							<comment>
<value>The -z option is used in combination with the -f b,-f g, -f G, -f h,-f m,-f n options. The uploaded file should contain a number of trees in NEWICK format. The file should contain one tree per line without blank lines between trees. For example, you can directly read in a RAxML bootstrap result file.</value>
							</comment>
						</attributes>
					</parameter>
					
<!--  -->					
<!-- Dont use BFGS-->					
					<parameter type="Switch" issimple="0">
						<name>no_bfgs</name>
						<attributes>
							<prompt>Don't use BFGS searching algorithm (--no-bfgs)</prompt>
							<vdef>
								<value>0</value>
							</vdef>
							<format>
								<language>perl</language>
								<code>($value)? "--no-bfgs":""</code>
							</format>
							<comment>
<value> BFGS is a more efficient optimization algorithm for optimizing 
branch lengths and GTR parameters simultaneously. You can disable it using this option</value>
							</comment>
						</attributes>
					</parameter>	
									
<!-- -j option j
Specifies that intermediate tree files shall be written to file during the standard ML and BS tree searches.
DEFAULT: OFF

This will simply print out a couple of intermediate trees during the tree search and not the
final tree only. The intermediate trees are written to files called: RAxML_checkpoint.TEST.0, RAxML_checkpoint.TEST.1, etc.
-->
					<parameter type="Switch" >
						<name>intermediate_treefiles</name>
						<attributes>
							<prompt>Write intermediate tree files to a file (-j)</prompt>
							<vdef>
								<value>0</value>
							</vdef>
  							<precond>
								<language>perl</language>
								<code>$select_analysis ne "g" &amp;&amp; $select_analysis ne "G" &amp;&amp; $select_analysis ne "fT" &amp;&amp; $select_analysis ne "J" &amp;&amp; $select_analysis ne "fA" &amp;&amp; $select_analysis ne "fb" &amp;&amp; $select_analysis ne "fE" &amp;&amp; $select_analysis ne "y" &amp;&amp; $select_analysis ne "fh"  &amp;&amp; $select_analysis ne "fx" &amp;&amp; $select_analysis ne "fu" &amp;&amp; $select_analysis ne "fv"</code>
							</precond>
							<group>2</group>
							<format>
								<language>perl</language>
								<code>($value)?" -j ":""</code>
							</format>
							<comment>
								<value>This will simply print out a couple of intermediate trees during the tree search and not the
final tree only. The intermediate trees are written to files called: RAxML_checkpoint.TEST.0, RAxML_checkpoint.TEST.1, etc.</value>
							</comment>
						</attributes>
					</parameter>

<!-- -D option  = ML search convergence criterion. This will break off ML searches if the
relative RobinsonFoulds distance between the trees obtained from two consecutive lazy SPR cycles
is smaller or equal to 1%. Usage recommended for very large datasets in terms of taxa. On trees
with more than 500 taxa this will yield execution time improvements of approximately 50% while yielding
only slightly worse trees.

DEFAULT: OFF
	
When enabling this option, RAxML will stop ML and standard, slow bootstrap searches early,
when the RF distance between the trees generated by two consecutive cycles of SPR
(Subtree Pruning Re-Grafting) moves is smaller than 1%. This leads to substantial speed
improvements while the decrease in log likelihood scores is only very small. The option has
been tested on several datasets and the results have been included in the following book
chapter:
A. Stamatakis: "Phylogenetic Search Algorithms for Maximum Likelihood". In M. Elloumi,
A.Y. Zomaya, editors. Algorithms in Computational Biology: techniques, Approaches and
Applications, 547-577, John Wiley and Sons, 2011.
-->	
					<parameter type="Switch" >
						<name>convergence_criterion</name>
						<attributes>
							<prompt>Use ML search convergence criterion. (-D)</prompt>
							<vdef>
								<value>0</value>
							</vdef>
  							<precond>
								<language>perl</language>
								<code>$select_analysis ne "fg" &amp;&amp;  $select_analysis ne "fG" &amp;&amp; $select_analysis ne "fE" &amp;&amp; $select_analysis ne "J" &amp;&amp; $select_analysis ne "fA" &amp;&amp; $select_analysis ne "fb" &amp;&amp; $select_analysis ne "y" &amp;&amp; $select_analysis ne "fh" &amp;&amp; $select_analysis ne "fx"  &amp;&amp; !$specify_runs &amp;&amp; $select_analysis ne "fu" &amp;&amp; $select_analysis ne "fv"</code>
							</precond> 
							<group>2</group>
							<format>
								<language>perl</language>
								<code>($value)?" -D ":""</code>
							</format>
<!-- Error: the tree search convergence criterion "-D" has no effect in conjunction with the:  "-x" or "-f a" options.  -->
							<ctrls>
								<ctrl>
									<message>The tree search convergence criterion "-D" has no effect in conjunction with the:  "-x" or "-f a" options.</message>
									<language>perl</language>
									<code>$value &amp;&amp; ($select_analysis eq "fa" || $choose_bootstrap eq "x" )</code>
								</ctrl>
							</ctrls>
							<comment>
								<value>-D option  = ML search convergence criterion. This will break off ML searches if the
relative RobinsonFoulds distance between the trees obtained from two consecutive lazy SPR cycles
is smaller or equal to 1%. Usage recommended for very large datasets in terms of taxa. On trees
with more than 500 taxa this will yield execution time improvements of approximately 50% while yielding
only slightly worse trees.</value>
							</comment>
						</attributes>
					</parameter>				 
                
 					<parameter type="Excl" ismandatory="1">
						<name>specify_mr</name>
						<attributes>
							<prompt>Specify majority rule consensus tree (-J) technique </prompt>
 							<precond>
								<language>perl</language>
								<code>$select_analysis eq "J"</code>
							</precond>							
							<vlist>
								<value>MR</value>
								<label>Majority rule</label>
								<value>MRE</value>
								<label>Extended majority rule</label>
								<value>STRICT</value>
								<label>Strict Majority</label>
								<value>MR_DROP</value>
								<label>MR_Drop</label>
								<value>STRICT_DROP</value>
								<label>Strict_Drop</label>
							</vlist>
							<vdef>
								<value>MR</value>
							</vdef>
							<ctrls>
								<ctrl>
									<message>Please select a majority rule option for the -J option</message>
									<language>perl</language>
									<code>!$specify_mr</code>
								</ctrl>
							</ctrls>
							<comment>
<value>You must use a collection of trees as your input file for this option. The option lets you compute a majority rule consensus tree with "MR" or extended majority rule consensus tree with "J
MRE" or strict consensus tree with "J STRICT". Options "J STRICT_DROP" and "J MR_DROP" will execute an algorithm that identifies dropsets which contain rogue taxa as proposed by Pattengale et
al. in the paper "Uncovering hidden phylogenetic consensus". 
</value>
								</comment>
						</attributes>
					</parameter>	
					
<!--  	when I commentedthis out, I replaced two dashes with -* YOu will have to fix this to make it work again.
			<parameter  type="String">
                        <name>generic</name>
                        <attributes>
                            <prompt>Additional RAxML  options (advanced users only)</prompt>
                            <format>
                                <language>perl</language>
                                <code>"$value"</code>
                            </format>
                            <group>99</group>
							<ctrls>
								<ctrl>
									<message>Additional RAxML options: You must specify each argument separately, with a - or two dases</message>
									<language>perl</language> -->
									<!-- don't use !~, there's something wrong with the way we translate it to javascript in pise2JavaScriptControl.ftl. -->
 <!--							<code> 
  								!($value =~ /^\s*$/ ) &amp;&amp;  
									!($value =~ /^((((-[A-Za-z0-9])(\s+([A-Za-z0-9,_\.][A-Za-z0-9,_\.\-]*))?)|(-*\S+))\s+)*(((-[A-Za-z0-9])(\s+([A-Za-z0-9,_\.][A-Za-z0-9,_\.\-]*))?)|(-*\S+))\s*$/ ) 
									</code>
								</ctrl>
								<ctrl>
									<message>Sorry, additional RAxML options: -T and -w are not allowed. </message>
									<language>perl</language>
									<code> ($value =~ /^(-w)|(\s+-w)/ ) or ($value =~ /^(-T)|(\s+-T)/ ) </code>
								</ctrl>
							</ctrls>
							<comment>
							<value>This option is meant to allow users to run command line strings that are not currently supported explicitly by the interface. Values must be valid RaxML commands, and so must be preceded with a - or two dashes. Commands requiring file uploads are not currently supported. It is possible to enter commands that dont make sense, or conflict with already provided RaxML commands. We rely on the user to be vigilant.</value>
							</comment>
                        </attributes>
                    </parameter>	 -->

				</parameters>
			</paragraph>
		</parameter>

	<!-- under development for large DS -->
	<!-- 	[-D]													ML search convergence criterion. This will break off ML searches if the relative Robinson-Foulds distance
		large trees													between the trees obtained from two consecutive lazy SPR cycles is smaller or equal to 1%. Usage recommended
															for very large datasets in terms of taxa. On trees with more than 500 taxa this will yield execution time improvements
															of approximately 50% while yielding only slightly worse trees.
															DEFAULT: OFF -->
	<!-- 
	[-F]													enable ML tree searches under CAT model for very large trees without switching to GAMMA in the end (saves memory) and print out some additional files
			(large trees)									with intermediate trees from the search.	This option can also be used with the GAMMA models in order to avoid the thorough optimization  of the best-scoring
															ML tree in the end.
															DEFAULT: OFF-->	
	<!-- 
	[-L sequenceSimilarityThreshold]     	Same functionality as "-l" above, but uses a less exhaustive and thus faster clustering algorithm. This is intended for very large datasets with more than 	
			(large data sets)						20,000-30,000 sequences
															DEFAULT: OFF-->
	<!-- -->

<!-- ascertainment bias -->
<parameter type="Paragraph">
	<paragraph>
		<name>ascertainment_config</name>
		<prompt>Ascertainment Bias Confguration</prompt>
		<parameters>

					<parameter issimple="0" type="Excl" >
						<name>ascertainment</name>
						<attributes>
							<prompt>Correct for Ascertainment bias (ASC_)</prompt>
							<precond>
								<language>perl</language>
								<code>!$invariable</code>
							</precond>
							<vlist>
								<value>ASC_</value>
								<label>yes</label>
								<value></value>
								<label>no</label>
							</vlist>
							<vdef>
								<value></value>
							</vdef>
							<group>2</group>
							<warns>
								<warn>
									<message>Ascertainment bias correction will be applied only to partitions for which it is requested in the partition file (-q)</message>
									<language>perl</language>
									<code>$ascertainment eq "ASC_" &amp;&amp; defined $partition</code>
								</warn>
							</warns>
							<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 constantsites. In this case, RAxML will exit with an error.</value>
							</comment>
						</attributes>
					</parameter>
<!-- end ascertainment bias		-->
<!-- ascertainment bias -->
				<parameter issimple="0" type="Excl">
						<name>ascertainment_corr</name>
						<attributes>
							<prompt>Ascertainment bias correction type (--asc-corr)</prompt>
<!--  						<precond>
 								<language>perl</language>
								<code>$ascertainment eq "ASC_"</code>
							</precond> -->
							<format>
								<language>perl</language>
								<code>"--asc-corr $value"</code>
							</format>
							<vlist>
								<value>lewis</value>
								<label>Lewis</label>
								<value>felsenstein</value>
								<label>Felsenstein</label>
								<value>stamatakis</value>
								<label>Stamatakis</label>
							</vlist>
							<group>40</group>
							<ctrls>
								<ctrl>
									<message>To use the Felsentein option (--asc-corr), you must specify the number of invariable sites in a file using -q</message>
									<language>perl</language>
									<code>$ascertainment_corr eq "felsenstein" &amp;&amp; !defined $partition</code>
								</ctrl>
								<ctrl>
									<message>To use the Stamatakis option (--asc-corr), you must specify the number of invariable sites per state for each partition in a file using -q</message>
									<language>perl</language>
									<code>$ascertainment_corr eq "stamatakis" &amp;&amp; !defined $partition</code>
								</ctrl>
								<ctrl>
									<message>Please specify the ascertainment correction method</message>
									<language>perl</language>
									<code>$ascertainment eq "ASC_" &amp;&amp; !defined $ascertainment_corr </code>
								</ctrl>
							</ctrls>
							<comment>
								<value>This option allows to specify the type of ascertainment bias correction you wish to
use. There are three types available: Lewis: the standard correction by Paul Lewis, Felsenstein: a correction introduced by Joe Felsenstein
that allows to explicitely specify the number of invariable sites (if known) one wants to correct for. Stamatakis: a correction introduced by myself that
allows to explicitly specify the number of invariable sites for each character (if known) one wants to correct for. Flesenstein and Stamatkis corrections are 
accompanied by an upload file specified by the -q option, even if only one partiion is present. For file formatting, please see the RaxML 8.1 or higher manual.</value>
							</comment>
						</attributes>
					</parameter>
					
					<parameter issimple="0" type="InFile" ismandatory="1">
						<name>ascertainment_pfile1</name>
						<attributes>
							<prompt>Choose Ascertainment bias correction file 1 (will be named p1.txt)</prompt>
							<precond>
									<language>perl</language>
									<code>$ascertainment_corr eq "felsenstein" || $ascertainment_corr eq "stamatakis"</code>
							</precond>
							<filenames>p1.txt</filenames>
							<group>40</group>
							<ctrls>
								<ctrl>
									<message>To use the Felsentein option (--asc-corr), you must specify the number of invariable sites in a file</message>
									<language>perl</language>
									<code>$ascertainment_corr eq "felsenstein" &amp;&amp; !defined $ascertainment_pfile1</code>
								</ctrl>
								<ctrl>
									<message>To use the Stamatakis option (--asc-corr), you must provide the number of invariable sites per state in a file</message>
									<language>perl</language>
									<code>$ascertainment_corr eq "stamatakis" &amp;&amp; !defined $ascertainment_pfile1</code>
								</ctrl>
							</ctrls>
							<comment>
								<value>Ascertainment corrections that follow the Stamatakis or Felsenstein models require files that specify the number of invariant sites per state or the number of invariable sites, respectively. This file will be named p1.txt, For information on file formatting, please see the RaxML 8.1 or higher manual.</value>
							</comment>
						</attributes>
					</parameter>
					
					<parameter issimple="0" type="InFile" ismandatory="1">
						<name>ascertainment_pfile2</name>
						<attributes>
							<prompt>Choose Ascertainment bias correction file 2 (will be named p2.txt)</prompt>
							<precond>
									<language>perl</language>
									<code>defined $ascertainment_pfile1</code>
							</precond>
							<filenames>p2.txt</filenames>
							<group>40</group>
							<comment>
								<value>This file will be named p2.txt, For information on file formatting, please see the RaxML 8.1 or higher manual.</value>
							</comment>
						</attributes>
					</parameter>
					
					<parameter issimple="0" type="InFile" ismandatory="1">
						<name>ascertainment_pfile3</name>
						<attributes>
							<prompt>Choose Ascertainment bias correction file 3 (will be named p3.txt)</prompt>
							<precond>
									<language>perl</language>
									<code>defined $ascertainment_pfile2</code>
							</precond>
							<filenames>p3.txt</filenames>
							<group>40</group>
							<comment>
								<value>This file will be named p3.txt, For information on file formatting, please see the RaxML 8.1 or higher manual.</value>
							</comment>
						</attributes>
					</parameter>
					
					<parameter issimple="0" type="InFile" ismandatory="1">
						<name>ascertainment_pfile4</name>
						<attributes>
							<prompt>Choose Ascertainment bias correction file 4 (will be named p4.txt)</prompt>
							<precond>
									<language>perl</language>
									<code>defined $ascertainment_pfile3</code>
							</precond>
							<filenames>p4.txt</filenames>
							<group>40</group>
							<comment>
								<value>This file will be named p4.txt, For information on file formatting, please see the RaxML 8.1 or higher manual.</value>
							</comment>
						</attributes>
					</parameter>
					
					<parameter issimple="0" type="InFile" ismandatory="1">
						<name>ascertainment_pfile5</name>
						<attributes>
							<prompt>Choose Ascertainment bias correction file 5 (will be named p5.txt)</prompt>
							<precond>
									<language>perl</language>
									<code>defined $ascertainment_pfile4</code>
							</precond>
							<filenames>p5.txt</filenames>
							<group>40</group>
							<comment>
								<value>This file will be named p5.txt, For information on file formatting, please see the RaxML 8.1 or higher manual.</value>
							</comment>
						</attributes>
					</parameter>
					
					<parameter issimple="0" type="InFile" ismandatory="1">
						<name>ascertainment_pfile6</name>
						<attributes>
							<prompt>Choose Ascertainment bias correction file 6 (will be named p6.txt)</prompt>
							<precond>
									<language>perl</language>
									<code>defined $ascertainment_pfile5</code>
							</precond>
							<filenames>p6.txt</filenames>
							<group>40</group>
							<comment>
								<value>This file will be named p6.txt, For information on file formatting, please see the RaxML 8.1 or higher manual.</value>
							</comment>
						</attributes>
					</parameter>
					
					
<!-- Example 2: raxmlHPC p
12345 s
alg n
TEST m
ASC_GTRGAMMA
asccorr=
stamatakis q
part
Example 3: raxmlHPC p
12345 s
alg n
TEST m
ASC_GTRGAMMA
asccorr=
felsenstein q
part
44
Below, we give an example of such a partition file:
[asc~p1.txt], ASC_DNA, p4=11000
[asc~p2.txt], ASC_DNA, p5=10011965
Here, the first entries in each line, provide the name of the file containing the invariable site
counts or frequencies for each partition that are stored in plain text files called p1.txt and
p2.txt. Note that, the respective file names must be preceded by the asc keyword and the
~ separator symbol!
Thus, each partition is associated with a file containing these counts.
For the Felsenstein correction, these files could look like this:
p1.txt:
1000
p2.txt:
2000
With that we tell RAxML, that the likelihood first partition shall be corrected for 1000
invariable sites, while the likelihood of the second partition shall be corrected for 2000
invariable sites. Note that, each file (p1.txt and p2.txt) must only contain a single line
comprising integer values!
For my correction, the files could look as follows for DNA data:
p1.txt:
250 300 400 100
p2.txt:
500 300 200 200
With that we tell RAxML that the likelihood of the first partition shall be corrected for 250
sites consisting of As, 300 sites consisting of Cs, 400 sites of Gs and 100 sites of Ts. For
the second partition the likelihood is corrected for 500 invariable sites of As, 300 Cs, 200 Gs
and 200 Ts.
The difference among the two corrections is that with Joe Felsenstein's correction we know
how many invariable sites there are, but not their composition, so we correct for the
absence of 1000 invariable sites in the first partition that could consists of As or Cs or Gs or
Ts. My correction can be used when we do know the exact frequencies of invariable site
patterns.
WARNING: When generating these ascertainment bias correction files (e.g., p1.txt and
p2.txt) for my correction pay particular attention to the order of states that
corresponds to the order of frequencies of invariable sites per state:
BINARY: 0,1
DNA: A, C, G, T
PROTEIN: A, R, N, D, C, Q, E, G, H, I, L, K, M, F, P, S, T, W, Y, V
flagcheck
When using this option, RAxML will only check if all command line
flags specifed are available and then exit with a message listing
all invalid command line flags or with a message stating that all
flags are valid.
45 -->
					
<!-- ascertainment correction 		-->

		</parameters>
	</paragraph>
</parameter>
	
<!--  ************************************* high memory optons **************************** -->
<!-- Refactored to work with Comet -->
<!-- Rules for running RAxML via the CIPRES gateway

All runs are on Comet in the compute partition.
- Check whether the -N option is specified and, if so, what its value is.

- Also, check whether more than 20 GB of memory per process is needed.
  If more than 60 GB of memory per process is needed, the user should contact us.
  
- If -N is not specified,
  run the Pthreads-only version of RAxML using 12 threads on 12 cores of a single node.
  Thus include the following in the run script.

  #SBATCH -p compute
  #SBATCH -N 1
  #SBATCH -n 12
  #SBATCH (dash dash)ntasks-per-node=12
  ...
  module load raxml
  raxmlHPC-PTHREADS -T 12 ...

- If -N nnn is specified with nnn < 50,
  run the hybrid parallel version of RAxML on 24 cores of a single node using n MPI processes
  and t threads per process according to the following table.

    Memory per
  process (GB)    n    t

         <= 20    6    4
  > 20 & <= 30    4    6
  > 30 & <= 40    3    8
  > 40 & <= 60    2   12

  Thus include the following in the run script.

  #SBATCH -p compute
  #SBATCH -N 1
  #SBATCH -n 24
  #SBATCH (dash dash)ntasks-per-node=24
  ...
  module load raxml
  ibrun -np <n> raxmlHPC-HYBRID -T <t> ...

- If -N nnn is specified with nnn >= 50 or nnn = autoFC or nnn = autoMR or nnn =autoMRE
  or nnn = autoMRE_IGN,
  run the hybrid parallel version of RAxML on 48 cores of two nodes using n MPI processes
  and t threads per process according to the following table.

    Memory per
  process (GB)    n    t

         <= 20   12    4
  > 20 & <= 30    8    6
  > 30 & <= 40    6    8
  > 40 & <= 60    4   12

  #SBATCH -p compute
  #SBATCH -N 2
  #SBATCH -n 48
  #SBATCH (dash dash)ntasks-per-node=24
  ...
  module load raxml
  ibrun -np <n> raxmlHPC-HYBRID -T <t> ...
 -->
<!--  <parameter type="Paragraph">
		<paragraph> 
			<name>high_memory_options</name>
			<prompt>Configure more memory</prompt>
			<parameters>
		
 user asks for the ability to configure for a large data set 
					<parameter type="Switch" issimple="0" ismandatory="1">
						<name>more_memory</name>
						<attributes>
							<prompt>I have a data set that may require more than 20 GB of memory</prompt>
							<precond>
								<language>perl</language>
								<code>$datatype eq "dna" || $datatype eq "protein"</code>
							</precond>
							<vdef>
								<value>0</value>
							</vdef>
							<ctrls>
								<ctrl>
									<message>Sorry, the more memory option cant be used unless -N is used</message>
									<language>perl</language>
									<code>$choose_bootstrap ne "b" &amp;&amp; $choose_bootstrap ne "x" &amp;&amp; !$specify_runs &amp;&amp; $more_memory </code>
								</ctrl>
							</ctrls>
							<comment>
<value>To figure out if you need this option, use the RAxML memory calculator here: http://sco.h-its.org/exelixis/software.html.
Input the number of taxa, and patterns (or characters), and the gamma model(AA or DNA, as appropriate for your data). Multiply the value
you receive times 32. If that value is greater than 64 GB, then you should select this option. If you dont, the run will fail silently 
at the end due to an out of memory error.	 
								</value>
							</comment>
						</attributes>
					</parameter>	-->	
		
<!-- user enters ntax parameter this will help decide how to run 
		<parameter type="Integer" issimple="0">
			<name>ntax</name>
			<attributes>
				<prompt>Enter the number of taxa in your dataset</prompt>
				<precond>
					<language>perl</language>
					<code>$more_memory</code>
				</precond>
				<ctrls>
					<ctrl>
						<message>Please enter a value for the number of taxa in your data matrix</message>
						<language>perl</language>
						<code>!defined $ntax</code>
					</ctrl>
					<ctrl>
						<message>The number of taxa in the matrix must 1 or greater.</message>
						<language>perl</language>
						<code>$ntax &lt; 1</code>
					</ctrl>
					<ctrl>								
						<message>Your job does not require the large memory option, please uncheck the large memory box and run normally.</message>
						<language>perl</language>
						<code>$more_memory &amp;&amp; $datatype eq "dna" &amp;&amp;(($ntax - 2)*($nchar)*8*16) &lt; 20*(1024*1024*1024)</code>
						<!-*   &gt; 12*(1024*1024*1024) &amp;&amp; (($ntax - 2)*($nchar)*8*16) &lt; 15*(1024*1024*1024) *->
					</ctrl>					
					<ctrl>
						<message>Your job will probably not complete as configured, please contact us for help.</message>
						<language>perl</language>
						<code>$more_memory &amp;&amp; $datatype eq "dna" &amp;&amp; (($ntax-2)* ($nchar*8*16)) &gt; 120*(1024*1024*1024) </code>
					</ctrl>
					<ctrl>
						<message>Your job does not require the large memory option, please uncheck the large memory box and run normally.</message>
						<language>perl</language>
						<code>$more_memory &amp;&amp; $datatype eq "protein" &amp;&amp; (($ntax-2) * ($nchar*8*80)) &lt; 20*(1024*1024*1024)</code>
					</ctrl>
					<ctrl>
						<message>Your job will probably not complete as configured, please contact us for help.</message>
						<language>perl</language>
						<code>$more_memory &amp;&amp; $datatype eq "protein" &amp;&amp; (($ntax-2)* ($nchar*8*80)) &gt; 120*(1024*1024*1024)</code>
					</ctrl>
				</ctrls>
				<group>15</group>
				<comment>
					<value>
						Knowing the number of taxa and patterns in your dataset helps us determine the most efficient way to run raxml.
					</value>
				</comment>
			</attributes>
		</parameter> 

			</parameters>
		</paragraph>
</parameter>	-->
<!-- ************************* end high memory options ********************* -->


		<parameter type="Paragraph">
			<paragraph>
				<name>bootstrap_config</name>
				<prompt>Configure Bootstrapping</prompt>
				<parameters>
				
<!-- Refactor to choose bootstrapping under one or another as an excl box -->
 					<parameter type="Excl" >
						<name>choose_bootstrap</name>
						<attributes>
							<prompt>Choose a Bootstrapping Type</prompt>
							<precond>
								<language>perl</language>
								<code>$select_analysis eq "fd" || $select_analysis eq "fa" || $select_analysis eq "fo" </code>
							</precond>
							<vlist>
								<value>b</value>
								<label>Non-parametric Boostrapping (-b)</label>
								<value>x</value>
								<label>Rapid Bootstrapping (-x)</label>
								<value></value>
								<label>No Bootstrapping</label>
							</vlist>
							<comment>
								<value>The -b option allows you to turn on non-parametric bootstrapping. Note that parallel bootstraps with the parallel version raxmlHPC-MPI are not
reproducible despite the fact that you specify a random number seed. 
								</value>
								<value>Use rapid bootstrapping (-x) to turn on rapid bootstrapping. CAUTION: unlike in previous versions of RAxML will conduct rapid BS replicates under the model of rate heterogeneity you specified via m
 and not by default under CAT</value>
							</comment>
						</attributes>
					</parameter>
					
					<parameter type="Integer" ismandatory="1">
						<name>seed_value</name>
						<attributes>
							<prompt>Enter a random seed value for bootstrapping</prompt>
							<vdef>
								<value>12345</value>
							</vdef>
							<precond>
								<language>perl</language>
								<code>$choose_bootstrap eq "b" || $choose_bootstrap eq "x" </code>
							</precond>
							<group>2</group>
							<ctrls>
								<ctrl>
									<message>Please enter a random seed for the -b option (eg 12345)</message>
									<language>perl</language>
									<code>$choose_bootstrap eq "b" &amp;&amp; !defined $seed_value</code>
								</ctrl>
								<ctrl>
									<message>Please enter a random seed for the -x option (eg 12345)</message>
									<language>perl</language>
									<code>!defined $seed_value &amp;&amp; $choose_bootstrap eq "x"</code>
								</ctrl>
							</ctrls>
							<comment>
								<value>This random number is provided to assure that there is comparability between runs.</value>
							</comment>
						</attributes>
						</parameter>
	
<!-- this adds the command line when the -b option is chosen -->				
 					<parameter type="String" ishidden="1" ismandatory="1">
						<name>mulparambootstrap_seed_val</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>$choose_bootstrap eq "b"</code>
							</precond>
							<format>
								<language>perl</language>
								<code>" -b $seed_value"</code>
							</format>
							<vdef>
								<value>12345</value>
							</vdef>
							<group>2</group>
						</attributes>
						</parameter> 
						
<!--  this adds the command line when -x is chosen -->
 					<parameter type="String" ishidden="1" ismandatory="1">
						<name>bootstrap_seed_val</name>
						<attributes>
							<prompt>Enter a random seed value for bootstrapping</prompt>
							<precond>
								<language>perl</language>
								<code>$choose_bootstrap eq "x"</code>
							</precond>
							<format>
								<language>perl</language>
								<code>" -x $seed_value"</code>
							</format>
							<vdef>
								<value>12345</value>
							</vdef>
							<group>2</group>
						</attributes>
					</parameter>  
					
					<!-- rev 6 -->
					<!-- Do maximum likelihood search after bootstrap -->
					
<!-- 	[-k] 		Specifies that bootstrapped trees should be printed with branch lengths. The bootstraps will run a bit longer, because model parameters will be optimized at 
					the end of each run under GAMMA or GAMMA+P-Invar respectively. DEFAULT: OFF (old version said Use with CATMIX/PROTMIX or GAMMA/GAMMAI., check on this)-->

					<parameter type="Switch">
						<name>printbrlength</name>
						<attributes>
							<prompt>Print branch lengths (-k)</prompt>
							<format>
								<language>perl</language>
								<code> ($value)?" -k":""</code>
							</format>
							<vdef>
								<value>0</value>
							</vdef>
							<group>2</group>
							<comment>
								<value>	The -k option causes bootstrapped trees to be printed with branch lengths. 
The bootstraps will require a bit longer to run under this option because model parameters will be optimized at 
					the end of each run under GAMMA or GAMMA+P-Invar respectively.
								</value>
							</comment>
						</attributes>
					</parameter>
					
					<parameter type="Excl" ismandatory="1">
						<name>choose_bootstop</name>
						<attributes>
							<prompt>Specify bootstrap protocol</prompt>
							<precond>
								<language>perl</language>
								<code>$choose_bootstrap eq "x" || $choose_bootstrap eq "b"</code>
							</precond>
							<vlist>
								<value>specify</value>
								<label>Specify an explicit number of bootstraps</label>
								<value>bootstop</value>
								<label>Let RaxML halt bootstrapping automatically</label>
							</vlist>
							<vdef>
								<value>specify</value>
							</vdef>
							<ctrls>
								<ctrl>
									<message>Please select "Specify an explicit number of bootstraps" or "Let RaxML halt bootstrapping automatically"</message>
									<language>perl</language>
									<code>!defined $choose_bootstop</code>
								</ctrl>
<!-- 								<ctrl>
									<message>Sorry, you can not use a constraint tree with automatic boot stopping</message>
									<language>perl</language>
									<code>$choose_bootstop eq "bootstop" &amp;&amp; defined $constraint</code>
								</ctrl>  -->
							</ctrls>
							<comment>
<value>This option instructs Raxml to automatically halt bootstrapping when certain criteria are met, instead of specifying the number of bootstraps for an analysis. The exact criteria are specified/configured using subsequent entry fields.</value>
							</comment>
						</attributes>
					</parameter>
					
					<parameter type="Integer" ismandatory="1">
						<name>bootstrap_value</name>
						<attributes>
							<prompt>Bootstrap iterations (-N)</prompt>
							<precond>
								<language>perl</language>
								<code>$choose_bootstop eq "specify"</code>
							</precond>
							<format>
								<language>perl</language>
								<code>" -N $value"</code>
							</format>
							<vdef>
								<value>100</value>
							</vdef>
							<group>2</group>
							<ctrls>
								<ctrl>
									<message>Please enter number of bootstraps desired (-N) (eg 100)</message>
									<language>perl</language>
									<code>$choose_bootstop eq "specify" &amp;&amp; !defined $bootstrap_value</code>
								</ctrl>
<!-- bootstraps must be less than or equal to 1000 -->
								<ctrl>
									<message>Sorry, the number of bootstraps cannot exceed 1,000 (-N) </message>
									<language>perl</language>
									<code>$bootstrap_value &gt; 1000</code>
								</ctrl>	
							</ctrls>
							<comment>
								<value>Specifies the number of alternative runs on distinct starting trees. If 10, RAxML computes 10 distinct ML trees starting from 10 distinct randomized maximum parsimony starting trees. In combination with the Random seed for rapid bootstrap (-x) invoke a rapid BS analysis.
</value>
							</comment>
						</attributes>
					</parameter>
				
					<parameter type="Excl" >
						<name>bootstopping_type</name>
						<attributes>
							<prompt>Select Bootstopping Criterion: (autoMRE is recommended)</prompt>
							<precond>
								<language>perl</language>
								<code>$choose_bootstop eq "bootstop"</code>	
							</precond>													
							<format>
								<language>perl</language>
								<code>"-N $value"</code>
							</format>
							<vlist>
								<value>autoFC</value>
								<label>autoFC</label>
								<value>autoMR</value>
								<label>autoMR</label>
								<value>autoMRE</value>
								<label>autoMRE</label>
								<value>autoMRE_IGN</value>
								<label>autoMRE_IGN</label>
							</vlist>
							<vdef>
								<value>autoMRE</value>
							</vdef>
							<ctrls>
								<ctrl>
									<message>Please choose a bootstopping criterion</message>
									<language>perl</language>
									<code>!defined $bootstopping_type</code>
								</ctrl>
							</ctrls>
						</attributes>
					</parameter> 
					
<!-- a priori bootstopping (-I) is mutually exclusive with regular bootstopping (-N) -->	
					<parameter type="Excl" ismandatory="1">
						<name>aposterior_bootstopping</name>
						<attributes>
							<prompt>Select the criterion for a posteriori bootstopping analysis (-I)</prompt>
							<precond>
								<language>perl</language>
								<code>$select_analysis eq "I"</code>
							</precond>								
							<vlist>
								<value>autoFC</value>
								<label>autoFC</label>
								<value>autoMR</value>
								<label>autoMR</label>
								<value>autoMRE</value>
								<label>autoMRE</label>
								<value>autoMRE_IGN</value>
								<label>autoMRE_IGN</label>
							</vlist>
							<vdef>
								<value>autoMRE</value>
							</vdef>
								<comment>
<value>This option allows the user to conduct a posteriori bootstopping analysis based on a set of bootstrapped trees. Use: autoFC for the frequency-based criterion, autoMR for the majority-rule consensus tree criterion, autoMRE for the extended majority-rule consensus tree criterion
and autoMRE_IGN for metrics similar to MRE, but include bipartitions under the threshold whether they are compatible or not. This emulates MRE but is faster to compute. For any of these options, you also need to upload a tree file containing several bootstrap replicates via "-z"</value>
								</comment>
						</attributes>
					</parameter>
					
					<parameter type="InFile">
						<name>aposterior_topologies</name>
						<attributes>
							<prompt>File with topologies for a posteriori bootstopping (-z)</prompt>
							<precond>
								<language>perl</language>
								<code>$select_analysis eq "I" &amp;&amp; !defined $bunchotops</code>
							</precond>
								<format>
									<language>perl</language>
									<code>" -z apotopologies_file.tre"</code>
								</format>
							<group>2</group>
							<filenames>apotopologies_file.tre</filenames>
							<comment>
<value></value>
							</comment>
						</attributes>
					</parameter>		
					
				</parameters>
			</paragraph>
		</parameter>
		
		<!-- return all output files from raxml in one big mess -->
		
	 	<parameter type="Results">
				<name>all_outputfiles</name>
				<attributes>
					<filenames>*</filenames>
				</attributes>
			</parameter>		
		

	</parameters>
</pise>

