<?xml version="1.0" encoding="ISO-8859-1" ?>
<!DOCTYPE pise PUBLIC "pise.dtd" "pise2.dtd"  >
<pise>

  <head>
    <title>CLANN</title>
    <version>4.2.5</version>
    <description>Software for inferring phylogenetic supertrees</description>
        <authors>C. J. Creevey and J. O. McInerney</authors>
    <reference>Creevey C. J. and McInerney, J. O. (2005) Clann: Investigating phylogenetic information through supertree analyses. Bioinformatics 21 (3): 390-2.</reference>
    <category>Phylogeny / Alignment</category>
    <doclink>http://mcinerneylab.com/software/clann/</doclink>
  </head>
       
  <command>clann_expanse</command>
				
  <parameters>
<!--
********************************************************************************************************************
Prepared by mmiller 2/16/2023 or thereabouts

Clann Usage

Usage: "clann -lnh [-c commands file] [tree file]"

Where [tree file] is an optional Nexus or Phylip formatted file of phylogenetic trees
-l turn on logging of screen output to file "clann.log"
-n turns off interactive mode - requires commands to be provided in a nexus 'clann block' or with '-c'
-c <file name> specifies a file with commands to be executed (each seperated by ';')
-h prints this message

Available Commands:

The following commands are always available:

execute		- Read in a file of source trees
help		- Display this message
quit		- Quit Clann
set		- Set global parameters such as optimality criterion for carrying reconstructing a supertree
!		- Run a shell session, while preserving the current Clann session (type 'exit' to return)
tips		- Show tips and hints for better use of Clann
log		- Control logging of screen output to a log file

The following commands are only available when there are source trees in memory:

Supertree reconstruction:

hs		- Carry out a heuristic search for the best supertree usign the criterion selected
bootstrap	- Carry out a bootstrap supertree analysis using the criterion selected
nj		- Construct a neighbour-joining supertree
alltrees	- Exhaustively search all possible supertrees
usertrees	- Assess user-defined supertrees (from seperate file), to find the best scoring
consensus	- Calculate a consensus tree of all trees containing all taxa
 
 Clann can assess supertrees created using other programs Using the "usertrees" command, clann will read in the file specified and assess all the trees it contains
 The best supertree found in the file is displayed along with its score

Source tree selection and modification:

showtrees	- Visualise selected source trees in ASCII format (also can save selected trees to file)
deletetrees	- Specify source trees to delete from memory (based on a variety of criteria)
deletetaxa	- Specify taxa to delete from all source trees in memory (i.e. prune from the trees while preserving branch lengths)
randomisetrees	- Randomises the source trees in memory, while preserving taxa composition in each tree



Miscellaneous calculations:

rfdists		- Calculate Robinson-Foulds distances between all source trees
generatetrees	- Generate random supertrees & assess  against source trees in memory
yaptp		- "Yet another permutation-tail-probability" test - performs a randomisation test

Experimental Options:

reconstruct	- Carry out a gene-tree reconciliation (source trees against a species tree)
prunemonophylies - Prunes clades which consist of multiple sequences from the same species, to a single representative
sprdists	- Carry out estimation of SPR distances of real data versus ideal and randomised versions of the data

Type a command followed by '?' in interactive mode to get information on the options available i.e.: "exe ?" Full descriptions of the commands are available in the manual-->
    
  <!-- the wrapper includes clan n -ln; where 
   	-l turn on logging of screen output to file "clann.log"
	-n turns off interactive mode, allowing patch submission -->  
    <parameter iscommand="1" ishidden="1" type="String">
    	<name>invoke_clann</name>
		<attributes>
			<format>
	  			<language>perl</language>
	  			<code>"clann_4.2.5_expanse"</code>
			</format>
			<group>0</group>
      	</attributes>
    </parameter>

	<!-- scheduler file
	
  #SBATCH -p shared
  #SBATCH -*qos=shared-cipres
  #SBATCH -N 1
  #SBATCH -*ntasks-per-node=1
  #SBATCH -*cpus-per-task=1
  #SBATCH -*mem=2G
 -->
		<parameter type="String" ishidden="1" >
			<name>scheduler_input</name>
			<attributes>
				<paramfile>scheduler.conf</paramfile>
					<format>
						<language>perl</language>
						<code>
									"ChargeFactor=1.0\\n" .
									"nodes=1\\n" .
									"mem=243G\\n" .
									"node_exclusive=1\\n" .
									"threads_per_process=1\\n"
						</code>
					</format>
			</attributes>
		</parameter>
		
		<parameter type="String" ishidden="1" >
			<name>commands_header</name>
			<attributes>
					<precond>
						<language>perl</language>
						<code>$nexusBlock == 2 &amp;&amp; !defined $commandfile_mine</code>
					</precond>
				<paramfile>commandfile.txt</paramfile>
					<format>
						<language>perl</language>
						<code>
								   "# This is a commands file for use in a CIPRES application\\n" .
                                   "# For use of a commands file in clann\\n"  .
                                   "# This file is run by calling clann as follows:\\n" .
                                   "# clann -c commandfile.txt\\n" 
						</code>
					</format>
					<group>1</group>
			</attributes>
		</parameter>

	<!-- <parameter ismandatory="1" issimple="1"  type="InFile"> -->
    	<parameter ismandatory="1" issimple="1" isinput="1" type="InFile">
    		<name>infile</name>
      		<attributes>
			<filenames>infile.tre</filenames>
      	</attributes> 
    </parameter>
    
    <!-- 		hidden params to run the program		-->   		 
 <!-- specifies the command file when needed (no Nexcus Clann block)-->   
       		<parameter type="String" ishidden="1">
				<name>commandfile_command</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$nexusBlock == 2 </code>
					</precond>
					<format>
						<language>perl</language>
						<code>"-c commandfile.txt"</code>
					</format>
					<group>10</group>
				</attributes>
		</parameter>
		
<!--these hidden paramters create the commands.txt file-->      
				
 <!-- specifies the invocation string  exe-->   
       		<parameter type="String" ishidden="1">
				<name>clann_invoke1</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$nexusBlock == 2  &amp;&amp; !defined $commandfile_mine &amp;&amp; !defined $specify_maxnamelen &amp;&amp; !defined $specify_delimiter  </code>
					</precond>
					<format>
	  					<language>perl</language>
	   					<code>  "# Start with invocation followed by the tree file:\\n" .
	   									"exe infile.tre\\n" .
	   									" \\n"</code>
					</format>
					<paramfile>commandfile.txt</paramfile>
					<group>1</group>
				</attributes>
       		</parameter>
 				
 <!-- specifies the invocation line whenmaxnamelen is specified -->   
       		<parameter type="String" ishidden="1">
				<name>clann_invoke2</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$nexusBlock == 2   &amp;&amp; !defined $commandfile_mine &amp;&amp; defined $specify_maxnamelen &amp;&amp; !defined $specify_delimiter  </code>
					</precond>
					<format>
	  					<language>perl</language>
	   					<code>  "# Start with invocation followed by the tree file:\\n" .
	   									"exe infile.tre -maxnamelen=$specify_maxnamelen \\n" .
	   									" \\n"</code>
					</format>
					<paramfile>commandfile.txt</paramfile>
					<group>1</group>
				</attributes>
       		</parameter>      		
      				
 <!-- specifies the invocation line if a delimiter is provided-->   
       		<parameter type="String" ishidden="1">
				<name>clann_invoke3</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$nexusBlock == 2   &amp;&amp; !defined $commandfile_mine &amp;&amp; !defined $specify_maxnamelen &amp;&amp; defined $specify_delimiter </code>
					</precond>
					<format>
	  					<language>perl</language>
	   					<code>  "# Start with invocation followed by the tree file:\\n" .
	   									"exe infile.tre -delimiter_char $specify_delimiter\\n" .
	   									"\\n"</code>
					</format>
					<paramfile>commandfile.txt</paramfile>
					<group>1</group>
				</attributes>
       		</parameter>

<!-- invocation line when delimiter and maxnamlen are provided-->       		
       		<parameter type="String" ishidden="1">
				<name>clann_invoke4</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$nexusBlock == 2   &amp;&amp; !defined $commandfile_mine  &amp;&amp; defined $specify_maxnamelen &amp;&amp; defined $specify_delimiter  </code>
					</precond>
					<format>
	  					<language>perl</language>
	   					<code>  "# Start with invocation followed by the tree file:\\n" .
	   									"exe infile.tre -maxnamelen= $specify_maxnamelen -delimiter_char $specify_delimiter\\n" .
	   									"\\n"</code>
					</format>
					<paramfile>commandfile.txt</paramfile>
					<group>1</group>
				</attributes>
       		</parameter>
       		
  <!--  these hidden parameters create the necessary string to specify the analysis-->
  <!--paramters for specifying  an hs analysis-->
    		<parameter ishidden="1" type="String">
				<name>suptreerecon_hscommand</name>
				<attributes>
<!-- this command is when the user does not specify a starting tree file, and uses hs-->
					<precond>
						<language>perl</language>
						<code>$specify_start ne "user" &amp;&amp; $specify_suptreerecon eq "hs" &amp;&amp; $specify_criterion ne "mrp"</code>
					</precond>
					<group>20</group>
					<format>
						<language>perl</language>
						<code>
						"#instructions to build a build a  heuristic search supertree \\n" .
						"$specify_suptreerecon sample=$specify_sampleno nreps=$specify_nreps swap=$specify_swap nsteps=$specify_nsteps start=$specify_start maxswaps=$specify_maxswaps weight=$specify_weighttype savetrees=$specify_outputname drawhistogram=yes nbins=20;\\n" .
							" \\n"</code>
					</format>
					<paramfile>commandfile.txt</paramfile>
				</attributes>
		</parameter> 
		
<!-- When criterion = mrp and analysis = parsimony-->
    		<parameter ishidden="1" type="String">
				<name>suptreerecon_hscommand1b</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$specify_start ne "user" &amp;&amp; $specify_suptreerecon eq "hs" &amp;&amp; $specify_parsornj eq "parsimony"</code>
					</precond>
					<group>20</group>
					<format>
						<language>perl</language>
						<code>
						"#instructions to build a build a  heuristic search supertree \\n" .
						"$specify_suptreerecon sample=$specify_sampleno nreps=$specify_nreps swap=$specify_swap nsteps=$specify_nsteps start=$specify_start maxswaps=$specify_maxswaps weight=$specify_weighttype savetrees=$specify_outputname analysis=parsimony drawhistogram=yes nbins=20;\\n" .
							" \\n"</code>
					</format> 
					<paramfile>commandfile.txt</paramfile>
				</attributes>
		</parameter> 
		
