exonerate(1)

📦
version 2.4.0 · 2 versions
, in debian bookworm, debian trixie, ubuntu jammy, ubuntu noble, ubuntu questing, ubuntu resolute, ubuntu stonking

🦋 exonerate(1) — sequence comparison tool 🦋

okay bestie, you opened the man page for exonerate 💅 and honestly? you're in for a treat. It's long, it's iconic, and we're getting through every single bit of it together. No skipping, no skimming, we're doing this properly. ✨

💖 NAME 💖

exonerate — a generic tool for sequence comparison. That's the whole job description, and she does it so well. 👑

📜 SYNOPSIS 📜

exonerate [ options ] <query path> <target path>

Like, that's the shape of every call. Options, then a query path, then a target path. Simple on the surface, absolutely stacked underneath. 💜

🌸 DESCRIPTION 🌸

exonerate is a general tool for sequence comparison. Generic queen behavior. 💅

She runs on the C4 dynamic programming library, and the whole point of her design is that she's both general and fast. Not a pick-one situation — she does both.

She can spit out either gapped or ungapped alignments, depending on which of a whole variety of alignment models you point her at. The C4 library lets you do sequence alignment using a reduced space full dynamic programming implementation — which is the thorough, no-shortcuts way of doing it.

But it also lets you auto-generate heuristics from the alignment models, using bounded sparse dynamic programming, so those alignments can be generated super fast too. 🏃‍♀️💨

⚠️ Real talk though: alignments generated using these heuristics will represent a valid path through the alignment model, but (unlike the exhaustive alignments) the results are not guaranteed to be optimal. She's fast, she's not always right-right, iykyk.

🎀 CONVENTIONS 🎀

There are a bunch of conventions (and honestly, some straight-up idiosyncracies) baked into exonerate. Get these in your head and reading the output becomes so much easier. 🧠✨

📍 Coordinates

She uses an in-between coordinate system, where positions are counted between the symbols, not on the symbols. And the numbering starts from zero. Groundbreaking, I know.

Here's how it looks for the sequence "ACGT":

A C G T
0 1 2 3 4

So the subsequence "CG" would have start=1, end=3, and length=2. See how that works? Chef's kiss. 😌

This coordinate system is used internally in exonerate, and for all the output formats produced — with two exceptions:

  • the "human readable" alignment display
  • the GFF output

...because convention and standards dictate otherwise there. Not her choice, she's just following the rules. 🙈

🔄 Reverse Complements

When an alignment gets reported on the reverse complement of a sequence, the coordinates are just given on the reverse complement copy of the sequence. So positions on the sequences are never negative. 🚫➖

Generally:

  • the forward strand is indicated by '+'
  • the reverse strand by '-'
  • an unknown or not-applicable strand (like in the case of a protein sequence) is indicated by '.'

🏆 Alignment Scores

Currently, only the raw alignment scores are displayed. This score just is the sum of transition scores used in the dynamic programming.

For example, in the case of a Smith-Waterman alignment, this will be the sum of the substitution matrix scores and the gap penalties. That's the whole math, bestie. 📐💖

✨ GENERAL OPTIONS ✨

Most arguments have both short and long forms. The long forms are more likely to be stable over time, so use the long forms in scripts that call exonerate. Future you will thank present you. 🫶

  • -h, --shorthelp <boolean> — Show help. This displays a concise summary of the available options, defaults and values currently set.
  • --help <boolean> — This shows all the help options, including the defaults, the value currently set, and the environment variable which may be used to set each parameter. There will be an indication of which options are mandatory. Mandatory options have no default, and must have a value supplied for exonerate to run. If mandatory options are used in order, their flags may be skipped from the command line (see examples below). Unlike this man page, the information from this option will always be up to date with the latest version of the program. 👀
  • -v, --version <boolean> — Display the version number. Also displays other information such as the build date and glib version used.

🧬 SEQUENCE INPUT OPTIONS 🧬

Pairwise comparisons get performed between all query sequences and all target sequences. So like, every combination. 💞

