/var/lib/mobyle/programs/clustalO-multialign.xml

<?xml version='1.0' encoding='UTF-8'?>
<!-- XML Authors: Corinne Maufrais, Nicolas Joly and Bertrand Neron, -->
<!-- 'Biological Software and Databases' Group, Institut Pasteur, Paris. -->
<!-- Distributed under LGPLv2 License. Please refer to the COPYING.LIB document. -->
<program>
  <head>
    <name>clustalO-multialign</name>
    <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" href="Entities/ClustalO_package.xml" />
    <doc>
      <title>Clustal-Omega: Multiple alignment</title>
      <description>
          <text lang="en">Align a set of protein sequences</text>
      </description>
    </doc>
    <category>alignment:multiple</category>
    <command>clustalo</command>
  </head>
  <parameters>

    <paragraph>
      <name>input</name>
      <prompt lang="en">Data Input</prompt>
      <parameters>

        <parameter ismandatory="1" issimple="1" ismaininput="1">
          <name>sequences_input</name>
          <prompt lang="en">Unaligned set of sequences</prompt>
          <precond>
              <code proglang="perl">not $alignment_input or ($sequences_input and $alignment_input)</code>
             <code proglang="python">not alignment_input or (sequences_input and alignment_input)</code>
          </precond>
          <type>
            <biotype>Protein</biotype>
            <datatype>
              <class>Sequence</class>
            </datatype>
            <dataFormat>FASTA</dataFormat>
            <dataFormat>SWISSPROT</dataFormat>
            <dataFormat>CODATA</dataFormat>
            <dataFormat>NBRF</dataFormat>
            <card>2,n</card>
          </type>
          <format>
            <code proglang="perl">" --infile=$value"</code>
            <code proglang="python">" --infile=" + str( value )</code>
          </format>
          <ctrl>
            <message>
              <text lang="en">Can not handle both Sequence and Alignment at the same time</text>
            </message>
            <code proglang="perl">not $alignment_input</code>
            <code proglang="python">not alignment_input</code>
          </ctrl>
          <comment>
            <text lang="en">Use this option to make a multiple alignment from a set of
            sequences. A sequence file must contain more than one sequence (at
            least two sequences)</text>
          </comment>
        </parameter>

        <parameter ismandatory="1" issimple="1" ismaininput="1">
          <name>alignment_input</name>
          <prompt lang="en">Aligned sequences</prompt>
          <precond>
        <code proglang="perl">not $sequences_input or ($sequences_input and $alignment_input)</code>
        <code proglang="python">not sequences_input or (sequences_input and alignment_input)</code>
      </precond>
          <type>
          <biotype>Protein</biotype>
            <datatype>
              <class>Alignment</class>
            </datatype>
            <dataFormat>FASTA</dataFormat>
            <dataFormat>CLUSTAL</dataFormat>
            <dataFormat>STOCKHOLM</dataFormat>
            <dataFormat>MSF</dataFormat>
            <dataFormat>PHYLPI</dataFormat>
            <!-- to add when squizz will handle this formats 
            <dataFormat>SELEX</dataFormat>
            <dataFormat>PO</dataFormat>
             -->
            <card>1</card>
          </type>
          <format>
            <code proglang="perl">" --infile=$value"</code>
            <code proglang="python">" --infile=" + str( value )</code>
          </format>
          <ctrl>
            <message>
              <text lang="en">Can not handle both Sequence and Alignment at the same time</text>
            </message>
            <code proglang="perl">not $sequences_input</code>
            <code proglang="python">not sequences_input</code>
          </ctrl>
          <comment>
          <text lang="en"> When the sequences are aligned (all sequences
              have the same length and at least one sequence has at least one
              gap), then the alignment is turned into a HMM, the sequences are
              de-aligned and the now un-aligned sequences are aligned using the
              HMM as an External Profile for External Profile Alignment (EPA).
              If no EPA is desired use the dealign Option.</text>
              
              <text lang="en">Clustal-Omega reads the file of aligned sequences. 
              It converts the alignment into a HMM, de-aligns the sequences and 
              re-aligns them, transferring pseudo-count information to
              the sequences/profiles during the MSA. The guide tree is constructed
              using a full distance matrix of Kimura distances.</text>
          </comment>
        </parameter>
        <parameter issimple="1">
            <name>seqtype</name>
            <prompt lang="en">type of sequences</prompt>
            <type>
                <datatype>
                  <class>Choice</class>
                </datatype>
            </type>
            <vdef>
              <value>auto</value>
            </vdef>
            <vlist>
                <velem>
                    <label>Automatic</label>
                    <value>auto</value>
                </velem>
                <velem>
                    <label>Protein</label>
                    <value>Protein</value>
                </velem>
                <velem>
                    <label>RNA</label>
                    <value>RNA</value>
                </velem>
                <velem>
                    <label>DNA</label>
                    <value>DNA</value>
                </velem>
            </vlist>
            <format>
                <code proglang="perl">(defined $value and $value neq $vdef)? " --seqtype=$value" : ""</code>
                <code proglang="python">("", " --seqtype="+str(value))[value is not None and value != vdef]</code>
            </format>
            <comment>
                <text lang="en">Since version 1.1.0 the Clustal-Omega alignment engine can process