<!-- When criterion = mrp and analysis = nj-->		
    	<parameter ishidden="1" type="String">
				<name>suptreerecon_hscommand1c</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$specify_start ne "user" &amp;&amp; $specify_suptreerecon eq "hs" &amp;&amp; $specify_parsornj eq "nj"</code>
					</precond>
					<group>20</group>
					<format>
						<language>perl</language>
						<code>
						"#instructions to build a build a  heuristic search supertree \\n" .
						"$specify_suptreerecon sample=$specify_sampleno nreps=$specify_nreps swap=$specify_swap nsteps=$specify_nsteps start=$specify_start maxswaps=$specify_maxswaps weight=$specify_weighttype savetrees=$specify_outputname analysis=nj drawhistogram=yes nbins=20;\\n" .
							" \\n"</code>
					</format> 
					<paramfile>commandfile.txt</paramfile>
				</attributes>
		</parameter>

<!-- hs When criterion ne mrp and analysis = variant for the case where user selects a starting  tree-->		
    		<parameter ishidden="1" type="String">
				<name>suptreerecon_commandhs2</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$specify_start eq "user" &amp;&amp; $specify_suptreerecon eq "hs"  &amp;&amp; $specify_criterion ne "mrp"</code>
					</precond>
					<group>20</group>
					<format>
						<language>perl</language>
						<code>
						"#instructions to build a build a heuristic search supertree with a user provided starting tree\\n" .
						"$specify_suptreerecon sample=$specify_sampleno nreps=$specify_nreps swap=$specify_swap nsteps=$specify_nsteps start=startingtree.tre maxswaps=$specify_maxswaps savetrees=$specify_outputname weight=$specify_weighttype drawhistogram=yes nbins=20 ;\\n" .
							" \\n"</code>
					</format>
					<paramfile>commandfile.txt</paramfile>
				</attributes>
		</parameter> 

<!-- hs When criterion = mrp and analysis = variant for the case where user selects a starting  tree; parsimony-->			
    	<parameter ishidden="1" type="String">
				<name>suptreerecon_hscommand2b</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$specify_start ne "user" &amp;&amp; $specify_suptreerecon eq "hs" &amp;&amp; $specify_parsornj eq "parsimony"</code>
					</precond>
					<group>20</group>
					<format>
						<language>perl</language>
						<code>
						"#instructions to build a build a  heuristic search supertree \\n" .
						"$specify_suptreerecon sample=$specify_sampleno nreps=$specify_nreps swap=$specify_swap nsteps=$specify_nsteps start=$specify_start maxswaps=$specify_maxswaps weight=$specify_weighttype savetrees=$specify_outputname analysis=parsimony drawhistogram=yes nbins=20;\\n" .
							" \\n"</code>
					</format> 
					<paramfile>commandfile.txt</paramfile>
				</attributes>
		</parameter>
		
<!-- hs When criterion = mrp and analysis = variant for the case where user selects a starting  tree; nj-->		
    	<parameter ishidden="1" type="String">
				<name>suptreerecon_hscommand2c</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$specify_start ne "user" &amp;&amp; $specify_suptreerecon eq "hs" &amp;&amp; $specify_parsornj eq "nj"</code>
					</precond>
					<group>20</group>
					<format>
						<language>perl</language>
						<code>
						"#instructions to build a build a  heuristic search supertree \\n" .
						"$specify_suptreerecon sample=$specify_sampleno nreps=$specify_nreps swap=$specify_swap nsteps=$specify_nsteps start=$specify_start maxswaps=$specify_maxswaps weight=$specify_weighttype savetrees=$specify_outputname analysis=nj drawhistogram=yes nbins=20;\\n" .
							" \\n"</code>
					</format> 
					<paramfile>commandfile.txt</paramfile>
				</attributes>
		</parameter>
		
<!-- hidden parameter to make command line for bootstrap and no user selected starting tree file and a user specified consensus method  -->
 <!-- when the user selects $specify_consensus = strict, majrule or minority-->		
<!-- bootstrap; no user starting tree; no user consensus value; not mrp -->
		  <parameter ishidden="1" type="String">
				<name>suptreerecon_bscommand1</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$specify_suptreerecon eq "bootstrap" &amp;&amp; $specify_start ne "user" &amp;&amp; $specify_consensus ne "user"  &amp;&amp; $specify_criterion ne "mrp"</code>
					</precond>
					<group>20</group>
					<format>
						<language>perl</language>
						<code>
						"#instructions to build a build a bootstrap supertree \\n" .
						"$specify_suptreerecon sample=$specify_sampleno nreps=$specify_nreps swap=$specify_swap nsteps=$specify_nsteps start=$specify_start maxswaps=$specify_maxswaps hsreps=$specify_hsreps consensus=$specify_consensus weight=$specify_weighttype treefile=$specify_outputname drawhistogram=yes nbins=20;\\n" .
							" \\n"</code>
					</format>
					<paramfile>commandfile.txt</paramfile>
				</attributes>
		</parameter> 
		
<!-- bootstrap; no user starting tree; no user consensus value criterion=mrp; parsimony -->		
		<parameter ishidden="1" type="String">
				<name>suptreerecon_bscommand1b</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$specify_suptreerecon eq "bootstrap" &amp;&amp; $specify_start ne "user" &amp;&amp; $specify_consensus ne "user"  &amp;&amp; $specify_parsornj eq "parsimony"</code>
					</precond>
					<group>20</group>
					<format>
						<language>perl</language>
						<code>
						"#instructions to build a build a bootstrap supertree \\n" .
						"$specify_suptreerecon sample=$specify_sampleno nreps=$specify_nreps swap=$specify_swap nsteps=$specify_nsteps start=$specify_start maxswaps=$specify_maxswaps hsreps=$specify_hsreps consensus=$specify_consensus weight=$specify_weighttype analysis=parsimony  treefile=$specify_outputname drawhistogram=yes nbins=20;\\n" .
							" \\n"</code>
					</format>
					<paramfile>commandfile.txt</paramfile>
				</attributes>
		</parameter> 
		
<!-- bootstrap; no user starting tree; no user consensus value criterion=mrp; nj -->		
		<parameter ishidden="1" type="String">
				<name>suptreerecon_bscommand1c</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$specify_suptreerecon eq "bootstrap" &amp;&amp; $specify_start ne "user" &amp;&amp; $specify_consensus ne "user"  &amp;&amp; $specify_parsornj eq "nj"</code>
					</precond>
					<group>20</group>
					<format>
						<language>perl</language>
						<code>
						"#instructions to build a build a bootstrap supertree \\n" .
						"$specify_suptreerecon sample=$specify_sampleno nreps=$specify_nreps swap=$specify_swap nsteps=$specify_nsteps start=$specify_start maxswaps=$specify_maxswaps hsreps=$specify_hsreps consensus=$specify_consensus weight=$specify_weighttype treefile=$specify_outputname analysis=nj  tdrawhistogram=yes nbins=20;\\n" .
							" \\n"</code>
					</format>
					<paramfile>commandfile.txt</paramfile>
				</attributes>
		</parameter>