Generally, for the best performance:

  • shorter sequences (eg. ESTs, shotgun reads, proteins) should be used as the query sequences
  • longer sequences (eg. genomic sequences) should be used as the target sequences
  • -q, --query <paths> — Specify the query sequences required. These must be in a FASTA format file. Single or multiple query sequences may be supplied. Additionally, multiple copies of the fasta file may be supplied following a --query flag, or by using multiple --query flags.
  • -t, --target <paths> — Specify the target sequences required. Also must be in a FASTA format file. As with the query sequences, single or multiple target sequences and files may be supplied. The target filename may be replaced by a server name and port number in the form of hostname:port when using exonerate-server. See the man page for exonerate-server for more information on running exonerate in client:server mode.
    • 🆕 NEW(v2.4.0): multiple servers may now be used. These will be queried in parallel if you have set the --cores option.
    • 🆕 NEW(v2.4.0): If an input file is not a FASTA format file, it is assumed to contain a list of other fasta files, directories or servers (one per line).
  • -Q, --querytype <dna | protein> — Specify the query type to use. If this is not supplied, the query type is assumed to be DNA when the first sequence in the file contains more than 85% [ACGTN] bases. Otherwise, it is assumed to be peptide. This option forces the query type, since some nucleotide and peptide sequences can fall either side of this threshold. 🤷‍♀️
  • -T, --targettype <dna | protein> — Specify the target type to use. The same as --querytype (above), except that it applies to the target. Specifying the sequence type will avoid the overhead of having to read the first sequence in the database twice (which may be significant with chromosome-sized sequences). 💀
  • --querychunkid <id>
  • --querychunktotal <total>
  • --targetchunkid <id>
  • --targetchunktotal <total>

These four options exist to facilitate running exonerate on compute farms, and avoid having to split up sequence databases into small chunks to run on different nodes. Iconic efficiency move, honestly. 💅

If, for example, you wished to split the target database into three parts, you would run three exonerate jobs on different nodes including the options:

--targetchunkid 1 --targetchunktotal 3
--targetchunkid 2 --targetchunktotal 3
--targetchunkid 3 --targetchunktotal 3
NB. The granularity offered by this option only goes down to a single sequence, so when there are more chunks than sequences in the database, some processes will do nothing. 😭 (girl is just sitting there, unpaid, doing zero work)
  • -V, --verbose <int> — Be verbose — show information about what is going on during the analysis. The default is 1 (little information), and the higher the number given, the more information is printed. To silence all the default output from exonerate, use:
--verbose 0 --showalignment no --showvulgar no

🔬 ANALYSIS OPTIONS 🔬

  • -E, --exhaustive <boolean> — Specify whether or not exhaustive alignment should be used. By default, this is FALSE, and alignment heuristics will be used. If it is set to TRUE, an exhaustive alignment will be calculated. This requires quadratic time, and will be much, much slower, but will provide the optimal result for the given model.
⚠️ yes bestie, she said quadratic. Buckle in if you flip this one on. 🐌
  • -B, --bigseq <int> — Perform alignment of large (multi-megabase) sequences. This is very memory efficient and fast when both sequences are chromosome-sized, but currently does not currently permit the use of a word neighbourhood (ie. exactly matching seeds only).
  • --revcomp <boolean> — Include comparison of the reverse complement of the query and target where possible. By default, this option is enabled, but when you know the gene is definitely on the forward strand of the query and target, this option can halve the time taken to compute alignments. 🕐✂️
  • --forcescan <none | query | target> — Force the FSM to scan the query sequence rather than the target. This option is useful, for example, if you have a single piece of genomic sequence and you wish to compare it to the whole of dbEST. By scanning the database rather than the query, the analysis will be completed much more quickly, as the overheads of multiple query FSM construction, multiple target reading and splice site predictions will be removed. By default, exonerate will guess the optimal strategy based on database sequence sizes. 🧠
  • --saturatethreshold <number> — When set to zero, this option does nothing. Otherwise, once more than this number of words (in addition to the expected number of words by chance) have matched a position on the query, the position on the query will be 'numbed' (ignore further matches) for the current pairwise comparison. 🥶
  • --customserver <command> — When using exonerate in client:server mode with a non-standard server, this command allows you to send a custom command to the server. This command is sent by the client (exonerate) before any other commands, and is provided as a way of passing parameters or other commands specific to the custom server. See the exonerate-server man page for more information on running exonerate in client:server mode.
  • --cores <number> — The number of cores/CPUs/threads that should be used. On a multi-core or multi-CPU machine, increasing this amount allows alignment computations to run in parallel on separate CPUs/cores.
NB. Generally, it is better to parallelise the analysis by splitting it up into separate jobs, but this option may prove useful for problems such as interactive single-gene queries. 🌈

