adding clustalO documentation

[jabaws.git] / website / prog_docs / clustalo.txt

\r
\r
CLUSTAL-OMEGA is a general purpose multiple sequence alignment program\r
for proteins.\r
\r
\r
\r
INTRODUCTION\r
\r
Clustal-Omega is a general purpose multiple sequence alignment (MSA)\r
program for proteins. It produces high quality MSAs and is capable of\r
handling data-sets of hundreds of thousands of sequences in reasonable\r
time.\r
\r
In default mode, users give a file of sequences to be aligned and\r
these are clustered to produce a guide tree and this is used to guide\r
a "progressive alignment" of the sequences.  There are also facilities\r
for aligning existing alignments to each other, aligning a sequence to\r
an alignment and for using a hidden Markov model (HMM) to help guide\r
an alignment of new sequences that are homologous to the sequences\r
used to make the HMM.  This latter procedure is referred to as\r
"external profile alignment" or EPA.\r
\r
Clustal-Omega uses HMMs for the alignment engine, based on the HHalign\r
package from Johannes Soeding [1]. Guide trees are made using an\r
enhanced version of mBed [2] which can cluster very large numbers of\r
sequences in O(N*log(N)) time. Multiple alignment then proceeds by\r
aligning larger and larger alignments using HHalign, following the\r
clustering given by the guide tree.\r
\r
In its current form Clustal-Omega can only align protein sequences but\r
not DNA/RNA sequences. It is envisioned that DNA/RNA will become\r
available in a future version.\r
\r
\r
\r
SEQUENCE INPUT:\r
\r
-i, --in, --infile={<file>,-}\r
        Multiple sequence input file (- for stdin)\r
\r
--hmm-in=<file>\r
        HMM input files\r
\r
--dealign\r
        Dealign input sequences\r
\r
--profile1, --p1=<file>\r
        Pre-aligned multiple sequence file (aligned columns will be kept fixed)\r
\r
--profile2, --p2=<file>\r
        Pre-aligned multiple sequence file (aligned columns will be kept fixed)\r
\r
\r
For sequence and profile input Clustal-Omega uses the Squid library\r
from Sean Eddy [3].\r
\r
\r
Clustal-Omega accepts 3 types of sequence input: (i) a sequence file\r
with un-aligned or aligned sequences, (ii) profiles (a multiple\r
alignment in a file) of aligned sequences, (iii) a HMM. Valid\r
combinations of the above are:\r
\r
(a) one file with un-aligned or aligned sequences (i); the sequences\r
    will be aligned, and the alignment will be written out. For this\r
    mode use the -i flag. If the sequences are aligned (all sequences\r
    have the same length and at least one sequence has at least one\r
    gap), then the alignment is turned into a HMM, the sequences are\r
    de-aligned and the now un-aligned sequences are aligned using the\r
    HMM as an External Profile for External Profile Alignment (EPA).\r
    If no EPA is desired use the --dealign flag.\r
\r
    Use the above option to make a multiple alignment from a set of\r
    sequences. A sequence file must contain more than one sequence (at\r
    least two sequences).\r
\r
(b) two profiles (ii)+(ii); the columns in each profile will be kept\r
    fixed and the alignment of the two profiles will be written\r
    out. Use the --p1 and --p2 flags for this mode.\r
\r
    Use this option to align two alignments (profiles) together.\r
\r
(c) one file with un/aligned sequences (i) and one profile (ii); the\r
    profile is converted into a HMM and the un-aligned sequences will\r
    be multiply aligned (using the HMM background information) to form\r
    a profile; this constructed profile is aligned with the input\r
    profile; the columns in each profile (the original one and the one\r
    created from the un-aligned sequences) will be kept fixed and the\r
    alignment of the two profiles will be written out. Use the -i flag\r
    in conjunction with the --p1 flag for this mode.\r
      The un/aligned sequences file (i) must contain at least two\r
    sequences. If a single sequence has to be aligned with a profile\r
    the profile-profile option (b) has to be used.\r
\r
    Use the above option to add new sequences to an existing\r
    alignment.\r
