--- /dev/null
+\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
git://source.jalview.org / jabaws.git / commitdiff