📁 FASTA DATABASE OPTIONS 📁

  • --fastasuffix <extension> — If any of the inputs given with --query or --target are directories, then exonerate will recursively descend these directories, reading all files ending with this suffix as fasta format input. 🗂️💖

✨ GAPPED ALIGNMENT OPTIONS ✨

okay bestie this is the part where things get real — actual alignment, actual gapping, actual drama 💅

  • -m, --model <alignment model> — pick which alignment model to use. the ones we support rn are:
    • ungapped — the simplest type of model, and the default. an appropriate model gets selected automatically for the type of input sequences you give it.
    • ungapped:trans — an ungapped model that includes translation of all frames of both the query and the target sequences. basically an ungapped tblastx type search vibe.
    • affine:global — does gapped global alignment, similar to the Needleman-Wunsch algorithm, except with affine gaps. global alignment requires that both sequences, in their entirety, are included in the alignment — no half measures, no crumbs.
    • affine:bestfit — does a best fit / best location alignment of the query onto the target sequence. the entire query sequence will be in the alignment, but only the best location for its alignment on the target.
    • affine:local — local alignment with affine gaps, similar to the Smith-Waterman-Gotoh algorithm. a general-purpose alignment algorithm. since it's local, any subsequence of the query and target sequence may appear in the alignment 👑
    • affine:overlap — finds the best overlap between the query and the target. the overlap alignment must include the start of the query or target and the end of the query or the target sequence, so it can align sequences which overlap at the ends, or in the mid-section of a longer sequence. this is the type of alignment that gets used in assembly algorithms all the time.
    • est2genome — like affine:local, but it also includes intron modelling on the target sequence so it can align spliced to unspliced coding sequences for both forward and reversed genes. similar to the alignment models used in programs like EST_GENOME and sim4.
    • ner — NERs are non-equivalenced regions, i.e. large regions in both the query and target which are not aligned. this model can be used for protein alignments where strongly conserved helix regions get aligned but weakly conserved loop regions don't. similarly it can be used to look for co-linearly conserved regions when comparing genomic sequences.
    • protein2dna — compares a protein sequence to a DNA sequence, incorporating all the appropriate gaps and frameshifts.
    • protein2dna:bestfit — bestfit version of the protein2dna model, where the entire protein is included in the alignment. it is currently only available when using exhaustive alignment.
    • protein2genome — allows alignment of a protein sequence to genomic DNA. similar to the protein2dna model, with the addition of modelling of introns and intron phases. same energy as the models used by genewise.
    • protein2genome:bestfit — bestfit version of the protein2genome model, where the entire protein is included in the alignment. it is currently only available when using exhaustive alignment.
    • coding2coding — similar to the ungapped:trans model, except gaps and frameshifts are allowed. basically a gapped tblastx search.
    • coding2genome — similar to the est2genome model, except the query sequence is translated during comparison, which gives you a more sensitive comparison.
    • cdna2genome — combines properties of the est2genome and coding2genome models, so you can model a whole cDNA where a central coding region can be flanked by non-coding UTRs. when the CDS start and end is known it may be specified using the --annotation option (see below) to permit only the correct coding region to appear in the alignment.
    • genome2genome — similar to the coding2coding model, except introns are modelled on both sequences. (not working well yet) 💀