<!-- variant for the case where user uses bootstrapping and selects  a starting tree-->	
 <!-- bootstrap; not mrp; user starting tree; no user consensus value -->	
    		<parameter ishidden="1" type="String">
				<name>suptreerecon_commandbootstrap2</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$specify_suptreerecon eq "bootstrap"  &amp;&amp; $specify_start eq "user" &amp;&amp; $specify_consensus ne "user"  &amp;&amp; $specify_criterion ne "mrp"</code>
					</precond>
					<group>20</group>
					<format>
						<language>perl</language>
						<code>
						"#instructions to build a build a bootstrap supertree with a user provided starting tree\\n" .
						"$specify_suptreerecon sample=$specify_sampleno nreps=$specify_nreps swap=$specify_swap nsteps=$specify_nsteps start=startingtree.tre maxswaps=$specify_maxswaps  hsreps=$specify_hsreps weight=$specify_weighttype consensus=$specify_consensus treefile=$specify_outputname drawhistogram=yes nbins=20 ;\\n" .
						" \\n"</code>
					</format>
					<paramfile>commandfile.txt</paramfile>
				</attributes>
		</parameter> 
		
 <!-- bootstrap; mrp; parsimony; user starting tree; no user consensus value -->			
		 <parameter ishidden="1" type="String">
				<name>suptreerecon_commandbootstrap2b</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$specify_suptreerecon eq "bootstrap"  &amp;&amp; $specify_start eq "user" &amp;&amp; $specify_consensus ne "user"  &amp;&amp; $specify_parsornj eq "parsimony"</code>
					</precond>
					<group>20</group>
					<format>
						<language>perl</language>
						<code>
						"#instructions to build a build a bootstrap supertree with a user provided starting tree\\n" .
						"$specify_suptreerecon sample=$specify_sampleno nreps=$specify_nreps swap=$specify_swap nsteps=$specify_nsteps start=startingtree.tre maxswaps=$specify_maxswaps  hsreps=$specify_hsreps weight=$specify_weighttype consensus=$specify_consensus  treefile=$specify_outputname  analysis=parsimony drawhistogram=yes nbins=20 ;\\n" .
						" \\n"</code>
					</format>
					<paramfile>commandfile.txt</paramfile>
				</attributes>
		</parameter> 

 <!-- bootstrap; mrp; nj; user starting tree; no user consensus value -->						
		 <parameter ishidden="1" type="String">
				<name>suptreerecon_commandbootstrap2c</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$specify_suptreerecon eq "bootstrap"  &amp;&amp; $specify_start eq "user" &amp;&amp; $specify_consensus ne "user"  &amp;&amp; $specify_parsornj eq "nj"</code>
					</precond>
					<group>20</group>
					<format>
						<language>perl</language>
						<code>
						"#instructions to build a build a bootstrap supertree with a user provided starting tree\\n" .
						"$specify_suptreerecon sample=$specify_sampleno nreps=$specify_nreps swap=$specify_swap nsteps=$specify_nsteps start=startingtree.tre maxswaps=$specify_maxswaps  hsreps=$specify_hsreps weight=$specify_weighttype consensus=$specify_consensus  treefile=$specify_outputname  analysis=nj drawhistogram=yes nbins=20 ;\\n" .
						" \\n"</code>
					</format>
					<paramfile>commandfile.txt</paramfile>
				</attributes>
		</parameter> 
				
 <!-- bootstrap; not mrp; no user starting tree; user consensus value -->		
    		<parameter ishidden="1" type="String">
				<name>suptreerecon_bscommand3</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$specify_suptreerecon eq "bootstrap" &amp;&amp; $specify_start ne "user" &amp;&amp; $specify_consensus eq "user"  &amp;&amp; $specify_criterion ne "mrp"</code>
					</precond>
					<group>20</group>
					<format>
						<language>perl</language>
						<code>
						"#instructions to build a build a bootstrap  supertree \\n" .
						"$specify_suptreerecon sample=$specify_sampleno nreps=$specify_nreps swap=$specify_swap nsteps=$specify_nsteps start=$specify_start maxswaps=$specify_maxswaps hsreps=$specify_hsreps weight=$specify_weighttype consensus=$specify_consensusfr  treefile=$specify_outputname  drawhistogram=yes nbins=20;\\n" .
							" \\n"</code>
					</format>
					<paramfile>commandfile.txt</paramfile>
				</attributes>
		</parameter> 

 <!-- bootstrap; mrp parsimony; no user starting tree; user consensus value -->				
		<parameter ishidden="1" type="String">
				<name>suptreerecon_bscommand3b</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$specify_suptreerecon eq "bootstrap" &amp;&amp; $specify_start ne "user" &amp;&amp; $specify_consensus eq "user"  &amp;&amp; $specify_parsornj eq "parsimony"</code>
					</precond>
					<group>20</group>
					<format>
						<language>perl</language>
						<code>
						"#instructions to build a build a bootstrap  supertree \\n" .
						"$specify_suptreerecon sample=$specify_sampleno nreps=$specify_nreps swap=$specify_swap nsteps=$specify_nsteps start=$specify_start maxswaps=$specify_maxswaps hsreps=$specify_hsreps weight=$specify_weighttype consensus=$specify_consensusfr  treefile=$specify_outputname  drawhistogram=yes analysis=parsimony nbins=20;\\n" .
							" \\n"</code>
					</format>
					<paramfile>commandfile.txt</paramfile>
				</attributes>
		</parameter> 

 <!-- bootstrap; mrp nj; no user starting tree; user consensus value -->			
		<parameter ishidden="1" type="String">
				<name>suptreerecon_bscommand3c</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$specify_suptreerecon eq "bootstrap" &amp;&amp; $specify_start ne "user" &amp;&amp; $specify_consensus eq "user"  &amp;&amp; $specify_parsornj eq "nj"</code>
					</precond>
					<group>20</group>
					<format>
						<language>perl</language>
						<code>
						"#instructions to build a build a bootstrap  supertree \\n" .
						"$specify_suptreerecon sample=$specify_sampleno nreps=$specify_nreps swap=$specify_swap nsteps=$specify_nsteps start=$specify_start maxswaps=$specify_maxswaps hsreps=$specify_hsreps weight=$specify_weighttype consensus=$specify_consensusfr  treefile=$specify_outputname  drawhistogram=yes analysis=nj nbins=20;\\n" .
							" \\n"</code>
					</format>
					<paramfile>commandfile.txt</paramfile>
				</attributes>
		</parameter> 
		
 <!-- bootstrap; not mrp; user starting tree; user consensus value -->	
     		<parameter ishidden="1" type="String">
				<name>suptreerecon_commandbootstrap4</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$specify_suptreerecon eq "bootstrap"  &amp;&amp; $specify_start eq "user" &amp;&amp; $specify_consensus eq "user"  &amp;&amp; $specify_criterion ne "mrp"</code>
					</precond>
					<group>20</group>
					<format>
						<language>perl</language>
						<code>
						"#instructions to build a build a bootstrap supertree with a user provided starting tree\\n" .
						"$specify_suptreerecon sample=$specify_sampleno nreps=$specify_nreps swap=$specify_swap nsteps=$specify_nsteps start=startingtree.tre maxswaps=$specify_maxswaps  hsreps=$specify_hsreps weight=$specify_weighttype consensus=$specify_consensusfr  treefile=$specify_outputname drawhistogram=yes nbins=20 ;\\n" .
						" \\n"</code>
					</format>
					<paramfile>commandfile.txt</paramfile>
				</attributes>
		</parameter> 

 <!-- bootstrap; mrp, parsimony; user starting tree; user consensus value -->						
    		<parameter ishidden="1" type="String">
				<name>suptreerecon_commandbootstrap4b</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$specify_suptreerecon eq "bootstrap"  &amp;&amp; $specify_start eq "user" &amp;&amp; $specify_consensus eq "user"  &amp;&amp; $specify_parsornj eq "parsimony"</code>
					</precond>
					<group>20</group>
					<format>
						<language>perl</language>
						<code>
						"#instructions to build a build a bootstrap supertree with a user provided starting tree\\n" .
						"$specify_suptreerecon sample=$specify_sampleno nreps=$specify_nreps swap=$specify_swap nsteps=$specify_nsteps start=startingtree.tre maxswaps=$specify_maxswaps  hsreps=$specify_hsreps weight=$specify_weighttype consensus=$specify_consensusfr  treefile=$specify_outputname analysis=parsimony drawhistogram=yes nbins=20 ;\\n" .
						" \\n"</code>
					</format>
					<paramfile>commandfile.txt</paramfile>
				</attributes>
		</parameter> 

 <!-- bootstrap; mrp, nj; user starting tree; user consensus value -->			
    		<parameter ishidden="1" type="String">
				<name>suptreerecon_commandbootstrap4c</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$specify_suptreerecon eq "bootstrap"  &amp;&amp; $specify_start eq "user" &amp;&amp;  $specify_consensus eq "user"  &amp;&amp; $specify_parsornj eq "nj"</code>
					</precond>
					<group>20</group>
					<format>
						<language>perl</language>
						<code>
						"#instructions to build a build a bootstrap supertree with a user provided starting tree\\n" .
						"$specify_suptreerecon sample=$specify_sampleno nreps=$specify_nreps swap=$specify_swap nsteps=$specify_nsteps start=startingtree.tre maxswaps=$specify_maxswaps  hsreps=$specify_hsreps weight=$specify_weighttype consensus=$specify_consensusfr  treefile=$specify_outputname  analysis=nj drawhistogram=yes nbins=20 ;\\n" .
						" \\n"</code>
					</format>
					<paramfile>commandfile.txt</paramfile>
				</attributes>
		</parameter>		
		
<!-- hidden parameter to specify the yaptp analysis; not mrp  with no selected starting tree file -->
    		<parameter ishidden="1" type="String">
				<name>suptreerecon_yaptpcommand</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$specify_start ne "user" &amp;&amp; $specify_suptreerecon eq "yaptp"  &amp;&amp; $specify_criterion ne "mrp"</code>
					</precond>
					<group>20</group>
					<format>
						<language>perl</language>
						<code>
						"#instructions to build a build a yaptp supertree \\n" .
						"$specify_suptreerecon sample=$specify_sampleno nreps=$specify_nreps search=$specify_swap nsteps=$specify_nsteps start=$specify_start maxswaps=$specify_maxswaps  hsreps=$specify_hsreps method=$specify_method weight=$specify_weighttype treefile=$specify_outputname drawhistogram=yes nbins=20;\\n" .
						" \\n"</code>
					</format>
					<paramfile>commandfile.txt</paramfile>
				</attributes>
		</parameter> 

<!-- hidden parameter to specify the yaptp analysis; mrp=parsimony  with no selected starting tree file -->
    		<parameter ishidden="1" type="String">
				<name>suptreerecon_yaptpcommand1b</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$specify_start ne "user" &amp;&amp; $specify_suptreerecon eq "yaptp"  &amp;&amp; $specify_parsornj eq "parsimony"</code>
					</precond>
					<group>20</group>
					<format>
						<language>perl</language>
						<code>
						"#instructions to build a build a yaptp supertree \\n" .
						"$specify_suptreerecon sample=$specify_sampleno nreps=$specify_nreps search=$specify_swap nsteps=$specify_nsteps start=$specify_start maxswaps=$specify_maxswaps  hsreps=$specify_hsreps method=$specify_method weight=$specify_weighttype treefile=$specify_outputname analysis=parsimony drawhistogram=yes nbins=20;\\n" .
						" \\n"</code>
					</format>
					<paramfile>commandfile.txt</paramfile>
				</attributes>
		</parameter> 

<!-- hidden parameter to specify the yaptp analysis; mrp=nj  with no selected starting tree file -->		
    		<parameter ishidden="1" type="String">
				<name>suptreerecon_yaptpcommand1c</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$specify_start ne "user" &amp;&amp; $specify_suptreerecon eq "yaptp"  &amp;&amp; $specify_parsornj eq "nj"</code>
					</precond>
					<group>20</group>
					<format>
						<language>perl</language>
						<code>
						"#instructions to build a build a yaptp supertree \\n" .
						"$specify_suptreerecon sample=$specify_sampleno nreps=$specify_nreps search=$specify_swap nsteps=$specify_nsteps start=$specify_start maxswaps=$specify_maxswaps  hsreps=$specify_hsreps method=$specify_method weight=$specify_weighttype treefile=$specify_outputname analysis=nj drawhistogram=yes nbins=20;\\n" .
						" \\n"</code>
					</format>
					<paramfile>commandfile.txt</paramfile>
				</attributes>
		</parameter> 
		
<!-- variant for the yaptp case where not mrp;  user selects  a starting tree-->		
    		<parameter ishidden="1" type="String">
				<name>suptreerecon_yaptpcommandhs2</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$specify_start eq "user" &amp;&amp; $specify_suptreerecon eq "yaptp"  &amp;&amp; $specify_criterion ne "mrp"</code>
					</precond>
					<group>20</group>
					<format>
						<language>perl</language>
						<code>
						"#instructions to build a build a yaptp supertree with a user provided starting tree\\n" .
						"$specify_suptreerecon sample=$specify_sampleno nreps=$specify_nreps search=$specify_swap nsteps=$specify_nsteps start=startingtree.tre maxswaps=$specify_maxswaps  hsreps=$specify_hsreps  method=$specify_method weight=$specify_weighttype treefile=$specify_outputname drawhistogram=yes nbins=20;\\n" .
							" \\n"</code>
					</format>
					<paramfile>commandfile.txt</paramfile>
				</attributes>
		</parameter> 

<!-- variant for the yaptp case where mrp=parsimony;  user selects  a starting tree-->			
		<parameter ishidden="1" type="String">
				<name>suptreerecon_yaptpcommandhs2b</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$specify_start eq "user" &amp;&amp; $specify_suptreerecon eq "yaptp"  &amp;&amp; $specify_parsornj eq "parsimony"</code>
					</precond>
					<group>20</group>
					<format>
						<language>perl</language>
						<code>
						"#instructions to build a build a yaptp supertree with a user provided starting tree\\n" .
						"$specify_suptreerecon sample=$specify_sampleno nreps=$specify_nreps search=$specify_swap nsteps=$specify_nsteps start=startingtree.tre maxswaps=$specify_maxswaps  hsreps=$specify_hsreps  method=$specify_method weight=$specify_weighttype treefile=$specify_outputname analysis=parsimony drawhistogram=yes nbins=20;\\n" .
							" \\n"</code>
					</format>
					<paramfile>commandfile.txt</paramfile>
				</attributes>
		</parameter> 