\r
(d) one file with un-aligned sequences (i) and one HMM (iii); the\r
    un-aligned sequences will be aligned to form a profile, using the\r
    HMM as an External Profile. So far only one HMM can be input and\r
    only HMMer2 and HMMer3 formats are allowed. The alignment will be\r
    written out; the HMM information is discarded. As, at the moment,\r
    only one HMM can be used, no HMM is produced if the sequences are\r
    already aligned. Use the -i flag in conjunction with the --hmm-in\r
    flag for this mode. Multiple HMMs can be inputted, however, in the\r
    current version all but the first HMM will be ignored.\r
\r
    Use this option to make a new multiple alignment of sequences from\r
    the input file and use the HMM as a guide (EPA).\r
\r
\r
Invalid combinations of the above are:\r
\r
(v) an un/aligned sequence file containing just one sequence (i)\r
\r
(w) an un/aligned sequence file containing just one sequence and a profile\r
    (i)+(ii)\r
\r
(x) an un/aligned sequence file containing just one sequence and a HMM\r
    (i)+(iii)\r
\r
(y) two or more HMMs (iii)+(iii)+... cannot be aligned to one another.\r
\r
(z) one profile (ii) cannot be aligned with a HMM (iii)\r
\r
\r
The following MSA file formats are allowed:\r
\r
    a2m=fasta, (vienna)\r
    clustal,\r
    msf,\r
    phylip,\r
    selex,\r
    stockholm\r
\r
\r
Prior to MSA, Clustal-Omega de-aligns all sequence input (i). However,\r
alignment information is automatically converted into a HMM and used\r
during MSA, unless the --dealign flag is specifically set.  Profiles\r
(ii) are not de-aligned.\r
\r
The Clustal-Omega alignment engine can at the moment not process\r
DNA/RNA. If a sequence input file (i) or a profile (ii) is interpreted\r
as DNA/RNA the program will terminate during the file input stage.\r
\r
\r
\r
CLUSTERING:\r
\r
  --distmat-in=<file>\r
        Pairwise distance matrix input file (skips distance computation)\r
\r
  --distmat-out=<file>\r
        Pairwise distance matrix output file\r
\r
  --guidetree-in=<file>\r
        Guide tree input file\r
        (skips distance computation and guide tree clustering step)\r
\r
  --guidetree-out=<file>\r
        Guide tree output file\r
\r
  --full\r
        Use full distance matrix for guide-tree calculation (slow; mBed is default)\r
\r
  --full-iter\r
        Use full distance matrix for guide-tree calculation during iteration (mBed is default)\r