the short names u, u:t, a:g, a:b, a:l, a:o, e2g, ner, p2d, p2d:b p2g, p2g:b, c2c, c2g cd2g and g2g can also be used for specifying models. ✨

  • -s, --score <threshold> — this is the overall score threshold. alignments will not be reported below it. for heuristic alignments, the higher this threshold, the less time the analysis will take. ⏱️
  • --percent <percentage> — report only alignments scoring at least this percentage of the maximal score for each query. eg. use --percent 90 to report alignments with 90% of the maximal score obtainable for that query. this option is useful not only because it reduces the spurious matches in the output, but because it generates query-specific thresholds (unlike --score) for a set of queries of differing lengths, and it will also speed up the search considerably. NB. with this option, it is possible to have a cDNA match its corresponding gene exactly, yet still score less than 100%, due to the addition of the intron penalty scores — hence this option must be used with caution, bestie 🫶
  • --showalignment <boolean> — show the alignments in a human readable form. yes, readable by actual humans. we love accessibility 💖
  • --showsugar <boolean> — display "sugar" output for ungapped alignments. Sugar is Simple UnGapped Alignment Report, which displays ungapped alignments one-per-line. the sugar line starts with the string "sugar:" for easy extraction from the output, and is followed by these 9 fields, in this order:
    • query_id — Query identifier
    • query_start — Query position at alignment start
    • query_end — Query position alignment end
    • query_strand — Strand of query matched
    • target_id — the same 4 fields, but for the target sequence:
    • target_start — (same 4 fields, for the target)
    • target_end — (same 4 fields, for the target)
    • target_strand — (same 4 fields, for the target)
    • score — The raw alignment score
  • --showcigar <boolean> — show the alignments in "cigar" format. Cigar is a Compact Idiosyncratic Gapped Alignment Report, which displays gapped alignments one-per-line. the format starts with the same 9 fields as sugar output (see above), and is followed by a series of <operation, length> pairs, where operation is one of match, insert or delete, and the length describes the number of times this operation is repeated.
  • --showvulgar <boolean> — shows the alignments in "vulgar" format. Vulgar is Verbose Useful Labelled Gapped Alignment Report. this format also starts with the same 9 fields as sugar output (see above), and is followed by a series of <label, query_length, target_length> triplets. the label may be one of the following:
    • M — Match
    • C — Codon
    • G — Gap
    • N — Non-equivalenced region
    • 5 — 5' splice site
    • 3 — 3' splice site
    • I — Intron
    • S — Split codon
    • F — Frameshift
  • --showquerygff <boolean> — report GFF output for features on the query sequence. see http://www.sanger.ac.uk/Software/formats/GFF for more information.
  • --showtargetgff <boolean> — report GFF output for features on the target sequence.
  • --ryo <format> — roll-your-own output format, aka main character energy 🔥 this lets you specify a printf-esque format line which is used to specify which information goes in the output, and how it's shown. the format field may contain the following fields:
    • %[qt][idlsSt] — for either {query,target}, report the {id,definition,length,sequence,Strand,type}. sequences are reported in a fasta-format like block (no headers).
    • %[qt]a[bels] — for either {query,target} region which occurs in the alignment, report the {begin,end,length,sequence}
    • %[qt]c[bels] — for either {query,target} region which occurs in the coding sequence in the alignment, report the {begin,end,length,sequence}
    • %s — The raw score
    • %r — The rank (in results from a bestn search)
    • %m — Model name
    • %e[tism] — Equivalenced {total,id,similarity,mismatches} (ie. %em == (%et - %ei))
    • %p[isS] — Percent {id,similarity,Self} over the equivalenced portions of the alignment. (ie. %pi == 100*(%ei / %et)). Percent Self is the score over the equivalenced portions of the alignment as a percentage of the self comparison score of the query sequence.
    • %g — Gene orientation ('+' = forward, '-' = reverse, '.' = unknown)
    • %S — Sugar block (the 9 fields used in sugar output (see above))
    • %C — Cigar block (the fields of a cigar line after the sugar portion)
    • %V — Vulgar block (the fields of a vulgar line after the sugar portion)
    • %% — Expands to a percentage sign (%)
    • \n — Newline
    • \t — Tab
    • \\ — Expands to a backslash (\)
    • \{ — Open curly brace
    • \} — Close curly brace
    • { — Begin per-transition output section
    • } — End per-transition output section
    • %P[qt][sabe] — Per-transition output for {query,target} {sequence,advance,begin,end}
    • %P[nsl] — Per-transition output for {name,score,label}

this option is very useful and flexible. for example, to report all the sections of query sequences which feature in alignments in fasta format, use:

--ryo ">%qi %qd\n%qas\n"

To output all the symbols and scores in an alignment, try something like:

--ryo "%V{%Pqs %Pts %Ps\n}"
  • -n, --bestn <number> — bestie, this one reports the best N results for each query. Heads up tho: only the results that score better than the score threshold actually get reported, so no sneaky low-scorers slipping through. It cuts down how much output you get <em>and</em> it lets exonerate speed up the search. Win-win 💅
  • -S, --subopt <boolean> — turns on reporting of Waterman-Eggert style suboptimal alignments. And bestie, it is on by default ✨ Every suboptimal (that means non-intersecting) alignment gets reported for each pair of sequences that scores at least the threshold you set with --score.
Okay so lowkey important: if you use this with exhaustive alignments, you're signing up for several full quadratic time passes, so the running time goes up <em>considerably</em>. Like, considerably considerably. 😭
  • -g, --gappedextension <boolean> — makes a gapped extension stage happen, i.e. dynamic programming gets applied in arbitrarily shaped, dynamically sized regions hanging around the HSP seeds. The extension threshold is controlled by the --extensionthreshold option, so go peek at that one.