<!-- variant for the yaptp case where mrp=nj;  user selects  a starting tree-->				
		<parameter ishidden="1" type="String">
				<name>suptreerecon_yaptpcommandhs2c</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$specify_start eq "user" &amp;&amp; $specify_suptreerecon eq "yaptp"  &amp;&amp; $specify_parsornj eq "nj"</code>
					</precond>
					<group>20</group>
					<format>
						<language>perl</language>
						<code>
						"#instructions to build a build a yaptp supertree with a user provided starting tree\\n" .
						"$specify_suptreerecon sample=$specify_sampleno nreps=$specify_nreps search=$specify_swap nsteps=$specify_nsteps start=startingtree.tre maxswaps=$specify_maxswaps  hsreps=$specify_hsreps  method=$specify_method weight=$specify_weighttype treefile=$specify_outputname analysis=nj drawhistogram=yes nbins=20;\\n" .
							" \\n"</code>
					</format>
					<paramfile>commandfile.txt</paramfile>
				</attributes>
		</parameter> 

<!-- hidden parameter to specify the nj analysis; not mrp with no selected starting tree file -->
    		<parameter ishidden="1" type="String">
				<name>suptreerecon_njcommand</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$specify_suptreerecon eq "nj"  &amp;&amp; $specify_criterion ne "mrp"</code>
					</precond>
					<group>20</group>
					<format>
						<language>perl</language>
						<code>
						"#instructions to build a build a neighbor joining supertree \\n" .
						"$specify_suptreerecon missing=$specify_missingdata savetrees=$specify_outputname;\\n" .
							" \\n"
						</code>
					</format>
					<paramfile>commandfile.txt</paramfile>
				</attributes>
		</parameter>

<!-- hidden parameter to specify the nj analysis; mrp=parsimony with no selected starting tree file -->		
		<parameter ishidden="1" type="String">
				<name>suptreerecon_njcommand1b</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$specify_suptreerecon eq "nj"  &amp;&amp; $specify_parsornj eq "parsimony"</code>
					</precond>
					<group>20</group>
					<format>
						<language>perl</language>
						<code>
						"#instructions to build a build a neighbor joining supertree \\n" .
						"$specify_suptreerecon missing=$specify_missingdata savetrees=$specify_outputname analysis=parsimony;\\n" .
							" \\n"
						</code>
					</format>
					<paramfile>commandfile.txt</paramfile>
				</attributes>
		</parameter>
		
<!-- hidden parameter to specify the nj analysis; mrp=nj with no selected starting tree file -->		
		<parameter ishidden="1" type="String">
				<name>suptreerecon_njcommand1c</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$specify_suptreerecon eq "nj"  &amp;&amp; $specify_parsornj eq "nj"</code>
					</precond>
					<group>20</group>
					<format>
						<language>perl</language>
						<code>
						"#instructions to build a build a neighbor joining supertree \\n" .
						"$specify_suptreerecon missing=$specify_missingdata savetrees=$specify_outputname analysis=nj;\\n" .
							" \\n"
						</code>
					</format>
					<paramfile>commandfile.txt</paramfile>
				</attributes>
		</parameter>
		
<!-- hidden parameter to specify the alltrees analysis; not mrp with no specified range -->
    		<parameter ishidden="1" type="String">
				<name>suptreerecon_alltreescommand</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$specify_suptreerecon eq "alltrees"  &amp;&amp; !defined $specify_range  &amp;&amp; $specify_criterion ne "mrp"</code>
					</precond>
					<group>20</group>
					<format>
						<language>perl</language>
						<code>
						"#instructions to build a build an alltrees  supertree \\n" .
						"$specify_suptreerecon create=$specify_create weight=$specify_weighttype savetrees=$specify_outputname;\\n" .
							" \\n"</code>
					</format>
					<paramfile>commandfile.txt</paramfile>
				</attributes>
		</parameter>

<!-- hidden parameter to specify the alltrees analysis; mrp=parsimony with no specified range -->		
		<parameter ishidden="1" type="String">
				<name>suptreerecon_alltreescommand1b</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$specify_suptreerecon eq "alltrees"  &amp;&amp; !defined $specify_range  &amp;&amp; $specify_parsornj eq "parsimony"</code>
					</precond>
					<group>20</group>
					<format>
						<language>perl</language>
						<code>
						"#instructions to build a build an alltrees  supertree \\n" .
						"$specify_suptreerecon create=$specify_create weight=$specify_weighttype savetrees=$specify_outputname analysis=parsimony;\\n" .
							" \\n"</code>
					</format>
					<paramfile>commandfile.txt</paramfile>
				</attributes>
		</parameter>

<!-- hidden parameter to specify the alltrees analysis; mrp=nj;  with no specified range -->			
		<parameter ishidden="1" type="String">
				<name>suptreerecon_alltreescommand1c</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$specify_suptreerecon eq "alltrees"  &amp;&amp; !defined $specify_range  &amp;&amp; $specify_parsornj eq "nj"</code>
					</precond>
					<group>20</group>
					<format>
						<language>perl</language>
						<code>
						"#instructions to build a build an alltrees  supertree \\n" .
						"$specify_suptreerecon create=$specify_create weight=$specify_weighttype savetrees=$specify_outputname analysis=nj;\\n" .
							" \\n"</code>
					</format>
					<paramfile>commandfile.txt</paramfile>
				</attributes>
		</parameter>

<!-- hidden parameter to specify the alltrees analysis; not mrp;  with specified range -->
		  <parameter ishidden="1" type="String">
				<name>suptreerecon_alltreescommand2</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$specify_suptreerecon eq "alltrees" &amp;&amp; defined $specify_range &amp;&amp; $specify_criterion ne "mrp"</code>
					</precond>
					<group>20</group>
					<format>
						<language>perl</language>
						<code>
						"#instructions to build a build an alltrees  supertree \\n" .
						"$specify_suptreerecon range=$specify_range create=$specify_create weight=$specify_weighttype savetrees=$specify_outputname;\\n" .
							" \\n"</code>
					</format>
					<paramfile>commandfile.txt</paramfile>
				</attributes>
		</parameter>

<!-- hidden parameter to specify the alltrees analysis; mrp=parsimony;  with specified range -->		
		<parameter ishidden="1" type="String">
				<name>suptreerecon_alltreescommand2b</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$specify_suptreerecon eq "alltrees" &amp;&amp; defined $specify_range &amp;&amp; $specify_parsornj eq "parsimony"</code>
					</precond>
					<group>20</group>
					<format>
						<language>perl</language>
						<code>
						"#instructions to build a build an alltrees  supertree \\n" .
						"$specify_suptreerecon range=$specify_range create=$specify_create weight=$specify_weighttype savetrees=$specify_outputname analysis=parsimony;\\n" .
							" \\n"</code>
					</format>
					<paramfile>commandfile.txt</paramfile>
				</attributes>
		</parameter>
		
<!-- hidden parameter to specify the alltrees analysis; mrp=nj;  with specified range -->						
		<parameter ishidden="1" type="String">
				<name>suptreerecon_alltreescommand2c</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$specify_suptreerecon eq "alltrees" &amp;&amp; defined $specify_range &amp;&amp; $specify_parsornj eq "nj"</code>
					</precond>
					<group>20</group>
					<format>
						<language>perl</language>
						<code>
						"#instructions to build a build an alltrees  supertree \\n" .
						"$specify_suptreerecon range=$specify_range create=$specify_create weight=$specify_weighttype savetrees=$specify_outputname analysis=nj;\\n" .
							" \\n"</code>
					</format>
					<paramfile>commandfile.txt</paramfile>
				</attributes>
		</parameter>
		
<!-- hidden parameter to specify the usertrees analysis with crtiterion not mrp; no selected starting tree file -->
    		<parameter ishidden="1" type="String">
				<name>suptreerecon_usertreescommand</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$specify_suptreerecon eq "usertrees"  &amp;&amp; $specify_criterion ne "mrp"</code>
					</precond>
					<group>20</group>
					<format>
						<language>perl</language>
						<code>
						"#instructions to build a build a usertree supertree \\n" .
						"$specify_suptreerecon usertrees.txt weight=$specify_weighttype printsourcescores=$specify_printscores outfile=$specify_outputname;\\n" .
							" \\n"</code>
					</format>
					<paramfile>commandfile.txt</paramfile>
				</attributes>
		</parameter>
		
<!-- hidden parameter to specify the consensus  analysis criterion not mrp; with weight value standard choice; no guide tree -->
    		<parameter ishidden="1" type="String">
				<name>suptreerecon_consensuscommand</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$specify_suptreerecon eq "consensus"  &amp;&amp; $specify_consensus ne "user"  &amp;&amp; !defined $consensus_guidetree  &amp;&amp; $specify_criterion ne "mrp"</code>
					</precond>
					<group>20</group>
					<format>
						<language>perl</language>
						<code>
						"#instructions to build a build a consensus supertree \\n" .
						"$specify_suptreerecon method=$specify_consensus filename=$specify_outputname;\\n" .
							" \\n"</code>
					</format>
					<paramfile>commandfile.txt</paramfile>
				</attributes>
		</parameter>

<!-- hidden parameter to specify the consensus  analysis criterion mrp=parsimony; with weight value standard choice; no guide tree -->		
		 <parameter ishidden="1" type="String">
				<name>suptreerecon_consensuscommand1b</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$specify_suptreerecon eq "consensus"  &amp;&amp;  $specify_consensus ne "user"   &amp;&amp; !defined $consensus_guidetree  &amp;&amp; $specify_parsornj eq "parsimony"</code>
					</precond>
					<group>20</group>
					<format>
						<language>perl</language>
						<code>
						"#instructions to build a build a consensus supertree \\n" .
						"$specify_suptreerecon method=$specify_consensus filename=$specify_outputname analysis=parsimony;\\n" .
							" \\n"</code>
					</format>
					<paramfile>commandfile.txt</paramfile>
				</attributes>
		</parameter>

<!-- hidden parameter to specify the consensus  analysis criterion mrp=nj; with weight value standard choice; no guide tree -->					
		 <parameter ishidden="1" type="String">
				<name>suptreerecon_consensuscommand1c</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$specify_suptreerecon eq "consensus"  &amp;&amp;  $specify_consensus ne "user"  &amp;&amp; !defined $consensus_guidetree  &amp;&amp; $specify_parsornj eq "nj"</code>
					</precond>
					<group>20</group>
					<format>
						<language>perl</language>
						<code>
						"#instructions to build a build a consensus supertree \\n" .
						"$specify_suptreerecon method=$specify_consensus filename=$specify_outputname analysis=nj;\\n" .
							" \\n"</code>
					</format>
					<paramfile>commandfile.txt</paramfile>
				</attributes>
		</parameter>
		
<!-- hidden parameter to specify the consensus analysis; criterion ne mrp user defined  weights value specified no guide tree -->
    		<parameter ishidden="1" type="String">
				<name>suptreerecon_consensuscommand2</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$specify_suptreerecon eq "consensus"  &amp;&amp;  $specify_consensus eq "user" &amp;&amp; !defined $consensus_guidetree  &amp;&amp; $specify_criterion ne "mrp"</code>
					</precond>
					<group>20</group>
					<format>
						<language>perl</language>
						<code>
						"#instructions to build a build a consensus supertree \\n" .
						"$specify_suptreerecon method=$specify_consensusfr filename=$specify_outputname;\\n" .
							" \\n"</code>
					</format>
					<paramfile>commandfile.txt</paramfile>
				</attributes>
		</parameter>