\r
\r
In order to produce a multiple alignment Clustal-Omega requires a\r
guide tree which defines the order in which sequences/profiles are\r
aligned. A guide tree in turn is constructed, based on a distance\r
matrix. Conventionally, this distance matrix is comprised of all the\r
pair-wise distances of the sequences. The distance measure\r
Clustal-Omega uses for pair-wise distances of un-aligned sequences is\r
the k-tuple measure [4], which was also implemented in Clustal 1.83\r
and ClustalW2 [5,6]. If the sequences inputted via -i are aligned\r
Clustal-Omega uses the Kimura-corrected pairwise aligned identities\r
[7]. The computational effort (time/memory) to calculate and store a\r
full distance matrix grows quadratically with the number of sequences.\r
Clustal-Omega can improve this scalability to N*log(N) by employing a\r
fast clustering algorithm called mBed [2]; this option is\r
automatically invoked (default). If a full distance matrix evaluation\r
is desired, then the --full flag has to be set. The mBed mode\r
calculates a reduced set of pair-wise distances. These distances are\r
used in a k-means algorithm, that clusters at most 100 sequences. For\r
each cluster a full distance matrix is calculated. No full distance\r
matrix (of all input sequences) is calculated in mBed mode. If there\r
are less than 100 sequences in the input, then in effect a full\r
distance matrix is calculated in mBed mode, however, no distance\r
matrix can be outputted (see below).\r
\r
\r
Clustal-Omega uses Muscle's [8] fast UPGMA implementation to construct\r
its guide trees from the distance matrix. By default, the distance\r
matrix is used internally to construct the guide tree and is then\r
discarded. By specifying --distmat-out the internal distance matrix\r
can be written to file. This is only possible in --full mode. The\r
guide trees by default are used internally to guide the multiple\r
alignment and are then discarded. By specifying the --guidetree-out\r
option these internal guide trees can be written out to\r
file. Conversely, the distance calculation and/or guide tree building\r
stage can be skipped, by reading in a pre-calculated distance matrix\r
and/or pre-calculated guide tree. These options are invoked by\r
specifying the --distmat-in and/or --guidetree-in flags,\r
respectively. However, distance matrix reading is disabled in the\r
current version. By default, distance matrix and guide tree files are\r
not over-written, if a file with the specified name already exists. In\r
this case Clustal-Omega aborts during the command-line processing\r
stage. To force over-writing of already existing files use the --force\r
flag (see MISCELLANEOUS).  In mBed mode a full distance matrix cannot\r
be outputted, distance matrix output is only possible in --full mode.\r
mBed or --full distance mode do not affect the ability to write out\r
guide-trees.\r
\r
Guide trees can be iterated to refine the alignment (see section\r
ITERATION). Clustal-Omega takes the alignment, that was produced\r
initially and constructs a new distance matrix from this alignment.\r
The distance measure used at this stage is the Kimura distance [7]. By\r
default, Clustal-Omega constructs a reduced distance matrix at this\r
stage using the mBed algorithm, which will then be used to create an\r
improved (iterated) new guide tree. To turn off mBed-like clustering\r
at this stage the --full-iter flag has to be set. While Kimura\r
distances in general are much faster to calculate than k-tuple\r
distances, time and memory requirements still scale quadratically with\r
the number of sequences and --full-iter clustering should only be\r
considered for smaller cases (<< 10,000 sequences).\r
\r
\r
\r
ALIGNMENT OUTPUT:\r
\r
  -o, --out, --outfile={file,-} Multiple sequence alignment output file (default: stdout)\r
\r
  --outfmt={a2m=fa[sta],clu[stal],msf,phy[lip],selex,st[ockholm],vie[nna]} MSA output file format (default: fasta)\r
\r
\r
By default Clustal-Omega writes its results (alignments) to stdout. An\r
output file can be specified with the -o flag. Output to stdout is not\r
possible in verbose mode (-v, see MISCELLANEOUS) as verbose/debugging\r
messages would interfere with the alignment output.  By default,\r
alignment files are not over-written, if a file with the specified\r
name already exists. In this case Clustal-Omega aborts during the\r
command-line processing stage. To force over-writing of already\r
existing files use the --force flag (see MISCELLANEOUS).\r
\r
Clustal-Omega can output alignments in various formats by setting the\r
--outfmt flag:\r
\r
  * for Fasta format set: --outfmt=a2m  or  --outfmt=fa  or  --outfmt=fasta\r
\r
  * for Clustal format set: --outfmt=clu  or  --outfmt=clustal\r
\r
  * for Msf format: set --outfmt= msf\r
\r
  * for Phylip format set: --outfmt=phy  or  --outfmt=phylip\r
\r
  * for Selex format set: --outfmt=selex\r
\r
  * for Stockholm format set: --outfmt=st  or  --outfmt=stockholm\r
\r
  * for Vienna format set: --outfmt=vie  or  --outfmt=vienna\r
\r
\r
ITERATION:\r
\r
  --iterations, --iter=<n>  Number of (combined guide tree/HMM) iterations\r
\r
  --max-guidetree-iterations=<n> Maximum guide tree iterations\r
\r
  --max-hmm-iterations=<n>  Maximum number of HMM iterations\r