It's sometimes slower than BSDP, but gapped extension improves sensitivity with weak, gap-rich alignments — think cross-species comparison energy. 🧬

NB. This option is now the default. Set it to false to reverse back to the old BSDP type alignments. Also: this option may be slower than BSDP for some large scale analyses with simple alignment models. Pick your fighter. ⚔️
  • --refine <strategy> — forces exonerate to refine alignments generated by heuristics using dynamic programming over larger regions. Takes more time, yes, but it improves the quality of the final alignments. Glow-up but make it compute. ✨

The strategies available for refinement are:

  • none — the default, no refinement is used.
  • full — an exhaustive alignment is calculated from the pair of sequences in their entirety. Go big or go home.
  • region — DP is applied just to the region of the sequences covered by the heuristic alignment. Chill, targeted, respectful of your time. 💅
  • --refineboundary <size> — specifies an extra boundary to be included in the region subject to alignment during refinement by region. Little padding for the vibes.

🔮 VITERBI ALGORITHM OPTIONS 🔮

  • -D, --dpmemory <Mb> — the exhaustive alignment traceback routines use a Hughey-style reduced memory technique, and this option says how much memory gets used for that. Generally the more memory you allow here, the faster the alignments come out. More RAM = more speed, no cap. 🚀

⚙️ CODE GENERATION OPTIONS ⚙️

  • -C, --compiled <boolean> — lets you disable generated code for dynamic programming. It's mainly used while developing exonerate itself. When you set it to FALSE, an "interpreted" version of the dynamic programming implementation is used instead, which is much slower. Interpreted = the vibes are relaxed but the clock is not. 💀

🕵️ HEURISTIC OPTIONS 🕵️

  • --terminalrangeint
  • --terminalrangeext
  • --joinrangeint
  • --joinrangeext
  • --spanrangeint
  • --spanrangeext