<!-- hidden parameter to specify the consensus analysis; criterion mrp=parsimony; user defined  weights value specified no guide tree -->	
	   	<parameter ishidden="1" type="String">
				<name>suptreerecon_consensuscommand2b</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$specify_suptreerecon eq "consensus"  &amp;&amp;  $specify_consensus eq "user" &amp;&amp; !defined $consensus_guidetree  &amp;&amp; $specify_parsornj eq "parsimony"</code>
					</precond>
					<group>20</group>
					<format>
						<language>perl</language>
						<code>
						"#instructions to build a build a consensus supertree \\n" .
						"$specify_suptreerecon method=$specify_consensusfr filename=$specify_outputname analysis=parsimony;\\n" .
							" \\n"</code>
					</format>
					<paramfile>commandfile.txt</paramfile>
				</attributes>
		</parameter>

<!-- hidden parameter to specify the consensus analysis; criterion mrp=nj; user defined  weights value specified no guide tree -->			
	   	<parameter ishidden="1" type="String">
				<name>suptreerecon_consensuscommand2b</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$specify_suptreerecon eq "consensus"  &amp;&amp;  $specify_consensus eq "user" &amp;&amp; !defined $consensus_guidetree  &amp;&amp; $specify_parsornj eq "nj"</code>
					</precond>
					<group>20</group>
					<format>
						<language>perl</language>
						<code>
						"#instructions to build a build a consensus supertree \\n" .
						"$specify_suptreerecon method=$specify_consensusfr filename=$specify_outputname analysis=nj;\\n" .
							" \\n"</code>
					</format>
					<paramfile>commandfile.txt</paramfile>
				</attributes>
			</parameter>

<!-- hidden parameter to specify the consensus analysis; criterion ne mrp; with user defined weight value standard choice; and guidetree -->
    		<parameter ishidden="1" type="String">
				<name>suptreerecon_consensuscommand3</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$specify_suptreerecon eq "consensus"  &amp;&amp; $specify_consensus ne "user" &amp;&amp; defined $consensus_guidetree  &amp;&amp; $specify_criterion ne "mrp"</code>
					</precond>
					<group>20</group>
					<format>
						<language>perl</language>
						<code>
						"#instructions to build a build a consensus supertree \\n" .
						"$specify_suptreerecon method=$specify_consensus guidetree=guidetree.tre filename=$specify_outputname;\\n" .
							" \\n"</code>
					</format>
					<paramfile>commandfile.txt</paramfile>
				</attributes>
		</parameter>
		
<!-- hidden parameter to specify the consensus analysis; criterion mrp=parsimony; with user defined weight value standard choice; and guidetree -->		
		<parameter ishidden="1" type="String">
				<name>suptreerecon_consensuscommand3b</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$specify_suptreerecon eq "consensus"  &amp;&amp; $specify_consensus ne "user" &amp;&amp; defined $consensus_guidetree  &amp;&amp;  $specify_parsornj eq "parsimony"</code>
					</precond>
					<group>20</group>
					<format>
						<language>perl</language>
						<code>
						"#instructions to build a build a consensus supertree \\n" .
						"$specify_suptreerecon method=$specify_consensus guidetree=guidetree.tre analysis=parsimony filename=$specify_outputname;\\n" .
							" \\n"</code>
					</format>
					<paramfile>commandfile.txt</paramfile>
				</attributes>
		</parameter>

<!-- hidden parameter to specify the consensus analysis; criterion mrp=nj; with user defined weight value standard choice; and guidetree -->			
		<parameter ishidden="1" type="String">
				<name>suptreerecon_consensuscommand3c</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$specify_suptreerecon eq "consensus"  &amp;&amp; $specify_consensus ne "user" &amp;&amp; defined $consensus_guidetree  &amp;&amp;  $specify_parsornj eq "nj"</code>
					</precond>
					<group>20</group>
					<format>
						<language>perl</language>
						<code>
						"#instructions to build a build a consensus supertree \\n" .
						"$specify_suptreerecon method=$specify_consensus guidetree=guidetree.tre analysis=nj filename=$specify_outputname;\\n" .
							" \\n"</code>
					</format>
					<paramfile>commandfile.txt</paramfile>
				</attributes>
		</parameter>			

<!-- hidden parameter to specify the consensus analysis; criterion not mrp; with weights value specified with guidetree -->
    		<parameter ishidden="1" type="String">
				<name>suptreerecon_consensuscommand4</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$specify_suptreerecon eq "consensus"  &amp;&amp; $specify_consensus eq "user" &amp;&amp; defined $consensus_guidetree  &amp;&amp; $specify_criterion ne "mrp"</code>
					</precond>
					<group>20</group>
					<format>
						<language>perl</language>
						<code>
						"#instructions to build a build a consensus supertree \\n" .
						"$specify_suptreerecon method=$specify_consensusfr guidetree=guidetree.tre filename=$specify_outputname;\\n" .
							" \\n"</code>
					</format>
					<paramfile>commandfile.txt</paramfile>
				</attributes>
		</parameter>

<!-- hidden parameter to specify the consensus analysis; criterion mrp=parsimony; with weights value specified with guidetree -->
    		<parameter ishidden="1" type="String">
				<name>suptreerecon_consensuscommand4b</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$specify_suptreerecon eq "consensus"  &amp;&amp; $specify_consensus eq "user" &amp;&amp; defined $consensus_guidetree  &amp;&amp; $specify_parsornj eq "parsimony"</code>
					</precond>
					<group>20</group>
					<format>
						<language>perl</language>
						<code>
						"#instructions to build a build a consensus supertree \\n" .
						"$specify_suptreerecon method=$specify_consensusfr guidetree=guidetree.tre analysis=parsimony filename=$specify_outputname;\\n" .
							" \\n"</code>
					</format>
					<paramfile>commandfile.txt</paramfile>
				</attributes>
		</parameter>

<!-- hidden parameter to specify the consensus analysis; criterion mrp=nj; with weights value specified with guidetree -->
    		<parameter ishidden="1" type="String">
				<name>suptreerecon_consensuscommand4c</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$specify_suptreerecon eq "consensus"  &amp;&amp; $specify_consensus eq "user" &amp;&amp; defined $consensus_guidetree  &amp;&amp; $specify_parsornj eq "nj"</code>
					</precond>
					<group>20</group>
					<format>
						<language>perl</language>
						<code>
						"#instructions to build a build a consensus supertree \\n" .
						"$specify_suptreerecon method=$specify_consensusfr guidetree=guidetree.tre analysis=nj filename=$specify_outputname;\\n" .
							" \\n"</code>
					</format>
					<paramfile>commandfile.txt</paramfile>
				</attributes>
		</parameter>			
   
   	<!-- hidden parameter to quit-->
    		<parameter ishidden="1" type="String">
				<name>quit_command</name>
				<attributes>
					<group>90</group>
					<format>
						<language>perl</language>
						<code>
						"#here is the quit command \\n" .
						"quit;\\n" .
							" \\n"</code>
					</format>
					<paramfile>commandfile.txt</paramfile>
				</attributes>
		</parameter>
		
    <!-- Begin visible parameters -->
	<parameter type="Float" issimple="1" ismandatory="1">
		<name>runtime</name>
		<attributes>
			<prompt>Maximum Hours to Run (click here for help setting this correctly)</prompt>
			<group>1</group>
			<paramfile>scheduler.conf</paramfile>
			<format>
				<language>perl</language>
				<code>"runhours=$value\\n"</code>
			</format>
			<vdef>
				<value>1.0</value>
			</vdef>
			<ctrls>
				<ctrl>
					<message>Maximum Hours to Run must be between 0.1 - 168.0.</message>
					<language>perl</language>
					<code>$runtime &lt; 0.1 || $runtime &gt;168.0</code>
				</ctrl>
				<ctrl>
					<message>Please enter  a value for the runtime</message>
					<language>perl</language>
					<code>!defined $runtime </code>
				</ctrl>
			</ctrls>
			<warns>
				<warn>
					<message>Your job will run on one processor as configured. If it runs for the full specificed time, it will consume 1x $runtime cpu hours</message>
					<language>perl</language>
					<code>defined $runtime</code>
				</warn>
			</warns>
			<comment>
				<value>
				Estimate the maximum time your job will need to run (up to 72 hrs).  Your job will be killed if it doesn't finish within the time you specify, however jobs with shorter maximum run times are often scheduled sooner than longer jobs.
				</value>
			</comment>
		</attributes>
	</parameter>

<!-- valid exe     <filename> options

        Options         Settings                        Current
        ===========================================================

        maxnamelen      <integer number> | delimited    *none
        delimiter_char  <character>                     '.'

        ===========================================================-->    		
			<parameter issimple="1"  type="Integer">
					<name>specify_maxnamelen</name>
					<attributes>
						<prompt>Consider only the first x letters of each taxon name.</prompt>
						<comment>
							<value>This option allows the user to specify that the software should only look at the first x number of characters when reading the taxon name. This allows the inclusion of other information along with the name of the taxa.</value>
						</comment>
					</attributes>
			</parameter>

 <!-- I need to use an auxiliary command file-->
    		<parameter issimple="1" ismandatory="1"  type="Excl">
				<name>nexusBlock</name>
				<attributes>
					<prompt>Data set is in Nexus format, and has  a Clann block</prompt>
					<vlist>
						<value>1</value>
						<label>Yes</label>
						<value>2</value>
						<label>No</label>
					</vlist>
					<ctrls>
						<ctrl>
							<message>Please specify whether or not you have a Clann Nexus block in your input file</message>
							<language>perl</language>
							<code>!defined $nexusBlock</code>
						</ctrl>
					</ctrls>
					<comment>
						<value>Clann receives instructions either from commands you specify in the interface below, or from a CLANN block in your input file (Nexus format). Either option is fine, but you must specify which method you are using. If you specified the run paramters in  a Clann Nexus block, you must specify it here, or the run will fail.</value>
					</comment>
				</attributes>
		</parameter>
		
		<parameter issimple="1" type="InFile">
				<name>commandfile_mine</name>
				<attributes>
					<prompt>Provide your own command file</prompt>
					<filenames>commandfile.txt</filenames>
					<precond>
							<language>perl</language>
							<code>$nexusBlock == 2 </code>
						</precond>
					<warns>
						<warn>
							<message>If you reate your own command file, the input tree file read into memory must be named infile.tre</message>
							<language>perl</language>
							<code>defined $commandfile_mine</code>
						</warn>
					</warns>
					<comment>
						<value> You can select your own Clann command file here.</value>
					</comment>
				</attributes>
		</parameter>

 	<!--		<parameter  issimple="1" type="String">
					<name>specify_delimiter</name>
					<attributes>
						<prompt>Specify a delimiter character for your dataset (default = .)</prompt>
						<comment>
							<value>This option allows the user to specify a delimiter character in their dataset.</value>
						</comment>
					</attributes>
			</parameter>-->
					