\r
\r
By default, Clustal-Omega calculates (or reads in) a guide tree and\r
performs a multiple alignment in the order specified by this guide\r
tree. This alignment is then outputted. Clustal-Omega can 'iterate'\r
its guide tree. The hope is that the (Kimura) distances, that can be\r
derived from the initial alignment, will give rise to a better guide\r
tree, and by extension, to a better alignment.\r
\r
A similar rationale applies to HMM-iteration. MSAs in general are very\r
'vulnerable' at their early stages. Sequences that are aligned at an\r
early stage remain fixed for the rest of the MSA. Another way of\r
putting this is: 'once a gap, always a gap'. This behaviour can be\r
mitigated by HMM iteration. An initial alignment is created and turned\r
into a HMM. This HMM can help in a new round of MSA to 'anticipate'\r
where residues should align. This is using the HMM as an External\r
Profile and carrying out iterative EPA.  In practice, individual\r
sequences and profiles are aligned to the External HMM, derived after\r
the initial alignment. Pseudo-count information is then transferred to\r
the (internal) HMM, corresponding to the individual\r
sequence/profile. The now somewhat 'softened' sequences/profiles are\r
then in turn aligned in the order specified by the guide\r
tree. Pseudo-count transfer is reduced with the size of the\r
profile. Individual sequences attain the greatest pseudo-count\r
transfer, larger profiles less so. Pseudo-count transfer to profiles\r
larger than, say, 10 is negligible. The effect of HMM iteration is\r
more pronounced in larger test sets (that is, with more sequences).\r
\r
Both, HMM- and guide tree-iteration come at a cost of increasing the\r
run-time. One round of guide tree iteration adds on (roughly) the time\r
it took to construct the initial alignment. If, for example, the\r
initial alignment took 1min, then it will take (roughly) 2min to\r
iterate the guide tree once, 3min to iterate the guide tree twice, and\r
so on. HMM-iteration is more costly, as each round of iteration adds\r
three times the time required for the alignment stage. For example, if\r
the initial alignment took 1min, then each additional round of HMM\r
iteration will add on 3min; so 4 iterations will take 13min\r
(=1min+4*3min). The factor of 3 stems from the fact that at every\r
stage both intermediate profiles have to be aligned with the\r
background HMM, and finally the (softened) HMMs have to be aligned as\r
well. All times are quoted for single processors.\r
\r
By default, guide tree iteration and HMM-iteration are coupled. This\r
means, at each iteration step both, guide tree and HMM, are\r
re-calculated. This is invoked by setting the --iter flag. For\r
example, if --iter=1, then first an initial alignment is produced\r
(without external HMM background information and using k-tuple\r
distances to calculate the guide tree). This initial alignment is then\r
used to re-calculate a new guide tree (using Kimura distances) and to\r
create a HMM. The new guide tree and the HMM are then used to produce\r
a new MSA.\r
\r
Iteration of guide tree and HMM can be de-coupled. This means that the\r
number of guide tree iterations and HMM iterations can be\r
different. This can be done by combining the --iter flag with the\r
--max-guidetree-iterations and/or the --max-hmm-iterations flag.  The\r
number of guide tree iterations is the minimum of --iter and\r
--max-guidetree-iterations, while the number of HMM iterations is the\r
minimum of --iter and --max-hmm-iterations.  If, for example, HMM\r
iteration should be performed 5 times but guide tree iteration should\r
be performed only 3 times, then one should set --iter=5 and\r
--max-guidetree-iterations=3. All three flags can be specified at the\r
same time (however, this makes no sense). It is not sufficient just to\r
specify --max-guidetree-iterations and --max-hmm-iterations but not\r
--iter. If any iteration is desired --iter has to be set.\r
\r
\r
LIMITS (will exit early, if exceeded):\r
\r
  --maxnumseq=<n>           Maximum allowed number of sequences\r
\r
  --maxseqlen=<l>           Maximum allowed sequence length\r
\r
Limits can be imposed on the number of sequences in the input file\r
and/or the lengths of the sequences. This cap can be set with the\r
--maxnumseq and --maxseqlen flags, respectively. Clustal-Omega will\r
exit early, if these limits are exceeded.\r
\r
\r
MISCELLANEOUS:\r
\r
  --auto                    Set options automatically (might overwrite some of your options)\r
\r
  --threads=<n>             Number of processors to use\r
\r
  -l, --log=<file>          Log all non-essential output to this file\r