DNA/RNA. Clustal-Omega tries to guess the sequence type (protein,
DNA/RNA), but this can be over-ruled with this flag.
                </text>
            </comment>
        </parameter>
        <parameter>
          <name>dealign</name>
          <prompt lang="en">Dealign input sequences</prompt>
          <precond>
            <code proglang="perl">$alignment_input</code>
            <code proglang="python">bool( alignment_input )</code>
          </precond>
          <type>
            <datatype>
              <class>Boolean</class>
            </datatype>
          </type>
          <vdef>
           <value>0</value>
          </vdef>
          <format>
            <code proglang="perl">(defined $value and $value) " --dealign " : ""</code>
            <code proglang="python">( "" , " --dealign ")[ value is not None and value !=vdef ]</code>
          </format>
          <comment>
          <text lang="en"> When the sequences are aligned (all sequences
            have the same length and at least one sequence has at least one
            gap), then the alignment is turned into a HMM, the sequences are
            de-aligned and the now un-aligned sequences are aligned using the
            HMM as an External Profile for External Profile Alignment (EPA).
            If no EPA is desired use turn on this option.</text>
        
            <text lang="en"> Clustal-Omega reads the file of aligned sequences. 
            It de-aligns the sequences and then re-aligns them. 
            No HMM is produced in the process, no pseudo-count information is transferred. 
            Consequently, the output must be the same as for unaligned output.</text>
         </comment>
        </parameter>

        <parameter>
          <name>hmm-in</name>
          <prompt lang="en">HMM input files</prompt>
          <type>
          <biotype>Protein</biotype>
            <datatype>
              <class>HmmProfile</class>
              <superclass>AbstractText</superclass>
            </datatype>
            <dataFormat>HMMER2</dataFormat>
            <dataFormat>HMMER3</dataFormat>
            <card>1</card>
          </type>
          <format>
            <code proglang="perl">(defined $value)?" --hmm-in=$value" : ""</code>
            <code proglang="python">( "" , " --hmm-in=" + str( value ))[value is not None ]</code>
          </format>
          <comment>
          <text lang="en"> the
    un-aligned sequences will be aligned to form a profile, using the
    HMM as an External Profile. So far only one HMM can be input and
    only HMMer2 and HMMer3 formats are allowed. The alignment will be
    written out; the HMM information is discarded. As, at the moment,
    only one HMM can be used, no HMM is produced if the sequences are
    already aligned. Use the -i flag in conjunction with the --hmm-in
    flag for this mode. Multiple HMMs can be inputted, however, in the
    current version all but the first HMM will be ignored.</text>
       <text lang="en">Use this option to make a new multiple alignment of sequences from
    the input file and use the HMM as a guide (EPA).</text>
    
    <text lang="en"> Clustal-Omega reads the sequences file and the HMM file 
    (in HMMer2 or HMMer3 format).  It then performs the alignment, 
    transferring pseudo-count information contained in
    hmm to the sequences/profiles during the MSA.</text>
          </comment>
        </parameter>

      </parameters>
    </paragraph>

    <paragraph>
      <name>clustering</name>
      <prompt lang="en">Clustering</prompt>
      <comment>
        <text lang="en">
          In order to produce a multiple alignment Clustal-Omega requires a
          guide tree which defines the order in which sequences/profiles are
          aligned. A guide tree in turn is constructed, based on a distance
          matrix. Conventionally, this distance matrix is comprised of all the
          pair-wise distances of the sequences. The distance measure
          Clustal-Omega uses for pair-wise distances of un-aligned sequences is
          the k-tuple measure [4], which was also implemented in Clustal 1.83
          and ClustalW2
          [5,6]. If the sequences inputted via -i are aligned
          Clustal-Omega uses the Kimura-corrected pairwise aligned identities
          [7]. The computational effort (time/memory) to calculate and store a
          full distance matrix grows quadratically with the number of sequences.
          Clustal-Omega can improve this scalability to N*log(N) by employing a
          fast clustering algorithm called mBed [2]; this option is
          automatically invoked (default). If a full distance matrix evaluation
          is desired, then the --full flag has to
          be set. The mBed mode
          calculates a reduced set of pair-wise distances. These distances are
          used in a k-means algorithm, that clusters at most 100 sequences. For
          each cluster a full distance matrix is calculated. No full distance
          matrix (of all input sequences) is calculated in mBed mode. If there
          are less than 100 sequences in the input, then in effect a full
          distance matrix is calculated in mBed mode, however, no distance
          matrix can be outputted (see below).
          </text>
        <text lang="en">Clustal-Omega uses Muscle's [8] fast UPGMA implementation to construct
          its guide trees from the distance matrix. By default, the distance
          matrix is used internally to construct the guide tree and is then
          discarded. By specifying --distmat-out the internal distance matrix
          can be written to file. This is only possible in --full mode. The
          guide trees by default are used internally to guide the multiple
          alignment and are then discarded. By specifying the --guidetree-out
          option these
          internal guide trees can be written out to
          file. Conversely, the distance calculation and/or guide tree building
          stage can be skipped, by reading in a pre-calculated distance matrix
          and/or pre-calculated guide tree. These options are invoked by
          specifying the --distmat-in and/or --guidetree-in flags,
          respectively. However, distance matrix reading is disabled in the
          current version. By default, distance matrix and guide tree files are
          not over-written, if a file with the specified name already
          exists. In
          this case Clustal-Omega aborts during the command-line processing
          stage. In mBed mode a full distance matrix cannot
          be outputted, distance matrix output is only possible in --full mode.
          mBed or --full distance mode do not affect the ability to write out
          guide-trees.
          </text>
        <text lang="en">
          Guide trees can be iterated to refine the alignment (see section
          ITERATION). Clustal-Omega takes the alignment, that was produced
          initially and constructs a new distance matrix from this alignment.
          The distance measure used at this stage is the Kimura distance [7]. By
          default, Clustal-Omega constructs a reduced distance matrix at this
          stage using the mBed algorithm, which will then be used to create an
          improved (iterated) new guide tree. To turn off mBed-like clustering
          at this
          stage the --full-iter flag has to be set. While Kimura
          distances in general are much faster to calculate than k-tuple
          distances, time and memory requirements still scale quadratically with
          the number of sequences and --full-iter clustering should only be
          considered for smaller cases ( &lt;&lt; 10,000 sequences).
          </text>
        <text lang="en">[2] Blackshields G, Sievers F, Shi W, Wilm A, Higgins DG. Sequence
          embedding for fast construction of guide trees for multiple
          sequence alignment. Algorithms Mol Biol. 2010 May 14;5:21.
          </text>
        <text lang="en">[4] Wilbur and Lipman, 1983; PMID 6572363</text>
        <text lang="en">[5] Thompson JD, Higgins DG, Gibson TJ. (1994). CLUSTAL W: improving
          the sensitivity of progressive multiple sequence alignment through
          sequence weighting, position-specific gap penalties and weight
          matrix choice. Nucleic Acids Res., 22, 4673-4680.
          </text>
        <text lang="en">[6] Larkin MA, Blackshields G, Brown NP, Chenna R, McGettigan PA,
          McWilliam H, Valentin F, Wallace IM, Wilm A, Lopez R, Thompson JD,
          Gibson TJ, Higgins DG. (2007). Clustal W and Clustal X version
          2.0. Bioinformatics, 23, 2947-2948.
          </text>
        <text lang="en">[7] Kimura M (1980). "A simple method for estimating evolutionary
          rates of base substitutions through comparative studies of
          nucleotide sequences". Journal of Molecular Evolution 16: 111–120.
          </text>
      </comment>

      <parameters>

        <parameter>
          <name>distmat_out</name>
          <prompt lang="en">Pairwise distance matrix output file</prompt>
          <type>
            <datatype>
              <class>Filename</class>
            </datatype>
          </type>
          <format>
            <code proglang="perl">(defined $value and $value)? " --distmat-out=$value ":""</code>
            <code proglang="python">( "" , " --distmat-out="+str(value))[ value is not None ]</code>
          </format>
          <ctrl>
            <message>
              <text lang="en">the full option must be set</text>
            </message>
            <code proglang="perl">$full</code>
            <code proglang="python">full</code>
          </ctrl>
        </parameter>

        <parameter>
          <name>guidetree_in</name>
          <prompt lang="en">Guide tree input file (--guidetree-in)</prompt>
          <type>
            <datatype>
              <class>Tree</class>
            </datatype>
            <dataFormat>NEWICK</dataFormat>
          </type>
          <format>
            <code proglang="perl">(defined $value )? " --guidetree-in= $value" : ""</code>
            <code proglang="python">( "" , " --guidetree-in="+str(value))[ value is not None ]</code>
          </format>
        </parameter>

        <parameter>
          <name>guidetree_out</name>
          <prompt lang="en">Guide tree output file (--guidetree-out)</prompt>
          <type>
            <datatype>
              <class>Filename</class>
            </datatype>
          </type>
          <format>
            <code proglang="perl">(defined $value and $value)? " --guidetree-out=$value ":""</code>
            <code proglang="python">( "" , " --guidetree-out="+str(value))[ value is not None ]</code>
          </format>
        </parameter>

        <parameter>
          <name>full</name>
          <prompt lang="en">Use full distance matrix for guide-tree calculation (slow; mBed is default) (--full)</prompt>
          <type>
            <datatype>
              <class>Boolean</class>
            </datatype>
          </type>
          <vdef>
          <value>0</value>
          </vdef>
          <format>
            <code proglang="perl">(defined $full and $ full)? " --full ": ""</code>
            <code proglang="python">( "" , " --full ")[ value is not None and value ]</code>
          </format>
        </parameter>

        <parameter>
          <name>full_iter</name>
          <prompt lang="en">Use full distance matrix for guide-tree calculation during iteration (mBed is default) (--full-iter)</prompt>
          <type>
            <datatype>
              <class>Boolean</class>
            </datatype>
          </type>
          <vdef>
            <value>0</value>
          </vdef>
          <format>
            <code proglang="perl">(defined $full and $ full)? " --full-iter ": ""</code>
            <code proglang="python">( "" , " --full-iter ")[ value is not None and value ]</code>
          </format>
        </parameter>

      </parameters>
    </paragraph>

    <paragraph>
      <name>output_format</name>
      <prompt lang="en">Alignment Output</prompt>
      <parameters>
        <parameter>
          <name>output_format</name>
          <prompt lang="en">alignment output format</prompt>
          <type>
            <datatype>
              <class>Choice</class>
            </datatype>
          </type>
          <vdef>
          <value>fa</value>
          </vdef>
          <vlist>
            <velem>
              <label>fasta</label>
              <value>fa</value>
            </velem>
            <velem>
              <label>clustal</label>
              <value>clustal</value>
            </velem>
            <velem>
              <label>msf</label>
              <value>msf</value>
            </velem>
            <velem>
              <label>phylip</label>
              <value>phylip</value>
            </velem>
            <velem>
              <label>stockholm</label>
              <value>stockholm</value>
            </velem>
            <velem>
              <label>vienna</label>
              <value>vienna</value>
            </velem>
            <!-- to add when squizz will handle this formats
             <velem>
              <label>selex</label>
              <value>selex</value>
            </velem>
             -->
          </vlist>
          <format>
            <code proglang="perl">(defined $value and $value ne $vdef)? " --outfmt=$value" : ""</code>
            <code proglang="python">( "" , " --outfmt=" + value )[ value is not None and value != vdef ]</code>
          </format>
        </parameter>

      </parameters>
    </paragraph>

    <paragraph>
      <name>iteration</name>
      <prompt lang="en">Iteration</prompt>
      <comment>
        <text lang="en">By default, Clustal-Omega calculates (or reads in) a guide tree and
          performs a multiple alignment in the order specified by this guide
          tree. This alignment is then outputted. Clustal-Omega can 'iterate'
          its guide tree. The hope is that the (Kimura) distances, that can be
          derived from the initial alignment, will give rise to a better guide
          tree, and by extension, to a better alignment.</text>
        <text lang="en">A similar rationale applies to HMM-iteration. MSAs in general are very
          'vulnerable' at their early stages. Sequences that are aligned at an
          early stage remain fixed for the rest of the MSA. Another way of
          putting this is: 'once a gap, always a gap'. This behaviour can be
          mitigated by HMM iteration. An initial alignment is created and turned
          into a HMM. This HMM can help in a new round of MSA to 'anticipate'
          where residues should align. This is using the HMM as an External
          Profile and carrying out iterative EPA. In practice, individual
          sequences and profiles are aligned to the External HMM, derived after
          the initial alignment. Pseudo-count information is then transferred to
          the (internal) HMM, corresponding to the individual
          sequence/profile. The now somewhat 'softened' sequences/profiles are
          then in turn aligned in the order specified by the guide
          tree. Pseudo-count transfer is reduced with the size of the
          profile. Individual sequences attain the greatest
          pseudo-count
          transfer, larger profiles less so. Pseudo-count transfer to profiles
          larger than, say, 10 is negligible. The effect of HMM iteration is
          more pronounced in larger test sets (that is, with more sequences).</text>
        <text lang="en">Both, HMM- and guide tree-iteration come at a cost of increasing the
          run-time. One round of guide tree iteration adds on (roughly) the time
          it took to construct the initial alignment. If, for example, the
          initial alignment took 1min, then it will take (roughly) 2min to
          iterate the guide tree once, 3min to iterate the guide tree twice, and
          so on. HMM-iteration is more costly, as each round of iteration adds
          three times the time required for the alignment stage. For example, if
          the initial alignment took 1min, then each additional round of HMM
          iteration will add on 3min; so 4 iterations will take 13min
          (=1min+4*3min). The factor of 3 stems from the fact that at every
          stage both intermediate profiles have to be aligned with the
          background HMM, and finally the (softened) HMMs have to be aligned as
          well. All times are quoted for single processors.</text>
        <text lang="en">By default, guide tree iteration and HMM-iteration are coupled. This
          means, at each iteration step both, guide tree and HMM, are
          re-calculated. This is invoked by setting the --iter flag. For
          example, if --iter=1, then first an initial alignment is produced
          (without external HMM background information and using k-tuple
          distances to calculate the guide tree). This initial alignment is then
          used to re-calculate a new guide tree (using Kimura distances) and to
          create a HMM. The new
          guide tree and the HMM are then used to produce
          a new MSA.</text>
        <text lang="en">Iteration of guide tree and HMM can be de-coupled. This means that the
          number of guide tree iterations and HMM iterations can be
          different. This can be done by combining the --iter flag with the
          --max-guidetree-iterations and/or the --max-hmm-iterations flag. The
          number of guide tree iterations is the minimum of --iter and
          --max-guidetree-iterations, while the number of HMM iterations is the
          minimum of --iter and --max-hmm-iterations. If, for example, HMM
          iteration should be
          performed 5 times but guide tree iteration should
          be performed only 3 times, then one should set --iter=5 and
          --max-guidetree-iterations=3. All three flags can be specified at the
          same time (however, this makes no sense). It is not sufficient just to
          specify --max-guidetree-iterations and --max-hmm-iterations but not
          --iter. If any iteration is desired --iter has to be set.</text>
      </comment>
      <parameters>

        <parameter>
          <name>iterations</name>
          <prompt lang="en">Number of (combined guide-tree/HMM) iterations (--iter)</prompt>
          <type>
            <datatype>
              <class>Integer</class>
            </datatype>
          </type>
          <format>
            <code proglang="perl">(defined $value)? " --iter=$value ": ""</code>
            <code proglang="python">( "" , " --iter="+str(value) )[ value is not None ]</code>
          </format>
          <comment>
            <text lang="en">if iterations= 2. Clustal-Omega reads the input file, creates a UPGMA guide tree