<!--			<parameter  issimple="1" ishidden="1" type="String">
					<name>specify_end</name>
					<attributes>
						<precond>
							<language>perl</language>
							<code>$nexusBlock == 2 </code>
						</precond>
						<format>
							<language>perl</language>
							<code> ";"</code>
						</format>
						<group>11</group>
					<paramfile>commandfile.txt</paramfile>
					</attributes>
			</parameter>-->
			
<!--  criterion       dfit | sfit | qfit | mrp | avcon        dfit-->		
	<parameter issimple="1" type="Excl">
				<name>specify_criterion</name>
				<attributes>
					<prompt>Specify your criterion  (set -criterion)</prompt>
					<precond>
						<language>perl</language>
						<code>$nexusBlock == 2   &amp;&amp; !defined $commandfile_mine </code>
					</precond>
					<vlist>
						<value>dfit</value>
						<label>Most Similar Supertree (dfit)</label>
						<value>sfit</value>
						<label>Maximum Split (sfit)</label>
						<value>qfit</value>
						<label>Maximum Quartet Fit (qfit)</label>
						<value>mrp</value>
						<label>Matrix Representation using Parsimony (MRP)</label>
						<value>avcon</value>
						<label>Average Consensus (avcon)</label>
					</vlist>
					<ctrls>
						<ctrl>
							<message>Please select a criterion for your analysis</message>
							<language>perl</language>
							<code>!defined $specify_criterion</code>
						</ctrl>
					</ctrls>
				</attributes>
		</parameter> 
		
		
		<parameter issimple="1" type="String">
				<name>specify_outputname</name>
				<attributes>
					<prompt>Specify an output name</prompt>
					<precond>
						<language>perl</language>
						<code>$nexusBlock == 2   &amp;&amp; !defined $commandfile_mine </code>
					</precond>
					<ctrls>
						<ctrl>
							<message>Please enter a name for the output file</message>
							<language>perl</language>
							<code>!defined $specify_outputname</code>
						</ctrl>
					</ctrls>
				</attributes>
		</parameter>		
		
			<parameter issimple="1" type="Integer">
				<name>specify_seed</name>
				<attributes>
					<prompt>Specify a seed  (set -seed)</prompt>
					<precond>
						<language>perl</language>
						<code>$nexusBlock == 2   &amp;&amp; !defined $commandfile_mine </code>
					</precond>
				</attributes>
		</parameter> 	
		
		<!-- hidden param to specify criterion-->		
    		<parameter ishidden="1" type="String">
				<name>specify_criterionhidden</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$specify_analysis == 1</code>
					</precond>
					<group>5</group>
					<format>
						<language>perl</language>
						<code>
						"#instructions to specify the search criterion\\n" .
						"set criterion=$specify_criterion;\\n"  .
						" \\n"</code>
					</format>
					<paramfile>commandfile.txt</paramfile>
				</attributes>
		</parameter>
		
		  <parameter ishidden="1" type="String">
				<name>specify_seedhidden</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>$specify_analysis == 1 &amp;&amp; defined $specify_seed</code>
					</precond>
					<group>5</group>
					<format>
						<language>perl</language>
						<code>
						"#instructions to specify the seed\\n"  .
						"set seed=$specify_seed;\\n"  .
						" \\n"</code>
					</format>
					<paramfile>commandfile.txt</paramfile>
				</attributes>
		</parameter>
		
    	<parameter issimple="1" type="Excl">
				<name>specify_analysis</name>
				<attributes>
					<prompt>What analysis do you wish to run?</prompt>
					<precond>
						<language>perl</language>
						<code>$nexusBlock == 2   &amp;&amp; !defined $commandfile_mine </code>
					</precond>
					<vlist>
						<value>1</value>
						<label>Supertree reconstruction </label>
						<value>2</value>
						<label>Source tree selection and modification</label>
						<value>3</value>
						<label>Miscellaneous calculations</label>
						<value>4</value>
						<label>Experimental Options</label>
					</vlist>
					<ctrls>
						<ctrl>
							<message>Please specify which analysis you wish to run</message>
							<language>perl</language>
							<code>!defined $specify_analysis</code>
						</ctrl>
					</ctrls>
				</attributes>
		</parameter> 
 		
 <!-- a set of analysis options that create commands in an auxiliary command file
 -c <file name> specifies a file with commands to be executed (each seperated by ';') -->

		
<!-- hs		- Carry out a heuristic search for the best supertree usign the criterion selected
bootstrap	- Carry out a bootstrap supertree analysis using the criterion selected
nj		- Construct a neighbour-joining supertree
alltrees	- Exhaustively search all possible supertrees
usertrees	- Assess user-defined supertrees (from seperate file), to find the best scoring
consensus	- Calculate a consensus tree of all trees containing all taxa-->		

 <parameter type="Paragraph">
    <paragraph>
		<name>supertree_recon</name>
		<prompt>Supertree Reconstruction</prompt>
		<parameters>

<!-- a set of hidden parameters will be used to transmit this into acceptable command lines-->
			<parameter ismandatory="1" type="Excl">
				<name>specify_suptreerecon</name>
				<attributes>
					<prompt>What Supertree reconstruction method?</prompt>
					<precond>
						<language>perl</language>
						<code>$specify_analysis == 1</code>
					</precond>
					<vlist>
						<value>hs</value>
						<label>Heuristic search</label>
						<value>bootstrap</value>
						<label>Bootstrap</label>
						<value>yaptp</value>
						<label>Yaptp</label>
						<value>nj</value>
						<label>Neighbor joining</label>
						<value>alltrees</value>
						<label>Alltrees</label>
						<value>usertrees</value>
						<label>Usertrees</label>
						<value>consensus</value>
						<label>Consensus</label>
					</vlist>
					<ctrls>
						<ctrl>
							<message>Please select a method for the supertree reconstruction</message>
							<language>perl</language>
							<code>!defined $specify_suptreerecon</code>
						</ctrl>
						<ctrl>
							<message>You cannot do a usertree search under MRP criterion</message>
							<language>perl</language>
							<code>$specify_suptreerecon eq "usertrees" &amp;&amp; $specify_criterion eq "mrp" </code>
						</ctrl>
						<ctrl>
							<message>You cannot do a usertree search under AVCON criterion</message>
							<language>perl</language>
							<code>$specify_suptreerecon eq "usertrees" &amp;&amp; $specify_criterion eq "avcon" </code>
						</ctrl>
					</ctrls>
					<group>1</group>
					<comment>
						<value> Heuristic search:  Carry out a heuristic search for the best supertree usign the criterion selected; Bootstrap	- Carry out a bootstrap supertree analysis using the criterion selected
NeighborJoining	- Construct a neighbour-joining supertree; Alltrees - Exhaustively search all possible supertrees; Usertrees	- Assess user-defined supertrees (from seperate file), to find the best scoring 
Consensus	- Calculate a consensus tree of all trees containing all taxa</value>
					</comment>
				</attributes>
			</parameter> 
				
<!--  start           nj | random | <filename>        nj -->
 			<parameter ismandatory="1" type="Excl">
				<name>specify_start</name>
				<attributes>
					<prompt>Specify the starting tree method</prompt>
					<precond>
						<language>perl</language>
						<code>($specify_suptreerecon eq "hs" ||  $specify_suptreerecon eq "bootstrap")</code>
					</precond>
					<vlist>
						<value>nj</value>
						<label>Neighbor joining</label>
						<value>random</value>
						<label>Random</label>
						<value>user</value>
						<label>User supplied</label>
					</vlist>
					<vdef>
						<value>nj</value>
					</vdef>
				<ctrls>
						<ctrl>
							<message>Please specify your starting tree method</message>
							<language>perl</language>
							<code>($specify_suptreerecon eq "hs" ||  $specify_suptreerecon eq "bootstrap") &amp;&amp; !defined $specify_start</code>
						</ctrl>
					</ctrls> 
					<comment>
<value>By default, the heuristic search starts with a neighbor-joining tree calculated from average
consensus distances (with missing distances estimated using either ultrametric or 4-point
condition distances). If more than one repetition of the heuristic search is to be carried out, the first
repetition uses the nj tree as a starting point and every subsequent repetition uses the nj tree after a
randomly chosen number of SPR operations having been carried out on it. </value>
<value>If the user decides to use a randomly chsen tree as a starting point for the heuristic search, a certain
number of random trees are evaluated (specified by the option sample) and the top few are retained
(the number of which is specified by the option nreps). These top trees are then used as starting
points for each of the repetitions of the heuristic search.</value>
<value>Finally, it is possible to specify a filename that contains trees which are to be used as starting points
If any other word other than nj or random is placed after the option start, it is assumed that this
is the name of a file containing starting trees. This overrides the options sample and nreps .
i.e. start=random or start=mytrees.txt</value>
					</comment>
				</attributes>
 			</parameter> 			
 				
<parameter type="InFile">
				<name>specify_startfile</name>
				<attributes>
					<prompt>Select your starting tree file</prompt>
					<precond>
						<language>perl</language>
						<code>$specify_start eq "user"</code>
					</precond>
					<filenames>startingtree.tre</filenames>
 					<ctrls>
						<ctrl>
							<message>Please select a starting tree file</message>
							<language>perl</language>
							<code>$specify_start eq "user" &amp;&amp; !defined $specify_start</code>
						</ctrl>
					</ctrls>
				</attributes>
		</parameter> 
		
<!--sample          <integer number>                *10,000-->
    		<parameter  type="Integer">
				<name>specify_sampleno</name>
				<attributes>
					<prompt>Number of  supertrees to be evaluated before search (-sample)</prompt>
					<precond>
						<language>perl</language>
						<code> ($specify_suptreerecon eq "hs" ||  $specify_suptreerecon eq "bootstrap" ||  $specify_suptreerecon eq "yaptp")</code>
					</precond>
					<vdef>
						<value>10000</value>
					</vdef>
 					<ctrls>
						<ctrl>
							<message>Please specify the number of supertrees to be evalauted</message>
							<language>perl</language>
							<code> ($specify_suptreerecon eq "hs" ||  $specify_suptreerecon eq "bootstrap" ||  $specify_suptreerecon eq "yaptp") &amp;&amp; !defined $specify_sampleno</code>
						</ctrl>
					</ctrls>
					<comment>
<value>This option determines the number of randomly chosen supertrees are evaluated before heuristic searches are carried out. The top x number of trees are kept as starting points for each of the x repetitions of the heuristic search. The default value is 10,000.</value>
					</comment>
				</attributes>
		</parameter> 