Okay so these six specify the size of the sub-alignment regions that DP gets applied to around the ends of the HSPs. Where exactly? Could be at the HSP ends (that's the terminal range), between HSPs (the join range), or between HSPs that might be connected by a large region like an intron or a non-equivalenced region (the span range). And each range can be specified either for a number of matches back onto the HSP (the internal range) or out from the HSP (the external range). Int = in, ext = out. iykyk 🎀

🌱 SEEDED DYNAMIC PROGRAMMING OPTIONS 🌱

  • -x, --extensionthreshold <score> — this is the amount the score is allowed to degrade during SDP. It's the equivalent of the hspdropoff penalties, except it gets applied during dynamic programming instead of HSP extension. Decrease this parameter and the SDP speeds up; increase it and the sensitivity goes up. Tradeoffs, bestie, they're everywhere. ⚖️
  • --singlepass <boolean> — by default, the suboptimal SDP alignments are reported by a singlepass algorithm, but that may miss some suboptimal alignments that are close together. This option forces the use of a multipass suboptimal alignment algorithm for SDP instead, which gives you higher quality suboptimal alignments. 🏆

🧪 BSDP OPTIONS 🧪

  • --joinfilter <limit> — (experimental) 🧪

Only allow consideration of this number of SARs for joining HSPs together. The SARs with the highest potential for appearing in a high-scoring alignment are the ones considered. This option is useful for limiting time and memory usage when searching unmasked data with repetitive sequences, but bestie, don't set it too low, because valid matches may get ignored. Something like --joinfilter 32 seems to work well. ✨

📜 SEQUENCE OPTIONS 📜

  • --annotation <path> — specify basic sequence annotation information. It's most useful with the cdna2genome model, but it will work with other models too. The annotation file has four fields per line:
<id> <strand> <cds_start> <cds_length>

Here's a simple example of such a file for 4 cDNAs:

dhh.human.cdna + 308 1191
dhh.mouse.cdna + 250 1191
csn7a.human.cdna + 178 828
csn7a.mouse.cdna + 126 828

These annotation lines will also work when only the first two fields are used — handy when you're specifying which strand of a specific sequence should be included in a comparison. Two fields only, still valid, still slaying. 💅

🔤 SYMBOL COMPARISON OPTIONS 🔤

  • --softmaskquery <boolean> — indicates that the query is softmasked. See the description below for --softmasktarget (it's literally right there 👇).
  • --softmasktarget <boolean> — indicates that the target is softmasked. In a softmasked sequence file, instead of masking regions with Ns or Xs, they get masked by putting those regions in lower case (and the unmasked regions in upper case). This option lets the masking be ignored by some parts of the program, which combines the speed of searching masked data with the sensitivity of searching unmasked data. The fastasoftmask utility supplied with exonerate can produce softmasked sequence from conventionally masked sequence. Two worlds, one option. 🌈
  • -d, --dnasubmat <name> — specify the substitution matrix to be used for DNA comparison. This should be a path to a substitution matrix in the same format that blast uses.
  • -p, --proteinsubmat <name> — specify the substitution matrix to be used for protein comparison. (Both DNA and protein substitution matrices are required for some types of analysis.) And ooh, the special names — nucleic, blosum62, pam250, edit or identity — will cause built-in substitution matrices to be used. Free matrices, no download required. 🎁

🧵 ALIGNMENT SEEDING OPTIONS 🧵

  • -M, --fsmmemory <Mb> — specifies the amount of memory to use for the FSM in heuristic analyses. exonerate multiplexes the query to accelerate large-throughput database queries. This figure should <em>always</em> be less than the physical memory on the machine, but when you're searching large databases, generally the more memory it's allowed to use, the faster it goes. Feed it RAM, it runs. 🍓
  • --forcefsm <none | normal | compact> — forces the use of more compact finite state machines for analyses involving big sequences and large word neighbourhoods. By default, exonerate picks a sensible strategy on its own, so this option will rarely need to be set. Trust the process. 🫶
  • --wordjump <int> — the jump between query words used to yield the word neighbourhood. Set it to 1 and every word is used; set it to 2 and every other word is used; set it to the wordlength and only non-overlapping words get used. This reduces memory requirements when you're working with very large query sequences and makes the search run faster — but it also damages search sensitivity when you set high values. Speed or sensitivity, choose wisely. 💀
  • --wordambiguity <limit> — this one lets you allow alignment seeds containing IUPAC ambiguity symbols. The limit is the maximum number of ambiguous words allowed at a single position. If that limit is reached, then the position is not used for alignment seeding. Using this option may slow down a search. For large datasets, it's recommended to use esd2esi --wordambiguity instead, since then the speed overhead is only incurred during indexing rather than during the database searching itself. NB. This option <em>only</em> works for IUPAC symbols in the target sequence — query words containing IUPAC symbols are (currently) excluded from seeding. 🙈

📐 AFFINE MODEL OPTIONS 📐

  • -o, --gapopen <penalty> — this is the gap open penalty.
  • -e, --gapextend <penalty> — this is the gap extension penalty.
  • --codongapopen <penalty> — this is the codon gap open penalty.
  • --codongapextend <penalty> — this is the codon gap extension penalty.

Four penalties, all doing exactly what they say on the tin. Respect. 🎀

🧬 NER OPTIONS 🧬

  • --minner <boolean> — minimum NER length allowed.
  • --maxner <length> — maximum NER length allowed. NB. this option only affects heuristic alignments.
  • --neropen <penalty> — penalty for opening a non-equivalenced region.

🪡 INTRON MODELLING OPTIONS 🪡

  • --minintron <length> — minimum intron length limit. NB. this option only affects heuristic alignments. And it is <em>not</em> a hard limit — it only affects the size of introns which are sought during heuristic alignment. So like, a suggestion, not a law. 💅
  • --maxintron <length> — maximum intron length limit. See the notes above for --minintron — same energy, opposite direction.
  • -i, --intronpenalty <penalty> — penalty for introduction of an intron. Introns don't come free, bestie. 💸

🌀 FRAMESHIFT MODELLING OPTIONS 🌀

  • -f, --frameshift <penalty> — the penalty for the inclusion of a frameshift in an alignment. One little slip and you pay for it. 😭

🅰️ ALPHABET OPTIONS 🅰️

  • --useaatla <boolean> — use three-letter abbreviations for AA names. i.e. when displaying an alignment, Met is used instead of M. Fancy full names instead of the single-letter mystery boxes. 👑

💖 TRANSLATION OPTIONS 💖

Okay bestie, this section is all about how we translate DNA into protein, and it's giving very choose your own genetic code energy. 🧬✨

  • --geneticcode <code> — Pick a different genetic code. The default is 1, the standard genetic code. You can drop it in shorthand or longhand form.

In shorthand, a number between 1 and 23 selects one of 17 built-in genetic code variants. These are taken from: http://www.ncbi.nlm.nih.gov/Taxonomy/Utils/wprintgc.cgi. The vibes are:

  • 1 — The Standard Code
  • 2 — The Vertebrate Mitochondrial Code
  • 3 — The Yeast Mitochondrial Code
  • 4 — The Mold, Protozoan, and Coelenterate Mitochondrial Code and the Mycoplasma/Spiroplasma Code
  • 5 — The Invertebrate Mitochondrial Code
  • 6 — The Ciliate, Dasycladacean and Hexamita Nuclear Code
  • 9 — The Echinoderm and Flatworm Mitochondrial Code
  • 10 — The Euplotid Nuclear Code
  • 11 — The Bacterial and Plant Plastid Code
  • 12 — The Alternative Yeast Nuclear Code
  • 13 — The Ascidian Mitochondrial Code
  • 14 — The Alternative Flatworm Mitochondrial Code
  • 15 — Blepharisma Nuclear Code
  • 16 — Chlorophycean Mitochondrial Code
  • 21 — Trematode Mitochondrial Code
  • 22 — Scenedesmus obliquus mitochondrial Code
  • 23 — Thraustochytrium Mitochondrial Code

In longhand, you can provide a genetic code variant as a 64 byte string in TCAG order. For example, the standard genetic code in this form is:

FFLLSSSSYY**CC*WLLLLPPPPHHQQRRRRIIIMTTTTNNKKSSRRVVVVAAAADDEEGGGG

Slay. 💅

✨ HSP CREATION OPTIONS ✨

  • --hspfilter <threshold> — Use aggressive HSP filtering to speed up heuristic searches. The threshold is the number of HSPs centred about a point in the query that will be stored. Any lower scoring HSPs get yeeted. This is an experimental option to handle speed problems caused by some sequences. A value of about 100 seems to work well.
  • --useworddropoff <boolean> — When this is TRUE, the score threshold for admitting words into the word neighbourhood is set to be the initial word score minus the word threshold (see below). This strategy is designed to prevent restricting the word SSSYY**CC*WLLLLPPPPHHQQRRRRIIIMTTTTNNKKSSRRVVVVAAAADDEEGGGG When this is FALSE, the word threshold is taken to be an absolute value. (Yes, that string is just vibing there in the original. We keep it exactly, no cap. 🫶)
  • --seedrepeat <count> — The seedrepeat parameter sets the number of seeds which must be found on the same diagonal or reading frame before HSP extension will occur. Increasing the value for --seedrepeat will speed up searches, and is usually a better option than using longer word lengths, particularly when using the exonerate-server where increasing word lengths requires recomputing the index, and greater increases memory requirements.
  • -w, --dnawordlen <bases> -W, --proteinwordlen <residues> -W, --codonnwordlen <bases> — The word length used for DNA, protein or codon words. When performing DNA vs protein comparisons, a the DNA wordlength will always (automatically) be triple the protein wordlength. (That "a the" is a little typo moment, but we're keeping the facts.)
  • --dnahspdropoff <score> --proteinhspdropoff <score> --codonhspdropoff <score> — The amount by which an HSP score will be allowed to degrade during HSP extension. Separate threshold can be set for dna or protein comparisons.
  • --dnahspthreshold <score> --proteinhspthreshold <score> --codonhspthreshold <score> — The HSP score thresholds. An HSP must score at least this much before it will be reported or be used in preparation of a heuristic alignment.
  • --dnawordlimit <score> --proteinwordlimit <score> --codonwordlimit <score> — The threshold for admitting DNA or protein words into the word neighbourhood. The behaviour of this option is altered by the --useworddropoff option (see above).
  • --geneseed <threshold> — Exclude HSPs from gapped alignment computation which cannot feature in a alignment containing at least one HSP scoring at least this threshold.

This option provides considerable speed up for gapped alignment computation, but may cause some very gap-rich alignments to be missed.

It is useful when aligning similar sequences back onto genome quickly, eg. try --geneseed 250.

  • --geneseedrepeat <count> — The geneseedrepeat parameter is like the seedrepeat parameter, but is only applied when looking for the geneseed hsps. Using a larger value for --geneseedrepeat will speed up searches when the --geneseed parameter is also used. (experimental, implementation incomplete)

🌸 ALIGNMENT OPTIONS 🌸

  • --alignmentwidth <width> — Width of alignment display. The default is 80.
  • --forwardcoordinates <boolean> — By default, all coordinates are reported on the forward strand. Setting this option to false reverts to the old behaviour (pre-0.8.3) whereby alignments on the reverse complement of a sequence are reported using coordinates on the reverse complement.

🎀 SUB-ALIGNMENT REGION OPTIONS 🎀

  • --quality <percent> — This option excludes HSPs from BSDP when their components outside of the SARs fall below this quality threshold.

🦋 SPLICE SITE PREDICTION OPTIONS 🦋

  • --splice3 <path> --splice5 <path> — Provide a file containing a custom PSSM (position specific score matrix) for prediction of the intron splice sites.

The file format for splice data is simple: lines beginning with # are comments, a line containing just the word splice denotes the position of the splice site, and the other lines show the observed relative frequencies of the bases flanking the splice sites in the chosen organism (in ACGT order).

Example 5' splice data file:

# start of example 5' splice data
# A C G T
28 40  17  14
59 14  13  14
 8  5  81   6
splice
 0  0 100   0
 0  0   0 100
54  2  42   2
74  8  11   8
 5  6  85   4
16 18  21  45
# end of test 5' splice data

Example 3' splice data file:

# start of example 3' splice data
# A C G T
 10  31  14  44
  8  36  14  43
  6  34  12  48
  6  34   8  52
  9  37   9  45
  9  38  10  44
  8  44   9  40
  9  41   8  41
  6  44   6  45
  6  40   6  48
 23  28  26  23
  2  79   1  18
100   0   0   0
  0   0 100   0
splice
 28  14  47  11
# end of example 3' splice data
  • --forcegtag <boolean> — Only allow splice sites at gt....ag sites (or ct....ac sites when the gene is reversed) With this restriction in place, the splice site prediction scores are still used and allow tie breaking when there is more than one possible splice site.

⚡ STRATEGIES FOR SPEED ⚡

  • Keep all data on local disks.
  • Apply the highest acceptable score thresholds using a combination of --score, --percent and --bestn.
  • Repeat mask and dust the genomic (target) sequence. (Softmask these sequences and use --softmasktarget).
  • Increase the --fsmmemory option to allow more query multiplexing.
  • Increase the value for --seedrepeat
  • When using an alignment model containing introns, set --geneseed as high as possible.
  • If you are compiling exonerate yourself, see the README file supplied with the source code for details of compile-time optimisations.

🌈 STRATEGIES FOR SENSITIVITY 🌈

Not documented yet.

Increase the word neighbourhood. Decrease the HSP threshold. Increase the SAR ranges. Run exhaustively.

💜 ENVIRONMENT 💜

Not documented yet.

👑 EXAMPLES 👑

  • exonerate cdna.fasta genomic.fasta — This simplest way in which exonerate may be used. By default, an ungapped alignment model will be used.
  • exonerate --exhaustive y --model est2genome cdna.fasta genomic.masked.fasta — Exhaustively align cdnas to genomic sequence. This will be much, much slower, but more accurate. This option causes exonerate to behave like EST_GENOME.
  • exonerate --exhaustive --model affine:local query.fasta target.fasta — If the affine:local model is used with exhaustive alignment, you have the Smith-Waterman algorithm.
  • exonerate --exhaustive --model affine:global protein.fasta protein.fasta — Switch to a global model, and you have Needleman-Wunsch.
  • exonerate --wordthreshold 1 --gapped no --showhsp yes protein.fasta genome.fasta — Generate ungapped Protein:DNA alignments
  • exonerate --model coding2coding --score 1000 --bigseq yes --proteinhspthreshold 90 chr21.fa chr22.fa — Perform quick-and-dirty translated pairwise alignment of two very large DNA sequences.

Many similar combinations should work. Try them out.

⭐ VERSION ⭐

This documentation accompanies version 2.2.0 of the exonerate package.

✨ AUTHOR ✨

Guy St.C. Slater. <guy@ebi.ac.uk>.

See the AUTHORS file accompanying the source code for a list of contributors.

💖 AVAILABILITY 💖

This source code for the exonerate package is available under the terms of the GNU general public licence.

Please see the file COPYING which was distrubuted with this package, or http://www.gnu.org/licenses/gpl.txt for details.

This package has been developed as part of the ensembl project. Please see http://www.ensembl.org/ for more information.

🎀 SEE ALSO 🎀

exonerate-server(1), ipcress(1), blast(1L).

And that's the whole page, bestie! This manual page is from exonerate version 2.2.0, dated November 2002, and it's exonerate(1) through and through. Go slay some alignments. 💅✨🦋

📦 where this page comes from