built from k-tuple distances, and performs an initial alignment. This
initial alignment is converted into a HMM and a new guide tree is
built from the Kimura distances of the initial alignment. The
un-aligned sequences are then aligned (for the second time but this
time) using pseudo-count information from the HMM created after the
initial alignment (and using the new guide tree). This second
alignment is then again converted into a HMM and a new guide tree is
constructed. The un-aligned sequences are then aligned (for a third
time), again using pseudo-count information of the HMM from the
previous step and the most recent guide tree. The final alignment is
written to screen.</text>
          </comment>
        </parameter>

        <parameter>
          <name>max_guidetree_iterations</name>
          <prompt lang="en">Maximum number guidetree iterations (--max-guidetree-iterations)</prompt>
          <type>
            <datatype>
              <class>Integer</class>
            </datatype>
          </type>
          <format>
            <code proglang="perl">(defined $value)? " --max-guidetree-iterations=$value ": ""</code>
            <code proglang="python">( "" , " --max-guidetree-iterations="+str(value) )[ value is not None ]</code>
          </format>
          <comment>
            <text lang="en">If iterations= 5 and the "Maximum number guidetree iterations" is set to 1. 
            Clustal-Omega reads the input file, creates a UPGMA guide tree
built from k-tuple distances, and performs an initial alignment. This
initial alignment is converted into a HMM and a new guide tree is
built from the Kimura distances of the initial alignment. The
un-aligned sequences are then aligned (for the second time but this
time) using pseudo-count information from the HMM created after the
initial alignment (and using the new guide tree). For the last 4
iterations the guide tree is left unchanged and only HMM iteration is
performed. This means that intermediate alignments are converted to
HMMs, and these intermediate HMMs are used to guide the MSA during
subsequent iteration stages.</text>
          </comment>
        </parameter>

        <parameter>
          <name>max_hmm_iterations</name>
          <prompt lang="en">Maximum number of HMM iterations (--max-hmm-iterations)</prompt>
          <type>
            <datatype>
              <class>Integer</class>
            </datatype>
          </type>
          <format>
            <code proglang="perl">(defined $value)? " --max-hmm-iterations=$value ": ""</code>
            <code proglang="python">( "" , " --max-hmm-iterations="+str(value) )[ value is not None ]</code>
          </format>
        </parameter>

      </parameters>
    </paragraph>

    <paragraph>
      <name>miscellaneous</name>
      <prompt lang="en">Miscellaneous</prompt>
      <parameters>
        <parameter>
          <name>auto</name>
          <prompt lang="en">Set options automatically (might overwrite some of your options) (--auto)</prompt>
          <type>
            <datatype>
              <class>Boolean</class>
            </datatype>
          </type>
          <vdef>
           <value>0</value>
           </vdef>
          <format>
            <code proglang="perl">(defined $value and $value)? " --auto ": ""</code>
            <code proglang="python">( "" , " --auto ")[value is not None and value]</code>
          </format>
          <comment>
            <text lang="en">Users may feel unsure which options are appropriate in certain
              situations even though using ClustalO without any special options
              should give you the desired results. The --auto flag tries to
              alleviate this problem and selects accuracy/speed flags according to
              the number of sequences. For all cases will use mBed and thereby
              possibly overwrite the --full option. For more than 1,000 sequences
              the iteration is turned off as the effect of iteration is more
              noticeable for 'larger'
              problems. Otherwise iterations are set to 1 if
              not already set to a higher value by the user. Expert users may want
              to avoid this flag and exercise more fine tuned control by selecting
              the appropriate options manually.</text>
          </comment>
        </parameter>
        
        <parameter ishidden="1">
          <name>verbosity</name>
          <argpos>100</argpos>
          <type>
            <datatype>
              <class>String</class>
            </datatype>
          </type>
          <format>
            <code proglang="perl">" -v --force --log=clustalO_log"</code>
            <code proglang="python">" -v --force --log=clustalO_log"</code>
          </format>
        </parameter>
        
      </parameters>
    </paragraph>

    <parameter isstdout="1">
      <name>alignment_output</name>
      <prompt lang="en">Multiple Sequence Alignment</prompt>
      <type>
      <biotype>Protein</biotype>
        <datatype>
          <class>Alignment</class>
        </datatype>
        <dataFormat>
          <test param="output_format" eq="fa">FASTA</test>
          <test param="output_format" eq="clustal">CLUSTAL</test>
          <test param="output_format" eq="msf">MSF</test>
          <test param="output_format" eq="phylip">PHILIPI</test>
          <test param="output_format" eq="stockholm">STOCKHOLM</test>
          <test param="output_format" eq="vienna">FASTA</test>
          <!-- to add when squizz will handle this formats 
          <test param="output_format" eq="selex">SELEX</test>
          -->
        </dataFormat>
      </type>
      <filenames>
        <code proglang="perl">"clustalO-multialign.out"</code>
        <code proglang="python">"clustalO-multialign.out"</code>
      </filenames>
    </parameter>

    <parameter isout="1">
      <name>guidetree_outfile</name>
      <prompt lang="en">Guide tree output file</prompt>
      <precond>
        <code proglang="perl">defined $guidetree_out</code>
        <code proglang="python">guidetree_out is not None</code>
      </precond>
      <type>
        <datatype>
          <class>Tree</class>
        </datatype>
        <dataFormat>NEWICK</dataFormat>
      </type>
      <filenames>
        <code proglang="perl">$guidetree_out</code>
        <code proglang="python">guidetree_out</code>
      </filenames>
    </parameter>

    <parameter isout="1">
      <name>distmat_outfile</name>
      <prompt lang="en">Pairwise distance matrix output file</prompt>
      <precond>
        <code proglang="perl">defined $distmat_out</code>
        <code proglang="python">distmat_out is not None</code>
      </precond>
      <type>
        <datatype>
          <class>DistanceMatrix</class>
          <superclass>AbstractText</superclass>
        </datatype>
      </type>
      <filenames>
        <code proglang="perl">$distmat_out</code>
        <code proglang="python">distmat_out</code>
      </filenames>
    </parameter>
    
    <parameter isout="1">
      <name>logfile</name>
      <prompt lang="en">Clustal omega log file</prompt>
      <type>
        <datatype>
          <class>ClustalOReport</class>
          <superclass>Report</superclass>
        </datatype>
      </type>
      <filenames>
        <code proglang="perl">"clustalO_log"</code>
        <code proglang="python">"clustalO_log"</code>
      </filenames>
    </parameter>

  </parameters>
</program>
mobyle-programs 5.1.1-1 / var / lib / mobyle / programs / clustalO-multialign.xml