<!--    nreps           <integer number>                *10    -->
    		<parameter  type="Integer">
				<name>specify_nreps</name>
				<attributes>
					<prompt>Number of reptitions or bootstraps (-nreps)</prompt>
					<precond>
						<language>perl</language>
						<code>($specify_suptreerecon eq "hs" ||  $specify_suptreerecon eq "bootstrap"  ||  $specify_suptreerecon eq "yaptp") </code>
					</precond>
					<vdef>
						<value>10</value>
					</vdef>
					<ctrls>
						<ctrl>
							<message>Please specify the number of repitions or bootstraps</message>
							<language>perl</language>
							<code>($specify_suptreerecon eq "hs" ||  $specify_suptreerecon eq "bootstrap"  ||  $specify_suptreerecon eq "yaptp")  &amp;&amp; !defined $specify_nreps</code>
						</ctrl>
					</ctrls>				
					<comment>
<value>This option specifies the number of repetitions of the heuristic search or the number of bootstrap reps that are to be carried out. The best
tree found is picked from all the repetitions carried out.</value>
					</comment>
				</attributes>
		</parameter> 
  
  <!-- swap            nni | spr | tbr  | all               spr --> 
 			<parameter ismandatory="1" type="Excl">
				<name>specify_swap</name>
				<attributes>
					<prompt>Heuristic search type (-swap or -search)</prompt>
					<precond>
						<language>perl</language>
						<code>($specify_suptreerecon eq "hs" ||  $specify_suptreerecon eq "bootstrap"  ||  $specify_suptreerecon eq "yaptp")</code>
					</precond>
					<vlist>
						<value>nni</value>
						<label>Nearest neighbor (nni)</label>
						<value>spr</value>
						<label>Sub tree pruning (spr)</label>
						<value>tbr</value>
						<label>Tree bisection (tbr; hr only)</label>
						<value>all </value>
						<label>All (not hr)</label>
					</vlist>
					<vdef>
						<value>spr</value>
					</vdef>
					<ctrls>
					<ctrl>
							<message>Please specify the search or swap type</message>
							<language>perl</language>
							<code>($specify_suptreerecon eq "hs" ||  $specify_suptreerecon eq "bootstrap"  ||  $specify_suptreerecon eq "yaptp") &amp;&amp; !defined $specify_swap</code>
						</ctrl> 	
						<ctrl>
							<message>Tbr is not valid for Yaptp Search Option (search=yaptp) </message>
							<language>perl</language>
							<code>$specify_swaps eq "tbr" &amp;&amp; $specify_suptreerecon eq "yaptp"</code>
						</ctrl>
						<ctrl>
							<message>All is not valid only for the Heuristic Search Option (swap=hs) </message>
							<language>perl</language>
							<code>$specify_swaps eq "all" &amp;&amp; $specify_suptreerecon eq "hs"</code>
						</ctrl>
						<ctrl>
							<message>All is not valid only for the MRP criterion (criterion=MRP) </message>
							<language>perl</language>
							<code>$specify_swaps eq "all" &amp;&amp; $specify_criterion eq "mrp"</code>
						</ctrl>
					</ctrls>
					<comment>
<value>This option determines the type of heuristic search that is to be carried out. nni specifies that the nearest neighbor interchange
method is to be used spr specifies that the sub tree pruning and regrafting method is to be used.</value>
					</comment>
				</attributes> 
 			</parameter>
  
 <!--nsteps          <integer number>                3 --> 
    		<parameter  type="Integer">
				<name>specify_nsteps</name>
				<attributes>
				<prompt>Maximum number of steps from original position (-nsteps)</prompt>
					<precond>
						<language>perl</language>
						<code>($specify_suptreerecon eq "hs" ||  $specify_suptreerecon eq "bootstrap" ||  $specify_suptreerecon eq "yaptp" ) </code>
					</precond>
					<vdef>
						<value>3</value>
					</vdef>
 					<ctrls>
						<ctrl>
							<message>Please specify the maximum number of steps allowed</message>
							<language>perl</language>
							<code>($specify_suptreerecon eq "hs" ||  $specify_suptreerecon eq "bootstrap" ||  $specify_suptreerecon eq "yaptp" ) &amp;&amp; !defined $specify_nsteps</code>
						</ctrl>
					</ctrls>					
					<comment>
<value>This option specifies the maximum number of steps away from its original position that any branch may be swapped or regrafted. The default value is 3.</value>
					</comment>		
				</attributes>
		</parameter>  		 		
				
<!--maxswaps        <integer number>                *1,000,000 -->
    		<parameter  type="Integer">
				<name>specify_maxswaps</name>
				<attributes>
					<prompt>Maximum number of swaps/rearrangements (-maxswap)</prompt>
					<precond>
						<language>perl</language>
						<code>($specify_suptreerecon eq "hs" ||  $specify_suptreerecon eq "bootstrap" ||  $specify_suptreerecon eq "yaptp") </code>
					</precond>
					<vdef>
						<value>1000000</value>
					</vdef>
 					<ctrls>
						<ctrl>
							<message>Please specify the maximum number of steps allowed</message>
							<language>perl</language>
							<code>($specify_suptreerecon eq "hs" ||  $specify_suptreerecon eq "bootstrap" ||  $specify_suptreerecon eq "yaptp" ) &amp;&amp; !defined $specify_maxswaps</code>
						</ctrl>
					</ctrls>			 
					<comment>
<value>This option specifies the maximum number of swaps/rearrangements to be tried during the search. This is set to 1,000,000 by default, but some searches may take too long so it may be desirable to set a lower limit. The number of random samples carried out before the heuristic searches are not counted for the maxswaps limitation</value>
					</comment>
				</attributes>
		</parameter>  


<!--hsreps        <integer number>                *10-->
    		<parameter  type="Integer">
				<name>specify_hsreps</name>
				<attributes>
					<prompt>Maximum number of repetitions of the heuristic search (-hsreps)</prompt>
					<precond>
						<language>perl</language>
						<code>($specify_suptreerecon eq "bootstrap" ||  $specify_suptreerecon eq "yaptp")</code>
					</precond>
					<vdef>
						<value>10</value>
					</vdef>
					<ctrls>
						<ctrl>
							<message>Please specify the maximum number of repititions allowed</message>
							<language>perl</language>
							<code>($specify_suptreerecon eq "bootstrap" ||  $specify_suptreerecon eq "yaptp") &amp;&amp; !defined $specify_hsreps</code>
						</ctrl>
						<ctrl>
							<message>The maximum number of supertrees sampled must be greater than the value of hsreps</message>
							<language>perl</language>
							<code>$specify_sampleno &lt; $specify_hsreps</code>
						</ctrl>
					</ctrls>	
					<comment>
<value>This option defines how many repetitions of the heuristic search are to be carried out on each bootstrap or YAPTP replicate.</value>
					</comment>
				</attributes>
		</parameter>  
	
<!--         savetrees       <filename>                      Heuristic_result.txt -->

<!--         weight          equal | comparisons             comparisons -->
 			<parameter ismandatory="1" type="Excl">
				<name>specify_weighttype</name>
				<attributes>
					<prompt>Weight used to normalise the scoring system (-weight)</prompt>
					<precond>
						<language>perl</language>
						<code>($specify_suptreerecon eq "hs" ||  $specify_suptreerecon eq "bootstrap" ||  $specify_suptreerecon eq "usertrees"||  $specify_suptreerecon eq "alltrees" ||  $specify_suptreerecon eq "yaptp") </code>
					</precond>
					<vlist>
						<value>equal</value>
						<label>Equal (all optimality)</label>
						<value>comparisons</value>
						<label>Comparisons (dfit only)</label>
						<value>taxa</value>
						<label>Taxa (qfit only)</label>
						<value>quartets</value>
						<label>Quartets (qfit only)</label>
						<value>splits</value>
						<label>Splits (sfit only)</label>
					</vlist>
					<vdef>
						<value>comparisons</value>
					</vdef>
					<ctrls>
						<ctrl>
							<message>Sorry, the quartets, taxa,  and splits weight option cannot be used with the dfit criterion</message>
							<language>perl</language>
							<code>($specify_weighttype eq "quartets" ||  $specify_weighttype eq "splits"  ||  $specify_weighttype eq "taxa")  &amp;&amp;  $specify_criterion eq "dfit" </code>
						</ctrl>
						<ctrl>
							<message>Sorry, the splits and comparison weight options cannot be used with the qfit criterion</message>
							<language>perl</language>
							<code> ($specify_weighttype eq "splits"  ||  $specify_weighttype eq "comparisons") &amp;&amp; $specify_criterion eq "qfit" </code>
						</ctrl>
						<ctrl>
							<message>Sorry, the comparisons, taxa, and quartets weight options cannot be used with the sfit criterion</message>
							<language>perl</language>
							<code> ($specify_weighttype eq "quartets" ||  $specify_weighttype eq "taxa" ||  $specify_weighttype eq "comparisons")   &amp;&amp;  $specify_criterion eq "sfit" </code>
						</ctrl>
						<ctrl>
							<message>Please specify the weight used to normalise the scoring system</message>
							<language>perl</language>
							<code>$specify_suptreerecon ne  "nj" &amp;&amp;  $specify_suptreerecon ne  "consensus" &amp;&amp; !defined $specify_weighttype</code>
						</ctrl> 
					</ctrls>
					<comment>
<value>This option specifies the weight used to normalise the scoring system for large (or small) tree bias. Depending on the optimality criteria used (see set
command) there are different weighting schemes.</value>
<value>Using the dfit optimality criterion, the options are: equal or comparisons. equal applies no normalisation and comparisons normalises so every tree has the same vote (regardless of tree size).</value>
<value>- Using the qfit optimality criterion, the options are: equal or taxa or quartets. equal applies no normalisation;  taxa applies a normalisation that is calculated as n-3. quartets normalises so every tree has the same vote (regardless of tree size).</value>
<value>Using the sfit optimality criterion, the options are: equal or splits; equal applies no normalisation. splits normalises so every tree has the same vote (regardless of tree size).
</value>
					</comment>
				</attributes> 
 			</parameter>   
 			
  <!-- 'Strict' specifies that the consensus should only include relationships that appear 100% of the time in
