RAxML 8 (DNA)

DESCRIPTION

        RAxML (Randomized Axelerated Maximum Likelihood) is a program for sequential and parallel Maximum
        Likelihood-based inference of large phylogenetic trees.

        It has originally been derived from fastDNAml which
        in turn was derived from Joe Felsenteins dnaml which is part of the PHYLIP package.

        Author: Alexandros Stamatakis

        LINK{http://sco.h-its.org/exelixis/web/software/raxml/index.html}

        Original RAxML documentation can be found at
        LINK{http://sco.h-its.org/exelixis/php/countManualNew.php}

        Several parts of this documentation have been used here.

        Version distributed with ARB and used by this window: RAxML 8.2.8

PARAMETERS

        Only the parameters adjustable via the ARB interface are described below.
        For in-depth documentation please refer to original documentation
        (the main used raxml options are specified for each protocol).


          Input tree

            Not required/used for tree reconstruction protocols 'Thorough' and 'Quick'.

          Protocol

            The following protocols are defined in ARB RAxML8 interface:

              Thorough tree search ("-f d")

                1. perform multiple searches for the best ML tree (uses "new rapid hill-climbing")
                2. (optionally) perform multiple bootstrap searches (executed parallel to 1. if enough CPU cores available)
                3. draw bipartition information (from 2.) on best tree found in 1.

              Quick tree search ("-f a")

                Rapid bootstrap analysis and search for best-scoring ML tree in one raxml run.

              Add to tree ("-g")

                Add species to specified input tree w/o modifying the trees topology.
                You need to mark all species which are member of the input tree,
                plus the species you like to add to that tree.
                The resulting tree will be imported into a new tree.

                If bootstrapping is selected, steps 2. and 3. from Thorough-protocol are executed.

              Optimize tree ("-f t")

                Perform randomized tree searches on one fixed starting tree.
                Imports the best resulting tree into ARB.

                If bootstrapping is selected, steps 2. and 3. from Thorough-protocol are executed.

              Calculate branchlengths ("-f e")

                Similar to 'Score tree', but also calculates new branchlengths
                and reimports the tree (as new tree).

                If bootstrapping is selected, steps 2. and 3. from Thorough-protocol are executed.

              Calculate bootstraps ("-b")

                Perform multiple bootstrap searches on marked species.
                Draw bipartition information on input tree and import as
                new tree.

              Score tree ("-f n")

                Calculates the likelihood for the specified input tree and
                appends the result to the comment of the existing tree.

                If you like to compare the likelihoods of different trees,
                please note that these depend (at least) on the
                following conditions:
                  * set of sequences (=which species are members of the trees)
                  * used Model
                  * used Filter

          Model

            The following substitution models are provided in ARB RAxML8 interface:

                GTRCAT

                  GTR + Optimization of substitution rates + Optimization of
                  site-specific evolutionary rates which are categorized into
                  numberOfCategories distinct rate categories for greater
                  computational efficiency.

                GTRGAMMA

                  GTR + Optimization of substitution rates + GAMMA model of
                  rate heterogeneity (alpha parameter will be estimated). 

          Searches

            Specifies the number of searches for best ML tree that will
            be performed in step 1. of 'Thorough' protocol and
            the number of randomized searches performed
            in 'Optimize tree' protocol.

          Bootstraps

            Specifies the number of bootstrap runs to perform.

             * 'No' disables bootstrapping (not possible for 'Quick' protocol).
             * 'Auto' uses RAxML8 option '-N autoMRE_IGN'
             * or explicitely select number of runs to perform.

          Compute MRE consensus tree

            Compute extended majority rule consensus tree from bootstrapped trees.

          Tree name

            Suffix for result tree(s) loaded into ARB, e.g.:

                'raxml' => 'tree_raxml' (and optionally 'tree_raxml_mre' if MRE tree requested)

          Random seed

                Specifies a fixed random seed (used for parsimony inferences AND rapid bootstrapping).
                This only makes sense if you like to reproduce results (which isn't possible for all cases).

                Recommended default setting is (empty). The number of seconds
                since 'epoch' will be used in that case.

          CPU thread override

                Specify number of threads to use (for bootstrapping and ML search).

                The script tries to detect the number of CPU cores available.
                If it fails to detect the (correct) number of cores on your machine, you
                can set the environment variable PBS_NP to the number of cores available.

                If the number of threads is not specified (=empty, which is recommended),
                the script will check the input alignment and automatically select the
                number of threads to use.

                If there are at least twice as many cores as threads wanted (approx.),
                bootstrapping and ML search will run asynchronously.
                Otherwise they run one after the other.

                When specifying the number of threads manually, make sure you do not specify
                more threads than cores available on your hardware, otherwise you'll encounter
                a massive performance penalty!

                If you like to force asynchronous execution of bootstrapping and ML search,
                set thread override to CORES/2 (e.g. if you have 8 cores select 4 threads).

                If you like to force sequential execution of bootstrapping and ML search, set
                the number of cores to a higher value. Please note that selecting too many threads
                may also result in degraded performance.