\r
  -h, --help                Print help and exit\r
\r
  -v, --verbose             Verbose output (increases if given multiple times)\r
\r
  --version                 Print version information and exit\r
\r
  --long-version            Print long version information and exit\r
\r
  --force                   Force file overwriting\r
\r
\r
Users may feel unsure which options are appropriate in certain\r
situations even though using ClustalO without any special options\r
should give you the desired results. The --auto flag tries to\r
alleviate this problem and selects accuracy/speed flags according to\r
the number of sequences. For all cases will use mBed and thereby\r
possibly overwrite the --full option. For more than 1,000 sequences\r
the iteration is turned off as the effect of iteration is more\r
noticeable for 'larger' problems. Otherwise iterations are set to 1 if\r
not already set to a higher value by the user. Expert users may want\r
to avoid this flag and exercise more fine tuned control by selecting\r
the appropriate options manually.\r
\r
Certain parts of the MSA calculation have been parallelised. Most\r
noticeably, the distance matrix calculation, and certain aspects of\r
the HMM building stage. Clustal-Omega uses OpenMP. By default,\r
Clustal-Omega will attempt to use as many threads as possible. For\r
example, on a 4-core machine Clustal-Omega will attempt to use 4\r
threads. The number of threads can be limited by setting the --threads\r
flag. This may be desirable, for example, in the case of\r
benchmarking/timing.\r
\r
Usually, non-essential (verbose) output is written to screen. This\r
output can be written to file by specifying the --log flag.\r
\r
Help is available by specifying the -h flag.\r
\r
By default Clustal-Omega does not print any information to stdout\r
(other than the final alignment, if no output file is\r
specified). Information concerning the progress of the alignment can\r
be obtained by specifying one verbosity flag (-v). This may be\r
desirable, to verify what Clustal-Omega is actually doing at the\r
moment. If two verbosity flags (-v -v) are specified, command-line\r
flags (explicitly and implicitly set) are printed in addition to the\r
progress report.  Triple verbose level (-v -v -v) is the most verbose\r
level. In addition to single- and double-verbose information much more\r
information is displayed: input sequences and names, details of the\r
tree construction and intermediate alignments. Tree construction\r
information includes pairwise distances. The number of pairwise\r
distances scales with the square of the number of sequences, and\r
double verbose mode is probably only useful for a small number of\r
sequences.\r
\r
The current version number of Clustal-Omega can be displayed by\r
setting the --version flag.\r
\r
The current version number of Clustal-Omega as well as the code-name\r
and the build date can be displayed by setting the --long-version\r
flag.\r
\r
By default, Clustal-Omega does not over-write files. These can be (i)\r
alignment output, (ii) distance matrix and (iii) guide\r
tree. Overwriting can be forced by setting the --force flag.\r
\r
\r
EXAMPLES:\r
\r
./clustalo -i globin.fa\r
\r
Clustal-Omega reads the sequence file globin.fa, aligns the sequences\r
and prints the result to screen in fasta/a2m format.\r
\r
\r
./clustalo -i globin.fa -o globin.sto --outfmt=st\r
\r
If the file globin.sto does not exist, then Clustal-Omega reads the\r
sequence file globin.fa, aligns the sequences and prints the result to\r
globin.sto in Stockholm format. If the file globin.sto does exist\r
already, then Clustal-Omega terminates the alignment process before\r
reading globin.fa.\r
\r
\r
./clustalo -i globin.fa -o globin.aln --outfmt=clu --force\r
\r
Clustal-Omega reads the sequence file globin.fa, aligns the sequences\r
and prints the result to globin.aln in Clustal format, overwriting the\r
file globin.aln, if it already exists.\r
\r
\r
./clustalo -i globin.fa --distmat-out=globin.mat --guidetree-out=globin.dnd --force\r
\r
Clustal-Omega reads the sequence file globin.fa, aligns the sequences,\r
prints the result to screen in fasta/a2m format (default), the guide\r
tree to globin.dnd and the distance matrix to globin.mat, overwriting\r
those files if they already exist.\r
\r
\r
./clustalo -i globin.fa --guidetree-in=globin.dnd\r
\r
Clustal-Omega reads the files globin.fa and globin.dnd, skipping\r
distance calculation and guide tree creation, using instead the guide\r
tree specified in globin.dnd.\r
\r
\r
./clustalo -i globin.fa --hmm-in=PF00042.hmm\r
\r
Clustal-Omega reads the sequence file globin.fa and the HMM file\r
PF00042.hmm (in HMMer2 or HMMer3 format).  It then performs the\r
alignment, transferring pseudo-count information contained in\r
PF00042.hmm to the sequences/profiles during the MSA.\r
\r
\r
./clustalo -i globin.sto\r
\r
Clustal-Omega reads the file globin.sto (of aligned sequences in\r
Stockholm format). It converts the alignment into a HMM, de-aligns the\r
sequences and re-aligns them, transferring pseudo-count information to\r
the sequences/profiles during the MSA. The guide tree is constructed\r
using a full distance matrix of Kimura distances.\r
\r
\r
./clustalo -i globin.sto  --dealign\r
\r
Clustal-Omega reads the file globin.sto (of aligned sequences in\r
Stockholm format). It de-aligns the sequences and then re-aligns\r
them. No HMM is produced in the process, no pseudo-count information\r
is transferred. Consequently, the output must be the same as for\r
unaligned output (like in the first example ./clustalo -i globin.fa)\r
\r
\r
./clustalo -i globin.fa --iter=2\r
\r
Clustal-Omega reads the file globin.fa, creates a UPGMA guide tree\r
built from k-tuple distances, and performs an initial alignment. This\r
initial alignment is converted into a HMM and a new guide tree is\r
built from the Kimura distances of the initial alignment. The\r
un-aligned sequences are then aligned (for the second time but this\r
time) using pseudo-count information from the HMM created after the\r
initial alignment (and using the new guide tree). This second\r
alignment is then again converted into a HMM and a new guide tree is\r
constructed. The un-aligned sequences are then aligned (for a third\r
time), again using pseudo-count information of the HMM from the\r
previous step and the most recent guide tree. The final alignment is\r
written to screen.\r
\r
\r
./clustalo -i globin.fa --iter=5 --max-guidetree-iterations=1\r
\r
Clustal-Omega reads the file globin.fa, creates a UPGMA guide tree\r
built from k-tuple distances, and performs an initial alignment. This\r
initial alignment is converted into a HMM and a new guide tree is\r
built from the Kimura distances of the initial alignment. The\r
un-aligned sequences are then aligned (for the second time but this\r
time) using pseudo-count information from the HMM created after the\r
initial alignment (and using the new guide tree). For the last 4\r
iterations the guide tree is left unchanged and only HMM iteration is\r
performed. This means that intermediate alignments are converted to\r
HMMs, and these intermediate HMMs are used to guide the MSA during\r
subsequent iteration stages.\r
\r
\r
./clustalo -i globin.fa -o globin.a2m -v\r
\r
In case the file globin.a2m does not exist, Clustal-Omega reads the\r
file globin.fa, prints a progress report to screen and writes the\r
alignment in (default) Fasta format to globin.a2m. The progress report\r
consists of the number of threads used, the number of sequences read,\r
the current progress in the k-tuple distance calculation, completion\r
of the guide tree computation and current progress of the MSA stage.\r
If the file globin.a2m already exists Clustal-Omega aborts before\r
reading the file globin.fa. Note that in verbose mode an output file\r
has to be specified, because progress/debugging information, which is\r
printed to screen, would interfere with the alignment being printed to\r
screen.\r
\r
\r
./clustalo -i PF00042_full.fa --dealign --full --outfmt=vie -o PF00042_full.vie --force\r
\r
Clustal-Omega reads the file PF00042_full.fa. This file contains\r
several thousand aligned sequences. --dealign tells Clustal-Omega to\r
erase all alignment information and re-align the sequences from\r
scratch. As there are several thousand sequences calculating a full\r
distance matrix may be slow. Setting the --full flag specifically\r
selects the full distance mode over the default mBed mode. The\r
alignment is then written out in Vienna format (fasta format all on\r
one line, no line breaks per sequence) to file PF00042_full.vie.\r
\r
\r
./clustalo -i PF00042_full.fa --dealign --outfmt=vie -o PF00042_full.vie --force\r
\r
Clustal-Omega reads the file PF00042_full.fa. This file contains\r
several thousand aligned sequences. --dealign tells Clustal-Omega to\r
erase all alignment information and re-align the sequences from\r
scratch. Calculating the distance matrix will be done by mBed\r
(default). Clustal-Omega will calculate pairwise distances to a\r
small number of reference sequences only. This will give a significant\r
speed-up. The speed-up is greater for larger families (more\r
sequences). The alignment is then written out in Vienna format (fasta\r
format all on one line, no line breaks per sequence) to file\r
PF00042_full.vie.\r
\r
\r
./clustalo --p1=globin.sto --p2=PF00042_full.vie -o globin+pf00042.fa\r
\r
Clustal-Omega reads files globin.sto and PF00042_full.vie of aligned\r
sequences (profiles). Both profiles are then aligned. The relative\r
positions of residues in both profiles are not changed during this\r
alignment, however, columns of gaps may be inserted into the profiles,\r
respectively. The final alignment is written to file globin+pf00042.fa\r
in fasta format.\r
\r
\r
./clustalo -i globin.fa --p1=PF00042_full.vie -o pf00042+globin.fa\r
\r
Clustal-Omega reads file globin.fa of un-aligned sequences and the\r
profile (of aligned sequences) in file PF00042_full.vie. A HMM is\r
created from the profile. This HMM is used to guide the alignment of\r
the un-aligned sequences in globin.fa. The profile that was generated\r
during this alignment of un-aligned globin.fa sequences is then\r
aligned to the input profile PF00042_full.vie. The relative positions\r
of residues in profile PF00042_full.vie is not changed during this\r
alignment, however, columns of gaps may be inserted into the\r
profile. The final alignment is output to file pf00042+globin.fa in\r
fasta format. The alignment in this example may be slightly different\r
from the alignment in the previous example, because no HMM guidance\r
was used generate the profile globin.sto. In this example HMM guidance\r
was used to align the sequences in globin.fa; the hope being that this\r
intermediate alignment will have profited from the bigger profile.\r
\r
\r
\r
LITERATURE:\r
\r
[1] Johannes Soding (2005) Protein homology detection by HMM-HMM\r
    comparison. Bioinformatics 21 (7): 951–960.\r