the bootstrapped trees.
'majrule'' species that the consensus should only include relationships that appear great than 50% of
the time in the bootstrapped trees.
'minor' specifies that that the consensus should only include relationships that appear great than 50% of
the time in the universally distributed trees, but that the minor components that are compatible with the
majority-rule tree should also be included.
User can specify a proportion (greater than 0.5 and lessthan 1.0) that should be the minimum proportion that any
relationship should appear in the universally-->
 			<parameter ismandatory="1" type="Excl">
				<name>specify_consensus</name>
				<attributes>
					<prompt>Consensus method (Consensus and Bootstrap)</prompt>
					<precond>
						<language>perl</language>
						<code>($specify_suptreerecon eq "consensus" ||  $specify_suptreerecon eq "bootstrap")</code>
					</precond>
					<vlist>
						<value>strict</value>
						<label>Strict</label>
						<value>majrule</value>
						<label>Majority Rule</label>
						<value>minor</value>
						<label>Minor</label>
						<value>user</value>
						<label>User specified</label>
					</vlist>
					<ctrls>
						<ctrl>
							<message>Please specify  a consensus method</message>
							<language>perl</language>
							<code>($specify_suptreerecon eq "consensus" ||  $specify_suptreerecon eq "bootstrap") &amp;&amp; !defined $specify_consensus</code>
						</ctrl>
					</ctrls>
					<comment>
						<value>This specifies the method to use to for consensus trees</value>
						<value>Strict specifies that the consensus should only include relationships that appear 100% of the time in
the bootstrapped trees.</value>
						<value>Majority Rule specifies that the consensus should only include relationships that appear great than 50% of the time in the bootstrapped trees.</value>
						<value>Minor specifies that that the consensus should only include relationships that appear great than 50% of the time in the universally distributed trees, but that the minor components that are compatible with the majority-rule tree should also be included.
</value>
						<value>User can specify a proportion (greater than 0.5 and lessthan 1.0) that should be the minimum proportion that any relationship should appear in the universally</value>
					</comment>
				</attributes> 
 			</parameter> 
 
  <!--        user specified consensus proportion    -->
    		<parameter  type="Float">
				<name>specify_consensusfr</name>
				<attributes>
					<prompt>Consensus fraction</prompt>
					<precond>
						<language>perl</language>
						<code>$specify_consensus eq "user"</code>
					</precond>
					<vdef>
						<value>0.50</value>
					</vdef>
					<ctrls>
						<ctrl>
							<message>The value for the consensus proportion must be between 0.5 and 1</message>
							<language>perl</language>
							<code>($specify_consensusfr &lt; 0.5 ||  $specify_consensusfr &gt; 1) </code>
						</ctrl>
						<ctrl>
							<message>Please enter a value for the consensus proportion between 0.5 and 1</message>
							<language>perl</language>
							<code>!defined $specify_consensusfr &amp;&amp; $specify_consensus eq "user"</code>
						</ctrl>
					</ctrls>
				</attributes>
		</parameter>   

<!-- yaptp-->
 		<parameter ismandatory="1" type="Excl">
				<name>specify_method</name>
				<attributes>
					<prompt>Method to randomize input trees (YAPTP only)</prompt>
					<precond>
						<language>perl</language>
						<code> $specify_suptreerecon eq "yaptp"</code>
					</precond>
					<vlist>
						<value>equiprobable</value>
						<label>Equiprobable</label>
						<value>markovian</value>
						<label>Markovian</label>
					</vlist>
					<vdef>
					<value>equiprobable</value>
					</vdef>
					<ctrls>
						<ctrl>
							<message>Please specify  a randomization method</message>
							<language>perl</language>
							<code>$specify_suptreerecon eq "yaptp" &amp;&amp; !defined $specify_method</code>
						</ctrl>
					</ctrls>
					<comment>
						<value>This option sets the method to be used to construct
the random supertrees. The most desirable method is equiprobable as this gives any tree in supertree space an equal chance of being chosen. This however
is not always possible to use as it requires the knowledge of how many supertrees there are in supertree space. This becomes difficult to calculate when the number of taxa becomes large. By default
the generatetrees command will use the equiprobable method.</value>
					</comment>
				</attributes> 
 			</parameter>
 			
 <!-- Please specify whether or not to print source scores; alltrees only -->
 			<parameter ismandatory="1" type="Excl">
				<name>specify_printscores</name>
				<attributes>
					<prompt>Print source scores (usertrees/avcon only)</prompt>
					<precond>
						<language>perl</language>
						<code> $specify_suptreerecon eq "usertrees" </code>
					</precond>
					<vlist>
						<value>yes</value>
						<label>Yes</label>
						<value>no</value>
						<label>No</label>
					</vlist>
					<vdef>
						<value>no</value>
					</vdef>
					<ctrls>
						<ctrl>
							<message>Please specify whether or not to print source scores</message>
							<language>perl</language>
							<code>$specify_suptreerecon eq "usertrees" &amp;&amp; !defined $specify_printscores</code>
						</ctrl>
					</ctrls>
				</attributes> 
 			</parameter>
 			
  <!-- create option; alltrees only -->
 			<parameter ismandatory="1" type="Excl">
				<name>specify_create</name>
				<attributes>
					<prompt>Create a file containing all trees (alltrees only)</prompt>
					<precond>
						<language>perl</language>
						<code> $specify_suptreerecon eq "alltrees" </code>
					</precond>
					<vlist>
						<value>yes</value>
						<label>Yes</label>
						<value>no</value>
						<label>No</label>
					</vlist>
					<vdef>
						<value>no</value>
					</vdef>
					<ctrls>
						<ctrl>
							<message>Please specify whether to create a file with all trees</message>
							<language>perl</language>
							<code>!defined $specify_create</code>
						</ctrl>
					</ctrls>
					<comment>
						<value>This option will write all the trees in supertree space along with their scores to the file alltrees.txt. This command should be used with caution, as with large numbers of taxa, the resulting file can be very large.</value>
					</comment>
				</attributes> 
 			</parameter>

<!-- all trees only specify the range -->			
 			 <parameter ismandatory="1" type="String">
				<name>specify_range</name>
				<attributes>
					<prompt>Specify a range of trees    number1 - number2  or all (alltrees only)</prompt>
					<precond>
						<language>perl</language>
						<code> $specify_suptreerecon eq "alltrees" </code>
					</precond>
					<comment>
						<value>This command specifies a range of trees for the alltrees method. Search treespace in the area between tree number x and y. For example if there were 10 taxa in the
supertree then supertree space would contain 2,027,025 trees. This could take a prohibitively long time on a single computer, but this option allows the
user to get different computers to search different parts of tree space. i.e. "range 1-1000000"" or "range 1000001-2027025"</value>
					</comment>
				</attributes> 
 			</parameter>

 			 <!-- method for MRP-->
 			<parameter ismandatory="1" type="Excl">
				<name>specify_parsornj</name> 
				<attributes>
					<prompt>Method to use for MRP  (analysis; MRP only)</prompt>
					<precond>
						<language>perl</language>
						<code> $specify_criterion eq "mrp" </code>
					</precond>
					<vlist>
						<value>parsimony</value>
						<label>Parsimony</label>
						<value>nj</value>
						<label>Neighbor Joining</label>
					</vlist>
					<vdef>
						<value>parsimony</value>
					</vdef>
					<ctrls>
						<ctrl>
							<message>Please set the analysis method for MRP to parsimony or neighbor joining </message>
							<language>perl</language>
							<code>!defined $specify_parsornj &amp;&amp;  $specify_criterion eq "mrp" </code>
						</ctrl>
					</ctrls>
					<comment>
						<value>This specifies the method to use to estimate the missing data in the average consensus analysis. By default this is set to 4point which is the 4-point condition estimate</value>
					</comment>
				</attributes> 
 			</parameter> 
 			
<!--$specify_suptreerecon eq "usertrees"  --> 	
 			<parameter ismandatory="1" type="InFile">
				<name>specify_usertrees</name> 
				<attributes>
					<prompt>Select your Usertrees file</prompt>
					<precond>
						<language>perl</language>
						<code> $specify_suptreerecon eq "usertrees" </code>
					</precond>
					<filenames>usertrees.txt</filenames>
					<ctrls>
						<ctrl>
							<message>Please specify a file with your usertrees to evaluate</message>
							<language>perl</language>
							<code>!defined $specify_usertrees &amp;&amp;  $specify_suptreerecon eq "usertrees" </code>
						</ctrl>
					</ctrls>
					<comment>
						<value>Provide the tree files  to analyze in phylip format</value>
					</comment>
				</attributes> 
 			</parameter>		
 			
 			 <!-- Options only available in the average consensus (avcon) Criterion
missing 4point | ultrametric

This specifies the method to use to estimate the missing data in the average consensus analysis. By default this
is set to 4point which is the 4-point condition estimate-->
 			<parameter ismandatory="1" type="Excl">
				<name>specify_missingdata</name>
				<attributes>
					<prompt>Method to handle missing data (missing; nj only)</prompt>
					<precond>
						<language>perl</language>
						<code> $specify_suptreerecon eq "nj" </code>
					</precond>
					<vlist>
						<value>4point</value>
						<label>4 Point</label>
						<value>ultrametric</value>
						<label>Ultrametric</label>
					</vlist>
					<vdef>
						<value>4point</value>
					</vdef>
					<ctrls>
						<ctrl>
							<message>Please enter a method to handle missing data</message>
							<language>perl</language>
							<code>!defined $specify_missingdata &amp;&amp; $specify_suptreerecon eq "nj" </code>
						</ctrl>
					</ctrls>
					<comment>
						<value>This specifies the method to use to estimate the missing data in the average consensus analysis. By default this is set to 4point which is the 4-point condition estimate</value>
					</comment>
				</attributes> 
 			</parameter> 
 			
 			   <parameter  type="InFile">
				<name>consensus_guidetree</name>
				<attributes>
					<prompt>Select a guidetree for Consensus</prompt>
					<precond>
						<language>perl</language>
						<code> $specify_suptreerecon eq "consensus"</code>
					</precond>
					<filenames>guidetree.tre</filenames>
				</attributes>
		</parameter>   
 	
<!-- drawhistogram   yes | no                        *no
 			<parameter ismandatory="1" type="Excl">
				<name>specify_drawhistogram</name>
				<attributes>
					<prompt>Draw a histogram?</prompt>
					<precond>
						<language>perl</language>
						<code>$specify_analysis == 1</code>
					</precond>
					<vlist>
						<value>yes</value>
						<label>Yes</label>
						<value>no</value>
						<label>No</label>
					</vlist>
					<vdef>
						<value>yes</value>
					</vdef>
					<ctrls>
						<ctrl>
							<message></message>
							<language>perl</language>
							<code></code>
						</ctrl>
					</ctrls>
					<comment>
						<value></value>
					</comment>
				</attributes> 
 			</parameter> -->

<!--         nbins           <integer number>                *20
    		<parameter  type="Integer">
				<name>specify_nbins</name>
				<attributes>
					<prompt>Number of bins for the histogram</prompt>
					<precond>
						<language>perl</language>
						<code>$specify_drawhistogram eq "yes"</code>
					</precond>
					<vdef>
						<value>20</value>
					</vdef>
				</attributes>
		</parameter>  -->

<!--      histogramfile   <filename>                      *Heuristic_histogram.txt-->	
		
		</parameters>
      </paragraph>
    </parameter>
 
    <parameter type="Results">
    	<name>all-outfiles</name>
   		<attributes>
			<filenames>*</filenames>
      	</attributes>
    </parameter>

  </parameters>

</pise>