\r
[2] Blackshields G, Sievers F, Shi W, Wilm A, Higgins DG.  Sequence\r
    embedding for fast construction of guide trees for multiple\r
    sequence alignment.  Algorithms Mol Biol. 2010 May 14;5:21.\r
\r
[3] http://www.genetics.wustl.edu/eddy/software/#squid\r
\r
[4] Wilbur and Lipman, 1983; PMID 6572363\r
\r
[5] Thompson JD, Higgins DG, Gibson TJ.  (1994). CLUSTAL W: improving\r
    the sensitivity of progressive multiple sequence alignment through\r
    sequence weighting, position-specific gap penalties and weight\r
    matrix choice. Nucleic Acids Res., 22, 4673-4680.\r
\r
[6] Larkin MA, Blackshields G, Brown NP, Chenna R, McGettigan PA,\r
    McWilliam H, Valentin F, Wallace IM, Wilm A, Lopez R, Thompson JD,\r
    Gibson TJ, Higgins DG.  (2007). Clustal W and Clustal X version\r
    2.0. Bioinformatics, 23, 2947-2948.\r
\r
[7] Kimura M (1980). "A simple method for estimating evolutionary\r
    rates of base substitutions through comparative studies of\r
    nucleotide sequences". Journal of Molecular Evolution 16: 111–120.\r
\r
[8] Edgar, R.C. (2004) MUSCLE: multiple sequence alignment with high\r
    accuracy and high throughput.Nucleic Acids Res. 32(5):1792-1797.\r
\r