PSSweb is a web server for protein structural statistics. It takes as input an ensemble of PDB files of protein structures, performs a multiple sequence alignment and computes structural statistics for each position of the alignment. Different optional functionalities are proposed: structure superposition, Cartesian coordinate statistics, dihedral angle calculation and statistics, and a cluster analysis based on dihedral angles. An interactive report is generated, containing a summary of the results, tables, figures and 3D visualization of superposed structures. The server is available at  As the number of available protein structures continues to increase , it is bhttp://pssweb.org), a web server for protein structural statistics. Given a set of protein structures, PSSweb automatically performs multiple sequence alignment, structure superposition, calculates Cartesian and dihedral coordinate statistics and performs cluster analysis. Results are presented in an HTML report containing a convenient summary with interactive figures and tables, as well as 3D visualization of superposed structures. PSSweb is based on PSS  and paper  and ‘*’, respectively. A blank chain identifier is entered as ‘_’. If the basename has the format of a PDB code, an attempt is made to download the file from the PDB server. It is also possible to upload custom PDB files or ZIP of PDB files. Only standard PDB ATOM records are treated by PSSweb. When an atom has alternate locations, only the first one is considered. Only the first model of nuclear magnetic resonance (NMR) PDB files is read.It is sometimes of interest to focus the analysis on a specific subset of amino acid positions. To provide for this option, a list of positions can be entered. The Position list restricts the list of amino acid positions and structural variables of interest for certain analyses. Each entry consists of number ranges determining which positions are included in the cluster analysis and in dihedral distribution plots, and of dihedral angles to be included in clustering. The reference for position numbering is the multiple sequence alignment.Obtaining a multiple alignment of input protein sequences is an essential first step in the PSSweb workflow. PSSweb is indeed meant to analyze ensembles of proteins with similar, but different sequences and it is necessary for subsequent analyses to establish a correspondence between amino acid positions of the different sequences. We note that some structural alignment methods do not require a sequence alignment as input. We propose four different approaches to multiple sequence alignment: PDB numbering, sequence alignment with Clustal Omega, sequence and sequence/structure alignment with MODELLER. The simplest method consists of deriving the multiple sequence alignment from PDB numbering. It is assumed in this case that residues are numbered in a consistent way. The advantage is speed and no risk of error in the alignment, in particular at gap borders. If the numbering is not coherent, this method will give unreliable results and so proper checking should be performed when using PDB numbering. The Clustal Omega program  is a fasSuperposition of structures can be performed with the Theseus program  or with Structural statistics can be computed from Cartesian coordinates. It is assumed that structures have been previously superposed. Figures of root mean square fluctuations of Cartesian coordinates and average B-factors, for backbone or sidechain atoms, as a function of the alignment position are prepared. These figures are superposed by default, to ease comparison, each plot can be hidden/displayed. In addition, a sortable and scrollable table containing the data is provided. The Cartesian analysis provides a characterization of structural variations in the protein set along the sequence, allowing the identification of the most flexible and rigid regions. Note that the B-factor field may be used to store other quantities, in particular in NMR structures.1, χ2, χ3 and χ4 dihedral angle standard deviations as a function of the alignment position are prepared. Additionally, Ramachandran (ϕ/ψ), χ1/χ2 and individual dihedral angle distribution plots are prepared for each alignment position defined in the Position list. If different families were defined in the Structure list, different colors are used to distinguish points belonging to each family. Displaying the distribution plots of many positions can produce a substantial HTML page. Note that the backbone dihedral angle ϕ is not defined at the N-terminal side of contiguous residues, while ψ and ω are not defined at the C-terminal side. The dihedral coordinates have an internal nature and are thus not affected by structure superposition. The dihedral analysis provides similar but complementary information to the Cartesian analysis  –15 (see http://pssweb.org) for protein structural statistics was presented. PSSweb takes as input an ensemble of PDB files of protein structures, performs a multiple sequence alignment and proposes different optional functionalities: structure superposition, structural statistics in both Cartesian and dihedral coordinates and cluster analysis. The results are presented in an interactive HTML page, containing figures, tables, 3D visualization of superposed structures and access to raw data. PSSweb is based on the already published PSS program (The PSSweb server ( program . The web


It is released under a BSD open-source license.When computing alignments of DNA sequences to a large genome, a key element in achieving high processing throughput is to prioritize locations in the genome where high-scoring mappings might be expected. We formulated this task as a series of list-processing operations that can be efficiently performed on graphics processing unit (GPU) hardware.We followed this approach in implementing a read aligner called Arioc that uses GPU-based parallel sort and reduction techniques to identify high-priority locations where potential alignments may be found. We then carried out a read-by-read comparison of Arioc’s reported alignments with the alignments found by several leading read aligners. With simulated reads, Arioc has comparable or better accuracy than the other read aligners we tested. With human sequencing reads, Arioc demonstrates significantly greater throughput than the other aligners we evaluated across a wide range of sensitivity settings. The Arioc software is available at  The cost and throughput of DNA sequencing have improved rapidly in the past several years , with reTo address this need, a number of attempts have been made to develop read-alignment software that exploits the parallel processing capability of general-purpose graphics processing units, or GPUs. GPUs are video display devices whose hardware and system-software architecture support their use not only for graphics applications but also for general purpose computing. They are well-suited to software implementations where computations on many thousands of data items can be carried out independently in parallel. This characteristic has inspired a number of attempts to develop high-throughput read aligners that use GPU acceleration.Experience has shown, however, that it is not easy to build useful GPU-based read alignment software. In general, GPU hardware is perceived as being impractical from a software-engineering standpoint for the task of computing read alignments . This imIn practice, software running on GPU hardware is constrained by a variety of algorithmic and software-engineering considerations. GPU programming requires software to manage single-instruction multiple-data (SIMD) threading, but efficient handling of memory  also requires a great deal of attention. Such threading and memory-management constraints lead to realistic GPU-based speed improvements on the order of 10×–100× .The salient problem in engineering a GPU-accelerated read aligner is that the most biologically relevant sequence-alignment algorithm  is not o9 nt or longer) reference sequence. Since a brute-force search for all plausible alignments in this setting would be computationally intractable, read aligners typically construct a “search space” (a list of reference-sequence locations) within which potential alignments might be discovered. This aspect of the sequence alignment problem accounts for a significant proportion of the computational effort involved in read alignment.There is, however, another significant barrier to the implementation of high-throughput GPU-based alignment software. In a typical pairwise sequence alignment problem, a short (100 to 250 nt) query sequence, or “read,” must be aligned with a comparatively long  extracted from the query sequence matches the same-length subsequence in the reference . The aliMost seed sequences occur rarely in the human reference genome, but a few seed sequences inevitably occur at hundreds or thousands of different locations in the reference sequence. This is not only because certain portions of the reference are internally repetitive  but also because short sequences occasionally occur at two or more non-overlapping positions in the reference genome . This can be illustrated for the human reference genome by plotting the frequency with which 20mers (20 nt subsequences) occur .Although the mean frequency of human 20mers is only 10.7, high-frequency 20mers account for a disproportionate percentage of reference-sequence locations in a lookup table. For example, only 0.1% of the 20mers in the human reference genome appear in 200 or more different locations, but they account for about 10% of the 20mers in the reference sequence. In contrast, 71.7% of the 20mers in the human genome occur exactly once.For a read aligner that implements a seed-and-extend strategy, this long-tailed distribution of seed frequencies is a computational obstacle for reads that contain one or more “high-frequency” seeds. To avoid searching for potential alignments at an inordinate number of locations in the reference sequence, an aligner must limit the number of locations at which it computes alignments for reads that contain such seeds.Read aligners address this problem by using several heuristics, all of which limit the number of potential alignments computed:•Limit the number of high-scoring mappings reported per read.•Limit the number of seeds examined per read.•Limit the number of reference locations examined per seed.These heuristics trade throughput for sensitivity. An aligner spends less time computing potential alignments simply because it does not examine the entire search space . For the same reason, however, the aligner is less likely to identify all of the high-scoring mappings for each read. The Arioc aligner implements two different heuristics to mitigate this problem.Arioc uses hash tables in which every location in the reference sequence is sampled. For highly repetitive regions of the human genome, however, adjacent and overlapping 20mers in the reference sequence hash to a large number of locations in the reference sequence. Repetitive regions are thus associated with long hash-table lists (“big buckets”) because the 20mers corresponding to those lists refer to numerous repetitive regions elsewhere in the reference.For this reason, the Arioc lookup tables are constructed by sampling adjacent “big bucket” hash-table lists in repetitive regions so that only one such list in 10 contains a reference-sequence location that lies within the region . This saAt run time, Arioc implements a heuristic that prioritizes alignments where a read contains two or more seeds that map to adjacent or nearby locations in the reference. This heuristic is reminiscent of the “spanning set” method used to compute alignments in the GSNAP aligner , but itsArioc uses an additional heuristic in the case of paired-end reads. The aligner prioritizes potential paired-end mappings where a reference location associated with at least one seed in one of the mates in the pair lies within a user-configurable distance and orientation of at least one seed in the other mate in the pair.Notably, these heuristics are implemented using a series of sorting and reduction operations on an aggregated list of seed locations. In a CPU-based implementation, the amount of computation required for these operations would be impractical with a reference genome the size of the human genome. In a GPU-based implementation, however, these list-based operations can be performed efficiently with a combination of cooperative parallel threading  and task parallelism . For example, an NVidia GTX480 GPU can sort over 300 million 64-bit integer values per second.The Arioc aligner was designed to evaluate the performance of these “GPU-friendly” heuristics. In effect, Arioc implements a pipeline in which the following operations are performed on GPU hardware for each read:•Define the “search space” for the read; that is, compute the set of reference locations that correspond to the seeds in the read.•Adjust the reference locations so that they correspond to the location of the seed within the read.•Sort and unduplicate the list of reference locations.•Count the number of seeds that reference each reference location.•For paired-end reads, identify pairs of reference locations that lie within a predefined distance and orientation of each other.•Coalesce adjacent seed locations so that they are covered by a minimum number of alignment computations.•Compute alignments to identify and record high scoring mappings.The Arioc aligner is written in C+ + and compiled for both Windows  and Linux (with the Gnu C+ + compiler). The implementation runs on a user-configurable number of concurrent CPU threads and on one or more NVidia GPUs. The implementation pipeline uses about 30 different CUDA kernels written in C+ +  and about 100 calls to various CUDA Thrust APIs .The development and test computers were each configured with dual 6-core Intel Xeon X5670 CPUs running at 2.93 GHz, so a total of 24 logical threads were available to applications. There was 144 GB of system RAM, of which about 96 GB was available to applications. Each computer was also configured with three NVidia Tesla series GPUs (Kepler K20c), each of which supports 5 GB of on-device “global” memory and 26,624 parallel threads. The internal expansion bus in each machine was PCIe v2.Throughput  was measured only when no other user applications were using the machines so that all CPU, memory, and I/O resources were available. For experiments with simulated data, we used Mason  to generThe Arioc implementation is a pipeline  in whichThe execution of the Arioc pipeline consists of iterative processing of batches of reads (query sequences), where the number of reads in a batch is constrained by the amount of available GPU memory. Within each batch iteration, the GPUs are used for list processing and for the computation of alignments, while CPU threads are used concurrently for scoring, classification, and formatting of alignment results as well as for input and output. GPU code executes concurrently with CPU code wherever possible. For example, the classification, reporting, and final output of the alignment results for a batch overlaps with the beginning of processing of the subsequent batch.The nongapped aligner uses periodic spaced seeds (gapped q-grams) to identify potential mappings. The seed pattern covers 84 adjacent positions with 30 “care” positions using the repeating 7-bit pattern 0010111; it is fully sensitive for nongapped alignments containing up to two mismatches when it is evaluated at seven adjacent locations in a sequence . Both thFor each of the first seven positions in each query sequence, the result of the bitwise AND between the seed value and the query sequence is packed into a 30-bit value that is used to probe a lookup table of potential alignment locations in the reference sequence. For each such location, mappings between the query sequence and the reference sequence are identified by bitwise comparison of the entire query sequence with the corresponding reference.Nongapped mappings with mismatches near one or both ends are examined for potential soft clipping. Arioc soft-clips a nongapped mapping whenever its alignment score is higher than it would be without soft clipping. The nongapped aligner assigns a numerical score to each mapping by applying the user-specified parameters for Smith–Waterman–Gotoh affine-gap alignment.Arioc only performs gapped alignment with reads for which it does not find a sufficient number of nongapped alignments. The minimum number of satisfactory nongapped alignments required for a read to be excluded from further processing is a user-configurable parameter.The gapped aligner is a straightforward implementation of the seed-and-extend strategy. To facilitate parallel computation, multiple seed locations are examined concurrently within each read. Groups of seed locations are selected iteratively. The first group of seeds is chosen so as to cover the entire read without overlapping seeds; subsequent groups are selected so as to straddle the seed positions examined in previous groups .In each iteration, the seed subsequences are extracted from the read and hashed to 30 bits using MurmurHash3 . The 30-Each iteration examines seed locations that straddle the locations that were processed in previous iterations; seeds are chosen at locations that are halfway between those examined in all previous iterations. (This is similar to the behavior of Bowtie 2’s -R option.) In this way the cumulative number of seeds examined doubles with each iteration, but the actual number of reference locations considered remains relatively stable. With fixed-length 20 nt seeds (20mers), six “seed iterations” are required to examine every seed location in the query sequence.To associate seeds with reference-sequence locations, Arioc uses two pairs of lookup tables, one pair for nongapped alignment and the other for gapped alignment. Each pair of lookup tables comprises an H table with one element for each possible hash value and a J table that contains reference-sequence locations. Each table lookup is a two-step process: a read from the H table (to obtain an offset into the J table) followed by reading a list of reference-sequence locations from the J table.To facilitate GPU-based list operations, the Arioc implementation encodes reference locations as 64-bit bitmapped values that can be represented in one-dimensional arrays. These arrays are maintained exclusively in GPU device memory where multiple CUDA kernels can access them. CUDA kernels are used to reorganize and triage reference-location lists:•Prioritize reference locations that lie within paired-end distance and orientation constraints.•Prioritize reference locations where overlapping and adjacent seeds cover the largest number of adjacent positions in the reference sequence.•Exclude reference locations that have been examined in previous seed iterations.•Identify reference locations for which acceptable mappings exist and for which criteria for paired-end mapping are met.10(p), where p is the aligner’s estimate of the probability that the read is not mapped to the correct reference location. Arioc estimates p using a computational model based on a probabilistic analysis of different types of mapping errors , Arioc breaks the batch into smaller sub-batches and processes the sub-batches iteratively.Arioc also uses about 65 GB of page-locked, GPU-addressable host-system memory for its lookup tables. Data transfers from this memory are slow because they move across the PCIe bus, but the data-transfer rate is acceptable because comparatively little data is transferred during hash-table lookups.The Arioc implementation pays particular attention to the layout of data in GPU memory. Memory reads and writes are “coalesced” so that data elements accessed by adjacent groups of GPU threads are laid out in adjacent locations in memory. Arioc therefore uses one-dimensional arrays of data to store the data elements accessed by multiple GPU threads. Although this style of in-memory data storage leads to somewhat opaque-looking code, the improvement in the speed of GPU code is noticeable (sometimes by a factor of two or more).Although data can theoretically move between CPU and GPU memory at speeds determined by the PCIe bus, experience has shown that application throughput is decreased when large amounts of data are moved to and from the GPU. For this reason, Arioc maintains as much data as possible in GPU memory. Data is transferred to the CPU only when all GPU-based processing is complete.Divergent flow of control in adjacent GPU threads can result in slower code execution. Branching logic is therefore kept to a minimum in GPU code in Arioc. Although this problem was encountered in previous GPU sequence-aligner implementations , it is eWe used the human reference genome release 37  for thro•Bowtie 2  (CPU)•BWA-MEM  (CPU)•SOAP3-dp  (GPU)•NVBIO  (GPU)We parsed the SAM-formatted output  from eacWe used simulated (Mason) reads to evaluate sensitivity for both paired-end and unpaired reads. For each aligner, we used high “effort” parameters so as to maximally favor sensitivity over throughput. For each read mapped by each aligner, we compared the POS and CIGAR information reported by the aligner with the POS and CIGAR generated by Mason. We assumed that a read was correctly mapped when, after accounting for soft clipping, one or both of its ends mapped within 3 nt of the mapping generated by Mason.  for eachWe used the YanHuang data to measure throughput using both paired-end and unpaired reads. For this analysis, we recorded throughput across a range of “effort” parameters chosen so as to trade speed for sensitivity. We defined “sensitivity” as the percentage of reads reported as mapped by each aligner with alignment score  within configured limits.Prior to computing alignments, all of the GPU-aware aligners spend a brief period of execution time initializing static data structures in GPU device memory. We excluded this startup time from throughput calculations for these aligners.Each of the read aligners we tested is able to map tens of millions of reads to the human genome in an acceptably short period of time. All of the aligners, including Arioc, were capable of mapping simulated reads with high accuracy. With sequencer reads, Arioc demonstrated up to 10 times higher throughput across a wide range of sensitivity settings.With simulated Illumina read data, Arioc mapped paired-end reads to their correct origin in the reference genome with sensitivity and specificity comparable to all four of the aligners to which we compared it –S8. AlthWe used experimental data from the YanHuang human genome project to evaluate speed . Across With this data, throughput decreases with increasing sensitivity for all of the aligners, with a steep decrease near each aligner’s maximum sensitivity. This is apparent even with BWA-MEM and SOAP3-dp, although we were unable to “tune” these aligners across as wide a range of sensitivity settings as the others.When executed concurrently on multiple GPUs in a single machine, Arioc’s throughput increases in proportion to the number of GPUs . At loweApart from its potential for high throughput, the Arioc implementation demonstrates that an increase in throughput can be achieved without losing sensitivity. Furthermore, by sacrificing throughput, Arioc can be “pushed” to a comparatively high level of sensitivity.The shape of the speed-versus-sensitivity curves we observed illustrates that read aligners achieve increased sensitivity by exploring a proportionally larger search space per successful mapping. Arioc’s search-space heuristics cause it to find high-scoring mappings  rapidly within a relatively small search space. For reads that do not map with high alignment scores, however, Arioc must explore more seed locations and compute more dynamic programming problems before it can report a satisfactory mapping. For example, in the experiment shown in Arioc explores a significantly larger search space for reads that it cannot align with a comparatively small number of mismatches or gaps. This mitigates the effect of the heuristics that filter the list of potential mapping locations on the reference sequence. In particular, gapped mappings that might be missed in an early seed iteration, when seeds are spaced widely, are detected in later seed iterations. The nature of these heuristics, however, implies that the additional mappings that Arioc finds when it is configured for higher sensitivity are generally lower-scoring mappings.The effect of Arioc’s heuristics on the computation of MAPQ  for a read is difficult to determine. In some cases, Arioc assigns a lower MAPQ (higher probability that the read is incorrectly mapped) simply because it computes alignments in parallel for the read and therefore tends to find more alternative mappings than would a non-parallelized implementation. On the other hand, by excluding many potential reference locations  from its search space, Arioc might incorrectly assign a high MAPQ to a read. In any event, we do not observe any notable difference overall in Arioc’s MAPQ scoring when compared with other aligners.Unlike the Smith–Waterman–Gotoh alignment algorithm, parallel list-management algorithms—in particular, variations of radix sort and of prefix (scan) operations—are amenable to cooperative parallel-threaded implementation. Much of the intermediate processing in the sequence-alignment pipeline is thus well-suited to GPU-based implementation. We exploited this characteristic of the read-alignment process in designing and developing the Arioc software.There are two features in the design and implementation of Arioc that distinguish it from other GPU-based read aligners. First, Arioc embodies a software design that uses the GPU as an “accelerator” in a task-parallel pipeline. CPU threads execute concurrently with GPU threads on independent data wherever possible, with synchronization points only where the GPU has completed processing a set of data. In practice, this means that overall throughput is GPU-bound and thus insensitive to variations in the time spent executing CPU threads .Second, Arioc is the result of a software-engineering approach that emphasizes the reuse of existing code as well as the use of data structures that conform to optimal GPU memory and threading models. In particular, we emphasized data structures that can be represented in one-dimensional arrays of integers as well as list manipulations that involve simple, data-independent numerical operations. In this way we were able to make extensive use of the NVidia Thrust library, a freely-available, well-optimized library implementation of basic parallel operations on GPU hardware. Arioc’s speed derives from its use of the GPU for the kinds of computations for which the cooperative threading model is well-suited .We recognize that direct comparisons in speed between CPU-based and GPU-based software implementations are fraught with difficulties. We attempted to choose comparison hardware that was reasonably similar in terms of cost and availability. As more capable CPU and GPU hardware becomes available, we expect Arioc, like all of the aligners we evaluated, to deliver higher throughput.We also foresee further optimization of Arioc’s implementation. For example, there are newer, faster GPU function libraries that might be used to replace calls to the Thrust APIs. Also, we have not experimented with low-level optimization of our Smith–Waterman–Gotoh GPU implementation . It is lIn an effort to keep up with the increasing amount of sequence data used in clinical and research settings, the usual approach to designing read alignment software has been to focus on increasing throughput. Experience with both CPU-based and GPU-based aligner implementations suggests that the most expeditious way to improve throughput is to add additional computational hardware, that is, to compute read alignments concurrently in multiple threads of execution. In this regard, therefore, GPU hardware is an attractive platform for high-throughput sequence-alignment implementations.Nonetheless, the highly data-parallel nature of GPU hardware makes it difficult to reuse CPU-based techniques in a GPU implementation. A different approach to exploiting GPU parallelism is to use it for computational tasks that are particularly well-suited to the hardware, that are difficult to perform efficiently on sequential CPU threads, and that can improve throughput while maintaining high accuracy. Our results with Arioc demonstrate the validity of this strategy.10.7717/peerj.808/supp-1Supplemental Information 1Click here for additional data file.


Inverse statistical approaches to determine protein structure and function from Multiple Sequence Alignments (MSA) are emerging as powerful tools in computational biology. However the underlying assumptions of the relationship between the inferred effective Potts Hamiltonian and real protein structure and energetics remain untested so far. Here we use lattice protein model (LP) to benchmark those inverse statistical approaches. We build MSA of highly stable sequences in target LP structures, and infer the effective pairwise Potts Hamiltonians from those MSA. We find that inferred Potts Hamiltonians reproduce many important aspects of ‘true’ LP structures and energetics. Careful analysis reveals that effective pairwise couplings in inferred Potts Hamiltonians depend not only on the energetics of the native structure but also on competing folds; in particular, the coupling values reflect both positive design (stabilization of native conformation) and negative design (destabilization of competing folds). In addition to providing detailed structural information, the inferred Potts models used as protein Hamiltonian for design of new sequences are able to generate with high probability completely new sequences with the desired folds, which is not possible using independent-site models. Those are remarkable results as the effective LP Hamiltonians used to generate MSA are not simple pairwise models due to the competition between the folds. Our findings elucidate the reasons for the success of inverse approaches to the modelling of proteins from sequence data, and their limitations. Inverse statistical approaches, modeling pairwise correlations between amino acids in the sequences of homologous proteins across many different organisms, can successfully extract protein structure (contact) information. Here, we benchmark those statistical approaches on exactly solvable models of proteins, folding on a 3D lattice, to assess the reasons underlying their success and their limitations. We show that the inferred parameters (effective pairwise interactions) of the statistical models have clear and quantitative interpretations in terms of positive (favoring the native fold) and negative (disfavoring competing folds) protein sequence design. New sequences randomly drawn from the statistical models are likely to fold into the native structures when effective pairwise interactions are accurately inferred, a performance which cannot be achieved with independent-site models. Prediction of protein structure from sequence remains a major goal of computational structural biology with significant practical implications. While great progress was achieved in de novo prediction of structures and even direct folding of smaller globular water soluble proteins , 2, strui.e. their probability of appearing in an MSA. This approach is similar in spirit to the derivation of Gibbs distribution in Statistical Mechanics, with an effective Hamiltonian constructed to reproduce single-site amino-acid frequencies and pairwise amino-acid correlations. As such, the effective Hamiltonian is a Potts model β(<1). Parameter β plays the role of an inverse algorithmic temperature that sets the stringency of sequence selection in the sampling MC procedure. The corresponding effective Hamiltonian,ai, but also contributions coming from all the other folds S′ in We generate a multi-sequence alignment (MSA) for the native fold, say, lis rule . The simβ = 103, which ensures that sequences fold in the native structure S with probability 0.995 or larger and that thermalization is fast  is < 1,000 MC steps. The MSA is then made of the sequences Aτ, with τ = 1, …, M = 50,000, generated at regular intervals of 1,000 steps. Each sequence Aτ is therefore drawn according to the equilibrium measure equal to Pnat(S|Aτ)β, up to a multiplicative normalisation factor.In practice we choose Fig A in . A conseAwt), where w is an arbitrary cut-off. The effective number of sequences is w = 0 and ωτ = 1), except for the biased sampling case, where some results were obtained with cut-off w = 0.2, see We compute the one- and two-point amino-acid empirical frequencies computed from the sequences q = 20-state variables, whose energy is given byL × q fields, h = {ih(a)}, and of L(L − 1)/2 × q2 couplings, J = {ijJ}, are chosen so that the frequencies computed from the Potts model distribution reproduce those of the data, We consider the maximum entropy (least constrained ) distribJ is approximated as minus the pseudo-inverse of the connected correlation matrix c, with entries cij = fij − fi(a)fj(b). Data are regularized through the introduction of a large pseudocount . A large regularization L2-penalty, γ = 0.01, was considered during the inference  [k is the fraction of the top k scores whose corresponding pairs of sites  are in contact.Computation of the Potts couplings e scores  (with the scores )Fij(APC)fj(b))]  (and areS|Snat) between structure S and the native fold Snat throughA in a MSA of Snat. The distributions of gaps for Snat = SA, SB, SC, SD are shown in Fig G in Snat is defined as the structure S minimizing Δ(S|Snat), see NS of competitor folds and their typical gap Δ with the native structure Snat through We define the gap Δ(S1 Text(PDF)Click here for additional data file.S1 CodeSee readme.txt file.(ZIP)Click here for additional data file.S2 CodeSee readme.txt file.(ZIP)Click here for additional data file.S3 CodeSee readme.txt file.(ZIP)Click here for additional data file.


They are formed when three or more helices come together in three-dimensional space. Recent studies have focused on the annotation and prediction of coaxial helical stacking (CHS) motifs within junctions. Here we exploit such predictions to develop an efficient alignment tool to handle RNA secondary structures with CHS motifs. Specifically, we build upon our Junction-Explorer software for predicting coaxial stacking and RNAJAG for modelling junction topologies as tree graphs to incorporate constrained tree matching and dynamic programming algorithms into a new method, called CHSalign, for aligning the secondary structures of RNA molecules containing CHS motifs. Thus, CHSalign is intended to be an efficient alignment tool for RNAs containing similar junctions. Experimental results based on thousands of alignments demonstrate that CHSalign can align two RNA secondary structures containing CHS motifs more accurately than other RNA secondary structure alignment tools. CHSalign yields a high score when aligning two RNA secondary structures with similar CHS motifs or helical arrangement patterns, and a low score otherwise. This new method has been implemented in a web server, and the program is also made freely available, at  RNA secondary structures are composed of double-stranded segments such as helices connected to single-stranded regions such as junctions and hairpin loops. These structural elements serve as building blocks in the design of diverse RNA molecules with various functions in the cell –3. In paArabidopsis has an important functional role  denotes the base at position i of Rseq ordered from the 5’ to 3’ ends. Rseq, i < j, is the subsequence starting at position i and ending at position j. Let R be the 2D structure of Rseq with at least one base pair. A helix in R is a double-stranded segment composed of contiguous base pairs. A base pair connecting position i and position j is denoted by  and its enclosed subsequence is Rseq. If all nucleotides in Rseq except Rseq[i] and Rseq[j] are unpaired single bases, and  is a base pair in R, we call Rseq a hairpin loop.Let n-way junction in R has n branches. This junction connects n helices where there are n base pairs …  (one base pair for each helix), and n subsequences participating in the junction. The n subsequences are denoted by Rseq, Rseq, Rseq,…, Rseq, and Rseq. All the unpaired bases on the n subsequences comprise the n-way junction, and the subsequences are called the loop regions of the junction. Internal loops or bulges can be considered as special cases of “two-way” junctions  to represent the node of tree T whose position in the left-to-right post-order traversal of T is i. The post-order procedure works by first traversing the left subtree, then traversing the right subtree, and finally visiting the root. In n-way junction consists of n– 1 children. The first helix according to the 5′ to 3′ orientation is the parent node of the junction node. The other n– 1 helices are the children of that junction node. The number of children of node t[i] is the degree of t[i]. In 1 is the parent node of J1, which has two children, H2 and H3. The degree of the junction node J1 is 2. In general, the degree of an n-way junction node is n– 1.We use R1 and R2 and their tree representations T1 and T2 respectively. Let t1[i]  be the node of T1  whose position in the post-order traversal of T1  is i . Let T1[i] be the subtree rooted at t1[i], and T2[j] be the subtree rooted at t2[j]. F1[i] represents the forest obtained by removing the root t1[i] from subtree T1[i]. F2[j] represents the forest obtained by removing the root t2[j] from subtree T2[j]. Suppose the degree of t1[i] is mi  to represent the alignment score of subtree T1[i] and subtree T2[j], and use γ to represent the alignment score of node t1[i] and node t2[j]. We use ∅ to represent an empty node; matching a tree node with ∅ amounts to aligning all nucleotides in the tree node to gaps.Consider two RNA 2D structures T1[i] and T2[j] and calculating the score S, there are nine cases to be considered.We employ a dynamic programming algorithm to align two RNA 2D structures with coaxial stacking patterns. Our approach is to transform each RNA 2D structure into an ordered labeled tree as explained in the previous subsection. We then apply the dynamic programming algorithm to the ordered labeled trees representing the two RNA 2D structures. Based on the alignment of the trees, we obtain the alignment of the corresponding RNA 2D structures. As noted above, each tree node belongs to one of three types: helix, junction, and hairpin loop. Different types of tree nodes are prohibited to be aligned with each other. When aligning two subtrees Case 1. Both t1[i] and t2[j] are junctions.v1 must be the same as the coaxial stacking status of v2. Thus, a three-way junction must be aligned with a three-way junction, which is not allowed to align with a four-way junction. Furthermore, a three-way junction whose coaxial helical stacking status is H1H2 must be aligned with a three-way junction having the same H1H2 status, which is not allowed to align with a three-way junction whose coaxial helical stacking status is H2H3. In general, junctions with different branches and different coaxial stacking configurations have different biological properties. This constraint is established to ensure a biologically meaningful alignment is obtained, and to avoid introducing too many gaps in the alignment.One constraint we impose on pairwise alignment is that when aligning a p-way junction node v1 with a q-way junction node v2, p must be equal to q. Furthermore, the coaxial helical stacking status of t1[i] must be aligned with t2[j] provided they have the same number of branches and the same coaxial helical stacking status, denoted by Ψ(t1[i]) = Ψ(t2[j]). Their children are trees, which together form forests F1[i] and F2[j] respectively. F1[i] must be aligned with F2[j]. Thus the alignment score of T1[i] and T2[j] can be calculated as:According to our tree model, if a tree node is a junction, it must have at least two children and the children must be helix nodes. A junction contains loop regions with single bases whereas helices are double-stranded regions with base pairs. A junction node is thus prohibited to be aligned with a helix node. Hence, t1[i]) = Ψ(t2[j]), t1[i] and t2[j] must have the same number of children, and the order among the sibling nodes is important. If Ψ(t1[i]) ≠ Ψ(t2[j]), i.e., t1[i] and t2[j] have different numbers of children (branches) or they have different coaxial helical stacking statuses, they are prohibited to be aligned together. Thus, the score of matching F1[i] with F2[j] can be calculated as:m is the number of children of t1[i] and t2[j] respectively. We use Π(t1[i]) to represent the coaxial helical stacking status of t1[i]; Π(t1[i]) = 1  if the coaxial helical stacking status of t1[i] is H1H2 . The score of matching t1[i] with t2[j] iss is the score obtained by aligning the junction in t1[i] with the junction in t2[j]. We use a dynamic programming algorithm  and t2[j] have the same number of branches, their CHS patterns are alike, and Π(t1[i])≠0, Π(t2[j])≠0, we use s+w as the modified alignment score. When t1[i] and t2[j] have the same number of branches and Π(t1[i]) = Π(t2[j]) = 0, we use s+(w/2) as the modified score. The value of w required experimentation, as we discuss later, but a value of 100 seems to work well in practice.If Ψ. Therefore, the alignment score of T1[i] and T2[j] can be calculated as:Due to the nature of RNA 2D structures and based on our tree model, a helix has only one child, which is either a junction or a hairpin loop. The subtree rooted at the child of t1[i], t2[j]) is obtained by aligning the helix in t1[i] with the helix in t2[j] using a dynamic programming algorithm [The score γ is obtained by aligning the hairpin loop in t1[i] with the hairpin loop in t2[j] using a dynamic programming algorithm [The score γ is calculated by taking the maximum of the two subcases illustrated in Case 5.t1[i] is a junction and t2[j] is a hairpin loop.t1[i] and t2[j] have different types, the two nodes cannot be aligned together. Furthermore, t2[j] is a hairpin loop, which does not have any child. Thus t1[i] must be aligned to gaps, and the subtree rooted at one of the children of t1[i] is aligned with T2[j]; specifically the subtree yielding the maximum alignment score is aligned with T2[j]. Therefore, the alignment score of T1[i] and T2[j] can be calculated as:Since Case 6.t1[i] is a helix and t2[j] is a junction.Similar to Case 4, there are two subcases.ti[i] is aligned to gaps. Thus, the subtree rooted at the child of t1[i], denoted by T1[i—1], must be aligned with T2[j].Subcase 1. t2[j] is aligned to gaps. Suppose t2[j] has nj children T1[i] must be aligned with one of these subtrees.Subcase 2. T1[i] with T2[j] as:Taking the maximum of these two subcases, we calculate the score of matching Case 7.t1[i] is a helix and t2[j] is a hairpin loop.t1[i] and t2[j] have different types, the two nodes cannot be aligned together. Furthermore, since t1[i] is a helix, it has only one child; t2[j] is a hairpin loop with no children. Therefore, t1[i] must be aligned to gaps and the subtree rooted at the child of t1[i], denoted by T1[i—1], must be aligned with T2[j], or if the alignment yields a negative score, we use the value 0. Thus, the alignment score isBecause Case 8.t1[i] is a hairpin loop and t2[j] is a junction.T1[i] with T2[j] as:This is similar to Case 5. Thus, we can calculate the score of matching Case 9.t1[i] is a hairpin loop and t2[j] is a helix.This is similar to Case 7, with the alignment score:T1| (|T2| respectively) denote the number of nodes in tree T1 (T2 respectively) that represents RNA structure R1 (R2 respectively). CHSalign maintains a two-dimensional table in which c represents the cell located at the intersection of the ith row and the jth column of the table. The value stored in the cell c, 1 ≤ i ≤ |T1|, 1 ≤ j ≤ |T2|, is S. The dynamic programming algorithm employed by CHSalign calculates the values in the table by traversing the trees T1 and T2 in a bottom-up manner. After all the values in the table are computed, the algorithm locates the cell c with the maximum value. A backtrack procedure starting with the cell c and terminating when encountering a zero identifies the alignment lines of an optimal alignment and calculates the alignment score between T1 and T2.Let |R1| (|R2| respectively) denote the number of nucleotides, i.e., the length, of RNA structure R1 (R2 respectively). Let |t1[i]| (|t2[j]| respectively) be the number of nucleotides in node t1[i] (t2[j] respectively). Let d1  be the maximum degree of any node in tree T1 (T2 respectively). The time complexity of computing γ is O(|t1[i]|×|t2[j]|) [S is O+|t1[i]|×|t2[j]|). Here max is a constant because a junction has at most twelve branches in solved RNA crystal structures [Let ||t2[j]|) . Thus, tructures ,25,52. Fc with the maximum value in the two-dimensional table and executing the backtrack procedure require O(|R1|×|R2|). Since only a two-dimensional table is used, the space complexity of CHSalign is O(|T1|×|T2|) = O(|R1|×|R2|).Locating the cell Popular benchmark datasets such as BRAliBase  and Rfam1H2, H2H3, H1H3. Thus, every three-way junction in Dataset2 contains a coaxial stacking pattern. In the RNA literature, most research efforts have been focused on three-way and four-way junctions [The second dataset, Dataset2, contains 76 three-way junctions extracted from the 24 3D structures in Dataset1.  The lengths of the three-way junctions range from 28nt to 153nt. The coaxial helical stacking status of each three-way junction in Dataset2 is described as one of three possibilities: Hunctions –62 partlWe have implemented two programs in Java, a standalone version denoted by CHSalign_u, and the other a pipeline denoted by CHSalign_p. CHSalign_u requires the user to manually annotate the coaxial stacking patterns within junctions of the pair of RNA 2D structures in the input, and produces an optimal alignment between the two input structures.By contrast, CHSalign_p accepts as input two unannotated RNA 2D structures and produces as output an optimal alignment between the two input structures while taking into account their junctions and coaxial stacking configurations within the junctions. This pipeline invokes our previously developed Junction-Explorer tool  to autom1H2, H2H3, or H1H3. We performed pairwise alignment of junctions in each subset. There are  pairwise alignments produced by CHSalign. Commonly used ways for evaluating the accuracy of these structural alignments include the calculation of distance matrices or RMSD (root-mean-square deviation) [We conducted a series of experiments to evaluate the performance of our algorithms. In the first experiment, we divided Dataset2 into three disjoint subsets Dataset2-1, Dataset2-2 and Dataset2-3, with 35, 18, and 23 junctions, respectively. These three subsets contain, respectively, three-way junctions whose coaxial helical stacking status is Hviation) ,32,63–66viation)  to evaluw used in w is sufficiently large , our algorithms work well. In subsequent experiments, we fixed the weight w in One important parameter in our algorithms is the weight precision as the performance measure, defined below, to evaluate how junctions and coaxial stacking patterns are aligned by different programs using the 24 structures in Dataset1. We say a junction J1 in structure R1 is aligned with a junction J2 in structure R2, or more precisely there is a junction alignment between J1 and J2, if there exist a nucleotide n1 on a loop region of J1 and a nucleotide n2 on a loop region of J2 such that n1 is aligned with n2. A junction alignment between J1 and J2 is a true positive if J1 and J2 have the same number of branches and the same coaxial helical stacking status. A junction alignment between J1 and J2 is a false positive if J1 and J2 have different numbers of branches or different coaxial helical stacking statuses. The precision (PR) of an alignment between R1 and R2 is defined asTP equals the number of true positives and FP equals the number of false positives in the alignment. The higher PR value a program has, the more precise alignment that program produces. In the experiment, we also included a closely related RNA 3D alignment tool (SETTER) [In the next experiment, we adopt (SETTER) .We calculated the precision of each alignment produced by a program, took the average of the precision values of the pairwise alignments of the 24 structures in Dataset1, and plotted the average values. To demonstrate the utility of the CHSalign tool, we applied CHSalign to the analysis of riboswitches that regulate gene expression by selectively binding metabolites . Table 2Without knowledge of junction helical arrangements, we first tested the following cases using CHSalign_p, where the two aligned junctions had the same coaxial stacking patterns. We used SAM riboswitches in different organisms , we obtained a low alignment score of 20.40. We also tested a pair of purine and TPP riboswitches (PDB codes 2G9C and 2GDI), which are in different riboswitch classes and have different coaxial stacking patterns in their three-way junctions. We obtained a low alignment score of 13.65. These experiments suggest that CHSalign_p, based only on secondary structural information, is useful for inferring tertiary structural features regarding helical arrangements.1H3) and the other had coaxial stacking helices 1 and 2 (H1H2). Second, we considered two RNAs with different structures (purine riboswitch with PDB code 2G9C and guanine riboswitch with PDB code 3RKF respectively) but annotated them with the same helical arrangement pattern, namely coaxial stacking helices 1 and 2 (H1H2). Note that this manually annotated H1H2 pattern is different from the H1H3 pattern that naturally occurs, and is also predicted by CHSalign_p, in the purine and guanine riboswitches.Finally, we tested CHSalign_u, which requires prior information about junction arrangement and produces a structural similarity score for two given RNAs. Here, we tested two cases. First, we considered the same RNA structure (purine riboswitch with PDB code 2G9C) but annotated it with different helical arrangement patterns where one had coaxial stacking helices 1 and 3  to unnatural arrangements . In the second case, CHSalign_u produced a high score of 179.68, which indicates the possibility that two different RNA structures can have very similar helical arrangements when we manually set these arrangements. Thus, CHSalign_u could help investigate the structural diversity of all possible helical arrangements, including natural or hypothetical conformations for two RNA 2D structures.In the first case, the score produced by CHSalign_u was very low (36.69), due to the different helical arrangements. This result shows the large conformational range of structural arrangements that the purine riboswitch can have, from naturally preferable arrangements  capable of producing an optimal alignment between two input RNA secondary (2D) structures with coaxial helical stacking (CHS), based on our previously developed Junction-Explorer  and RNAJIt has been observed that several functional RNA families such as tRNA, RNase P, and large ribosomal subunits have conserved structural features while having very diverse sequence patterns. RNA structure alignment tools such as CHSalign can help measure the structural similarity between these RNAs, even without sequence relevance in the RNAs. Similar RNA structural motifs are encountered on a variety of RNAs. While these motifs exist in different contexts, their functions are related. For instance, sarcin-ricin motifs often bind to proteins, and GNRA tetraloops act as receptors for RNA-RNA long-range interactions. Furthermore, examples of larger structure-function similarity are observed in the tRNA-like structure found in the transfer-messenger RNA (tmRNA), whose structure similarity with tRNA helps identify the functional role of tmRNAs to aid in translation via stalled ribosome rescue. Other tRNA-like structures found in viruses such as HIV and internal ribosome entry sites (IRES) mimic the 3D “L-shape” of tRNAs to take control of the host ribosome.As our knowledge on RNA structure progresses, more sophisticated secondary structure alignment tools are required that allow for comparison of tertiary motifs such as coaxial stacking patterns. Indeed, experimental probing techniques such as RNA SHAPE chemistry, SAXS, NMR, and fluorescence resonance energy transfer (FRET), can often provide sufficient information to determine coaxial helical stacking ,68,69. BCHSalign is the first tool that can compute an RNA secondary structure alignment in the presence of coaxial helical stacking. When coaxial stacking configurations are available from experimental data such as FRET, NMR or SAXS data, the user can input such information to aid in the alignment. However, if no knowledge of coaxial stacking configurations is available, CHSalign can infer this information by employing Junction-Explorer , which pExisting RNA secondary structure alignment tools ,39 do noS1 FileFor each pair of riboswitches, the input and output of the CHSalign_p program are displayed. The input includes two riboswitches in bpseq format. CHSalign_p invokes Junction-Explorer to predict coaxial helical stacking (CHS) motifs in the input molecules, and aligns the predicted structures. The output includes the CPU time spent in performing the alignment, the alignment score and alignment details.(TXT)Click here for additional data file.S2 FileFor each pair of riboswitches, the input and output of the CHSalign_u program are displayed. The input includes two riboswitches in bpseq format along with CHS motifs annotated manually by the user. The output includes the CPU time spent in performing the alignment, the alignment score and alignment details.(TXT)Click here for additional data file.


Resolution of complex repeat structures and rearrangements in the assembly and analysis of large eukaryotic genomes is often aided by a combination of high-throughput sequencing and genome-mapping technologies . In particular, mapping technologies can generate sparse maps of large DNA fragments (150 kilo base pairs (kbp) to 2 Mbp) and thus provide a unique source of information for disambiguating complex rearrangements in cancer genomes. Despite their utility, combining high-throughput sequencing and mapping technologies has been challenging because of the lack of efficient and sensitive map-alignment algorithms for robustly aligning error-prone maps to sequences.We introduce a novel seed-and-extend glocal  alignment method, OPTIMA , which is the first to create indexes for continuous-valued mapping data while accounting for mapping errors. We also present a novel statistical model, agnostic with respect to technology-dependent error rates, for conservatively evaluating the significance of alignments without relying on expensive permutation-based tests.We show that OPTIMA and OPTIMA-Overlap outperform other state-of-the-art approaches (1.6−2 times more sensitive) and are more efficient (170−200 %) and precise in their alignments (nearly 99 % precision). These advantages are independent of the quality of the data, suggesting that our indexing approach and statistical evaluation are robust, provide improved sensitivity and guarantee high precision.The online version of this article (doi:10.1186/s13742-016-0110-0) contains supplementary material, which is available to authorized users. In recent years, the availability of commercial platforms for high-throughput genome mapping  has led to the use of model-based scoring functions for sensitively evaluating alignments [Alignment of maps  to sequignments –15. Thesignments , 16, 17.ignments  are handignments  but tendMap-alignment algorithms are thus faced with the twin challenges of improving sensitivity and precision on the one hand and reducing computational costs for alignment and statistical evaluation on the other hand. An elegant solution to this problem from the field of sequence-to-sequence alignment is the use of a seed-and-extend approach . Howeverin silico) map; and overlap alignment, solved with OPTIMA-Overlap, where the end of one map is aligned to the beginning of another. When benchmarked against state-of-the-art aligners, OPTIMA and OPTIMA-Overlap typically provide a strong boost in sensitivity (1.6–2 times) without sacrificing precision of alignments (∼99 %). Moreover, our pilot implementations exhibited runtime improvements over commercially available tools (two times faster than OpGen’s Gentig) and orders of magnitude over published, freely available algorithms and software [In this work, we describe how a sorted search index and the use of a composite seeding strategy can help to efficiently and sensitively detect seed map-to-sequence alignments . Our secsoftware , 13.Finally, these methods are shown to be robust to variations in error distributions while being agnostic to them, suggesting that the methods can deal with different experimental outcomes of the same technology  as well as being applicable across mapping technologies (with minor modifications for pre-processing of data). Because glocal and overlap alignments form the basis of a range of applications that involve the combination of sequence and mapping data , OPTIMA and OPTIMA-Overlap can serve as building blocks for these applications, allowing for time- and cost-effective analyses.in silico maps through pattern recognition [High-throughput genome mapping technologies typically work by linearizing large molecules of DNA  and usi1ognition .Fig. 1Eo1,o2,…,om be the m ordered fragment sizes of an experimentally derived map o and r1,r2,…,rn be the n fragment sizes of an in silico map r. For simplicity, we suppose here that m≤n and assume that we can derive standard deviations for in silico fragments, that is, σj for rj, in a technology-dependent fashion. In an idealized case, we can define the problem of glocally aligning o to r as a one-to-one correspondence between all the fragments of o with a subset of the fragments of r, that is, rl,rl+1,…,rl+m−1 . In practice, many sources of errors affect experimentally derived maps, including missing cuts, false/extra cuts, missing fragments, fragment sizing errors and spurious maps [In silico maps could also be affected by sequencing or assembly errors [1Let ous maps . In siliy errors , but the errors 1:ok,ok+1,…,os aligned as as a whole entity to a subset of in silico fragments rl,rl+1,…,rt is called a feasible match if and only if: A subset of fragments Cσ=3 is an appropriate bound if sizing errors are approximately normally distributed.where glocal alignment is an ordered set of matches M1,M2,…,Mw between experimental and in silico fragments, such that all the experimental fragments o1,o2,…,om are aligned to a subset of the in silico fragments rt,rt+1,…,rv, and both sets are orderly partitioned by all the matches Mw1… without overlaps, with w≤m and w≤v−t+1.A valid Cσ test , can be handled in this framework by allowing gaps, that is, with the option of ignoring short fragments for the purpose of the test Eq. .overlap alignment is an ordered set of matches M1,M2,…,Mw that allows experimental maps and in silico maps to only partially align with each other, with M1 and Mw each corresponding to an end of one of the maps  and is as follows. We start by indexing the Cσ bound) as matches. However, as mapping data typically have high error rates [c consecutive fragments (c-mer) is likely to have low sensitivity unless we use a naive c=1 approach  the c-mer in silico map;(ii) the c-mer in silico map); and(iii) the c-mer in silico map).c-tuples corresponding to a composite seed, as defined in Definition 4, for each location in the reference map. In addition, to account for false cuts in the experimental map, for each set of consecutive fragments c-tuples of the type Composite seeds (iv) depicted in Fig. The reference index would then contain all mentclass2pt{minimc-tuples are collected and sorted into the same index in lexicographic order by c1 (where the ci are elements in the c-tuple). Lookups can be performed by binary search over fragment-sized intervals that satisfy the Cσ bound for c1 and a subsequent linear scan of the other elements ci, for i≥2, while verifying the Cσ bound in each case. Note that, because seeds are typically expected to be of higher quality, we can apply a more stringent threshold on seed fragment size matches ) per experimental map, where n is the total length of the in silico maps in fragments, m≪n is the length of the experimental map and #seedsc=1 is the number of seeds found in the first level of the index lookup, before narrowing down the list to the actual number of seeds that will be extended (#seeds). The cost and space of creating the reference index is thus O(cn), if the number of errors considered in the composite seeds is limited and bounded (as in Definition 4), and radix sort is used to sort the index. This approach drastically reduces the number of alignments computed in comparison to more general, global alignment searches [Overall, the computational cost of finding seeds using this approach is searches , as willsth experimental fragment with the end of the tth in silico fragment using backtracking to find feasible matches, that is, those that satisfy Eq. #cuterrors= missing cuts + false cuts + missing fragments found), with ties being broken by minimizing a χ2 function for fragment sizing errors: In order to extend a seed to get a glocal alignment we adopt a scoring scheme similar to that used in SOMA (see ). This a1in silico fragments, s−k is the number of false cuts, t−l is the number of missing cuts, Cce is a constant larger than the maximum possible total for χ2, Score0,0=0, Scorei,0=∞ and Scorej0,=∞.where the first index of each subscript represents experimental fragments, the second index represents the in silico fragment is considered as missing if this condition allows for a valid alignment that improves the local χ2 on nearby matches by half (up to three consecutive fragments).Note that a small f fragments (default of five).As in , we bandc-tuple) of an experimental map with m fragments is thus, in the worst case, O((m−c) δ3) time, where δ is the bandwidth of the dynamic programming, and O((m−c)2) space for allocating the dynamic programming matrix for each side of the seed.The computational cost of extending a seed  null model. The assumption here is that there is only one true alignment and that, therefore, the population of these sub-optimal alignments can provide a conservative null model for evaluating the significance of an alignment; more specifically, for each candidate alignment found, we compute its distance from the null model in a feature space (to be defined later) using a Z-score transformation and then use this score to evaluate whether it is optimal, statistically significant and unique  alignments, that are expected to follow the normal distribution  and be comparable between different alignments of the same experimental map, and we compute a Z-score for each feature f∈F and for each candidate solution π∈Π identified through the seeding method. Each Z-score takes into account the mean and standard deviation of a particular feature f among all candidate alignments found: We start by identifying a set fi, with 1≤i≤k and k≥2, the resulting score is given by: Accounting for all considered features si=1 if lower values of feature fi are preferable and −1 otherwise, and the corresponding p-value is pπ=Pnorm(𝜗(π)), that is, the probability that a ‘random’ Z-score will be less than 𝜗(π) under the standard normal distribution.where #matches), the total number of cut errors and the Wilson-Hilferty transformation (WHT) of the χ2 score for sizing errors : In our case, we chose a set of features based on the number of matches  indicate better solutions, while a higher number of matches represents more reliable alignments, we need to adjust the signs of their Z-scores accordingly. The final Z-score 𝜗(π) computed for each candidate solution π is therefore given by: Note that this set can be shown to be composed of approximately independent features for false positive alignments . By the central limit theorem, the mean of the first two features can be approximated by the normal distribution when the number of candidate solutions is large enough , and, by Slutsky’s theorem, their sample variance would not have a significant effect on the distribution of the test statistics. As lower values of p-value pπ. The candidate solution π∗ with the lowest p-value p∗ is reported as the optimal solution, as shown in Fig. which can be subsequently converted into the q-value analysis [q=0.01). To assess uniqueness, we set a threshold on the ratio of p-values between the best solution and the next-best solution (default of five). See Supplementary Note 2 in Additional file The statistical significance of the optimal solution can then be assessed through a false discovery rate analysis  based ona priori.In summary, our statistical scoring approach finds an optimal solution and evaluates its statistical significance and uniqueness in a unified framework, thus allowing for savings in computational time and space compared to a permutation test, without restricting the method to a scenario where experimental error probabilities are known To extend OPTIMA to compute and evaluate overlap alignments – a key step in assembly pipelines that use mapping data , 5, 23 –in silico map, in order to choose the most significant overlap alignments . Each glocal alignment sub-problem will then return either: (i)a significant and unique sub-map alignment;(ii)an alignment labeled as non-significant and/or non-unique ; or(iii)no feasible alignments found.Briefly, for each map, OPTIMA-Overlap first finds optimal sub-map alignments, evaluates their significance and uniqueness, and then tries to extend the candidate alignments found until it reaches the ends of either the experimental map or the see Fig. e. This ap-value  and iterated through to select sub-maps that should be extended. At each stage we check the significance and uniqueness of the reported solutions (compared to the others), as well as checking for potential cases of identical or conflicting alignments as defined below.Optimal solutions to the sub-problems are then ranked by π1 is said to be conflicting with another alignment π2 if either: π1 overlaps the sub-map of π2; orthe sub-map of π1 aligns to the same in silico map as π2, but in a different location or strand.A sub-map alignment in silico maps, but condition (a) could be relaxed in some cases, for example, when experimental maps are known to overlap multiple in silico maps in the same region. Therefore, while iterating through the list of sub-maps, the following rules are implemented: πi is labeled as a false alignment, then we stop iterating through the rest of the list.Significance: if the current solution πi represents the same overlap alignment as a more significant solution; (ii) πi is conflicting with a solution with a lower p-value ; or (iii) πi is not unique with respect to other solutions πj with j>i  that it is conflicting with.Uniqueness: we skip an alignment if either: (i) Extension with dynamic programming: optimal overlap solutions are identified according to Eq. Conflicting alignments can result in ambiguous placement of an experimental map on a database of q-value analysis, as before, to report all alignments with q≤0.01. For the q-value analysis, we consider all candidate solutions found for the sliding windows in order to learn the q-value parameters. In addition, we can reuse the dynamic programming matrix computed for each seed across sub-map alignments and thus complete the overlap alignment with the same asymptotic time and space complexity as the glocal alignment.This approach allows us to report multiple overlap alignments  for an experimental map while using the d, the average restriction enzyme digestion rate; f100, the average false cut rate per 100 kbp; and the fragment sizing errors for predefined (reference) in silico fragment size ranges : d=0.78 (corresponding to missing cut rate of 22 %); f100=0.97; and probability at 0.5 for missing fragments of size below 1.2 kbp, 0.75 below 600 bp and 1 below 350 bp.Easier scenario: d=0.61 (corresponding to missing cut rate of 39 %); f100=1.38; and 0.5 for missing fragments of size below 2 kbp, 0.75 below 800 bp and 1 below 350 bp.Harder scenario: To benchmark OPTIMA and OPTIMA-Overlap against other state-of-the-art map aligners, we first developed synthetic datasets that aim to represent two ends of the spectrum of errors in mapping data for eukaryotic genomes. These scenarios were defined by confidently aligning (using SOMA  and manuin silico maps (possibly creating truncated end fragments). Then we introduce cut errors using the probability distributions described in [d; next, we insert false cuts modeled as a Poisson process with rate f100 ; and finally, we remove small fragments with the probabilities described above. Sizing errors are introduced by sampling from the empirical errors found for each range of reference fragment sizes. Simulated experimental maps smaller than 150 kbp or with fewer than ten fragments are discarded, mimicking the pre-processing stage on the Argus system.For each scenario, we first simulate the map sizes using empirically derived distributions from real maps  and extract the corresponding reference sub-maps by sampling start locations uniformly from the ribed in  with theDrosophila melanogaster (BDGP 5) and Homo sapiens (hg19/GRCh37) genomes using the KpnI restriction pattern GGTAC’C, where the apostrophe indicates the position of the cut, which resulted in 13,920 fragments genome-wide (forward and reverse strands) with an average fragment size (AFS) of 17.3 kbp and 573,276 fragments with AFS = 10.8 kbp, respectively.We generated 100 times greater coverage of maps with errors for the in silico reference genomes. TWIN [OPTIMA was compared against the state-of-the-art algorithms Gentig v.2  , 17, 24,es. TWIN  was not in silico fragments up to 2 kbp, to run only for Cσ=3, to make its results comparable, and by inverting the role of in silico–experimental input maps (v). We omitted SOMA’s statistical test , because it is unfeasible for large datasets [in silico maps, without trimming end fragments or removing any small in silico fragments.We also ran variations of these algorithms from their default options (d): specifically, by providing the true error distribution parameters used in the simulations as input (tp), the adjusted AFS based on the organism under analysis (a) and parameter values published in the respective papers (instead of the software’s default ones), to provide, in addition, the true error distribution rates (p); and by allowing the trimming of map ends in the alignment (t). Moreover, SOMA  was modidatasets , and appDrosophila genome but lower precision on the human genome, with as low as 80 % precision under scenario (B) (with default parameters). Without their computationally expensive statistical tests, which can increase the runtime by a factor of greater than 100, SOMA and the likelihood-based method have much lower precision, particularly on the human genome. In addition, in terms of sensitivity, OPTIMA was found to be notably better than other aligners, even when the true error distribution rates were provided as input to these algorithms. In particular, for the higher quality scenario (A), OPTIMA is more than 1.5 times as sensitive as Gentig, and for the commonly obtained scenario (B), OPTIMA is more than twice as sensitive as Gentig.As can be seen from the results in Table These results are further broken down in Fig. In Table KpnI enzyme and ten map cards in total), and glocally aligned them over the human reference genome. Supplementary Note 4 in Additional file To assess OPTIMA’s performance on real data we generated, in-house, 309,879 and 296,217 optical maps for two human cell lines, GM12878 and HCT116, respectively, using the Argus system from OpGen , 25 (wit(r)relaxed filtering, which filters maps with fewer than ten fragments and smaller than 150 kbp;(s)stringent filtering (as suggested in ), which Tables The statistics were reported independently for each map card to capture the variability in terms of quality. In total, OPTIMA, with a stringent uniqueness threshold of 30, confidently aligned nearly three times as many maps as Gentig (with default parameters) for GM12878. Similarly, for HCT116, OPTIMA results were 1.7 times better than Gentig results, and corresponding improvements were also obtained using the stringently filtered datasets.d, false/extra cut rate f100 and sizing errors were found to be similar to those obtained using scenario (B)  [For overlap alignment, we compared OPTIMA-Overlap with an overlap-finding extension of Gentig v.2  , 24, as XTENDER) .Drosophila (BDGP 5) and human (hg19/GRCh37) genomes. In addition, we simulated assembled sequence fragments for these genomes based on empirically derived scaffold size distributions ; the simulated assemblies were used to generate in silico maps  and (B) from our previously simulated maps for  aligned , 15), whIn silico maps were generated from de novo assemblies of shotgun Illumina sequencing data (HiSeq) and six mate-pair libraries with insert sizes ranging from 1.1 kbp to 25 kbp [k-mer size of 51 for contig assembly and Opera v.1.1 [de novo.For our second test, we compared all methods on optical mapping data generated in-house from the K562 human cancer cell line on OpGen’s Argus system, where a random sample of 2000 maps with at least ten fragments was extracted. o 25 kbp   reported alignments that provide an extension to the Overlap alignments form a critical building block for applications such as OpGen’s Genome-Builder and its use in boosting assembly quality . As OPTIWe similarly compared OPTIMA and Gentig on the two human cell line results, shown in Tables With the availability of new mapping technologies  and greater use of existing ones to complement high-throughput sequencing, there is a critical need for robust computational tools that can combine genomic mapping and sequence data efficiently. In this work, we introduce two new alignment tools that address this need for a wide range of applications, from genome assembly to structural variation analysis. Our benchmarking results provide evidence that these methods outperform existing approaches in sensitivity and runtime while providing highly precise alignments in a range of experimental settings. Similar results are also seen in real datasets from human cell lines, suggesting that they could help in significantly reducing the cost of optical mapping analysis and thus increase its usage.de novo assembly of experimental maps. The second concept is the development of a conservative statistical testing approach that does not require knowledge of the true distribution of errors or an expensive permutation test to evaluate the uniqueness and significance of alignments. This allows us to significantly reduce the runtime cost of this step without sacrificing specificity or the ability to be agnostic with respect to error rates. Although our experiments with real data in this work were limited to data generated on the Argus system from OpGen, similar ideas (with minor variations) should also be applicable to data generated by other technologies such as the Irys platform from BioNano Genomics.In the development of OPTIMA and OPTIMA-Overlap, we establish two key new ideas for map alignment. The first is the introduction of composite seeds, an idea that echoes the idea of spaced seeds in the context of continuous-valued sequence alignment. Composite seeds allow us to develop efficient seed-and-extend aligners for map-to-sequence alignment of erroneous mapping data. We believe that similar ideas can be applied for map-to-map alignment and In future work, we plan to implement further runtime and memory optimizations to OPTIMA and OPTIMA-Overlap and to explore their use for super-scaffolding of large genomes as well as for studying genomic rearrangements in cancer.Project name: OPTIMA: Index-based map-to-sequence alignment in large eukaryotic genomesProject home page:http://www.davideverzotto.it/research/OPTIMA, https://github.com/verznet/OPTIMAOperating system: Platform independentProgramming language: Java 7+Other requirements: Java Development Kit 7+, Apache Commons Math 3.2, CERN Colt 1.2.0License: LGPL  2.1, OSI compliantAny restrictions to use by non-academics: noneGigaScience GigaDB database [Snapshots of the code and benchmarking and real datasets are available from the database , 30.Additional file 1Supplementary material. Supplementary notes and figures to accompany the main manuscript. (PDF 32358 kb)


Manual annotation is essential to create high-quality reference alignments and annotation. Annotators need to be able to view sequence alignments in detail. The SeqTools package provides three tools for viewing different types of sequence alignment: Blixem is a many-to-one browser of pairwise alignments, displaying multiple match sequences aligned against a single reference sequence; Dotter provides a graphical dot-plot view of a single pairwise alignment; and Belvu is a multiple sequence alignment viewer, editor, and phylogenetic tool. These tools were originally part of the AceDB genome database system but have been completely rewritten to make them generally available as a standalone package of greatly improved function.Blixem is used by annotators to give a detailed view of the evidence for particular gene models. Blixem displays the gene model positions and the match sequences aligned against the genomic reference sequence. Annotators use this for many reasons, including to check the quality of an alignment, to find missing/misaligned sequence and to identify splice sites and polyA sites and signals. Dotter is used to give a dot-plot representation of a particular pairwise alignment. This is used to identify sequence that is not represented (or is misrepresented) and to quickly compare annotated gene models with transcriptional and protein evidence that putatively supports them. Belvu is used to analyse conservation patterns in multiple sequence alignments and to perform a combination of manual and automatic processing of the alignment. High-quality reference alignments are essential if they are to be used as a starting point for further automatic alignment generation.While there are many different alignment tools available, the SeqTools package provides unique functionality that annotators have found to be essential for analysing sequence alignments as part of the manual annotation process.The online version of this article (doi:10.1186/s13104-016-1847-3) contains supplementary material, which is available to authorized users. Manual annotation is essential to create high-quality reference alignments and annotation. Annotators need to be able to view sequence alignments in detail in order to verify them and to correct any errors. The SeqTools package provides three interactive tools for viewing different types of sequence alignment: Blixem, Dotter and Belvu.These three programs were originally part of the AceDB  genome dThe SeqTools programs are desktop applications written in C using GTK+. They are easy to install and are fast to run for small to medium sized alignments. Unlike many web-based tools, they do not require a network connection to work so are not subject to network problems. They support simple, widely-supported text-based file formats and have extensive command-line options which enable their use in software pipelines.Blixem is a many-to-one browser of pairwise alignments. It takes two files as input: a FASTA file containing the reference sequence, and a GFF version 3 file containing alignments as well as any gene models or other features of interest. Input files can be passed on the command line or piped in and additional feature files can be loaded from within the program. The move to GFF from legacy AceDB file formats is a major improvement in version 4 of Blixem.The display consists of two sections: a zoomable overview section showing the feature positions along the reference sequence; and a detail section showing the actual alignment of protein or nucleotide sequences to the reference DNA sequence. Multiple match sequences are stacked below the reference sequence and individual bases are colour-coded to indicated how well they match. Markers indicate where deletions and insertions occur.Blixem works in nucleotide or protein mode depending on the type of the sequences. In nucleotide mode, both strands of the reference sequence are calculated and can be displayed simultaneously in the detail section. In protein mode, the three-frame translation of the reference sequence is calculated and all three frames for the current strand can be shown Fig. . In bothBlixem can display gene models and other feature types. Gene models and basic features are shown in the overview section as well as the detail section, and CDS and UTR sections can be highlighted in different colours. In version 4, support for new feature types has been added. These include: short-reads, which are displayed aligned against the reference sequence; SNPs, insertions and deletions, which are highlighted in the reference sequence; annotated polyA sites and signals, which again are highlighted in the reference sequence; and polyA tails, which are shown in the detail-view. Any other feature type can also be loaded, and will be displayed with simple positional information along with any styles specified in the config file.An improved user-interface makes it easy to quickly find and navigate around alignments. There are flexible methods to filter, highlight and sort sequences. Other new features allow users to display a coverage plot, to display colinearity lines between alignment blocks, to show unaligned portions of match sequences, and to highlight splice-sites in the reference sequence for particular features.Blixem has many configuration and command-line options, which include functionality to map coordinates, zoom in to a particular region, specify the sort order, and toggle sections of the display on or off. The colour scheme can be specified in an optional “.ini”-like styles file to match local colour usage. When calling Blixem from another program, the display can therefore be customised to match that of the parent program as closely as possible.Blixem can be used to display next-generation sequencing (NGS) data. It is capable of displaying up to around 50,000 reads while remaining usefully responsive. Startup time is around 20 s with this number of reads, and while a small lag is noticeable it is less than a second for most operations. Blixem doesn’t currently read BAM/SAM files natively, so the reads have to be provided in GFF3 format. However, we plan to incorporate HTSlib into Blixem to provide native support for BAM/SAM in the future. Blixem has a number of display settings for working with NGS data. A configuration option  allows the user to toggle a “squashed” view, where identical reads are compressed onto the same line, and lines are annotated with the number of reads they contain. This configuration option can be applied globally, or just to specific sources. There are command-line arguments to enable the squashed view by default, to show the coverage plot by default, and to change the default sort order (e.g. to sort by position or identity rather than name).Dotter can be called from within Blixem to give a graphical representation of a particular alignment, which often allows annotators to see matches they would otherwise have missed.Dotter is a graphical dot-matrix program for detailed comparison of two sequences. Dotter can be called from the command-line or from other tools such as Blixem. It takes two sequences as input, in FASTA file format. Every residue in one sequence is compared to every residue in the other and a score is calculated. The scores are plotted on a grid with one sequence on the x-axis and the other on the y-axis. Dots are drawn in grey-scale, with darker shades indicating a higher score. Interactive function allows exploration of score values regardless of screen display bias.Dotter can operate in nucleotide–nucleotide, nucleotide–protein or protein–protein mode. In nucleotide–nucleotide mode, comparisons are made against both strands of the horizontal sequence; alignments appear as diagonal lines, with alignments on the reverse strand sloping in the opposite direction to those on the forward strand Fig. . In nuclTo improve visualisation, scores are averaged over a sliding window. Scores below a minimum cutoff are ignored and scores above a maximum cutoff are saturated. The stringency cutoffs can be adjusted interactively using the Greyramp Tool, without having to recalculate the dot-matrix. This is a major advantage because large matrices can take a long time to compute. It is not easy to predict the correct thresholds programatically, so manual adjustment is often necessary. The Greyramp Tool allows the user to interactively change the upper and lower cutoffs with simple sliders on a greyramp image. A contrast sider is also available to move both cutoffs simultaneously. A simpler, minimised version of the greyramp tool is available which allows quick access to the contrast slider while maximising the screen space available for the plot.The dot-plot can be navigated with keyboard shortcuts or the mouse. A crosshair displays the currently-selected position coordinates. The coordinates can easily be copied to the clipboard. The sequence data at the crosshair position can be inspected using the alignment tool. This tool places the crosshair position at the centre of its display to give a good view of the sequence on either side. In nucleotide mode it displays both strands of the reference sequence, and in protein mode it displays the three-frame translation. Bases are highlighted according to how well they match  so it is easy to see whether the current position is on the alignment.The alignment tool scrolls in unison with the crosshair, and can be scrolled using keyboard shortcuts. Each sequence can be scrolled independently, or they can be scrolled in unison in order to walk along the alignment. Scrolling can be per-nucleotide or per-peptide, allowing very fine control of the crosshair/sequence position. Sections of the sequence can be selected in the alignment tool and the selected sequence and its coordinates can be copied to the clipboard.Features such as gene-models and high-scoring pairs (HSPs) can be loaded from a GFF file or piped from a calling program such as Blixem. HSPs can be superimposed onto the dot-plot, and gene models are displayed along the axis of the relevant sequence, so they can be easily compared with the alignment. Internal repeats can be analysed by running Dotter on a sequence versus itself. Overlaps between several sequences can be found by concatenating the sequences and running Dotter on the concatenated sequence versus itself. In the case where you have multiple sequences on each axis, a grid can be displayed showing which section is from which sequence.Dotter offers the option to save the plot to file, which is useful for large plots that take a long time to compute. Dotter can also be run in batch mode, where the matrix is computed in the background and saved for viewing later. Recreating a plot from a saved matrix is very fast, and has the advantage that it can still be dynamically adjusted and interacted with.Belvu is a multiple sequence alignment (MSA) viewer and editor used to create high-quality reference alignments. Belvu can load and save alignments in Stockholm, MSF, Selex and Fasta file formats.Opening an alignment brings up Belvu’s graphical alignment window. By default, residues are coloured by conservation Fig. . ConservResidues can also be coloured by residue type Fig. . There aBelvu can display a conservation profile for the alignment Fig. , which sBelvu has basic alignment editing capabilities, whereby sequences or columns can be removed. Sequences can be removed by manual selection, or by automatically removing those that match certain criteria such as the percentage of gaps they contain, their score, or whether they are a redundant or partial sequence. Similarly, columns can be removed by criteria such as the percentage of gaps or the maximum conservation in the column.Belvu can construct a distance-based phylogenetic tree from a multiple alignment, using either neighbour-joining or UPGMA tree construction methods Fig. . DistancBelvu has extensive command-line capabilities, which includes most of its non-interactive functionality: file format conversion; distance-matrix construction; tree generation using a variety of methods; distance-matrix construction; tree reconstruction from a distance matrix; bootstrap analysis; and automated editing operations based on caller-specified criteria such as conservation and percentage of gaps. Multiple command-line operations can be used in conjunction with one another, making powerful, automated processing possible. This makes Belvu ideal for use in software pipelines. Table Blixem and Dotter are used extensively by the HAVANA group at the Wellcome Trust Sanger Institute and are essential to the manual annotation process. Examples of work published by the HAVANA group that has involved the use of Blixem and Dotter includes –10. BelvThis section provides some examples of the type of work that each tool has been used for. We also compare the tools with other, similar tools that are available. This comparison is aimed at highlighting what makes the SeqTools programs unique and is not intended to be a comprehensive review of all features.Blixem is the “workhorse” for manual gene annotation in the HAVANA group and other collaborating institutes and is in continuous use. It represents the annotator’s first point of contact at nucleotide-level for all sequence alignment data, including ESTs, mRNAs and proteins. Annotators use Blixem to check the quality of an alignment , to identify splice sites , to identify polyA sites and signals, to investigate the functional effects of polymorphisms (including reference sequence disabling variants in polymorphic pseudogenes), to investigate potential genome sequence errors, to identify deleterious mutations in pseudogenes, and in rarer cases to identify selenocysteine residues and RNA editing events.As far as the authors are aware, there are no other tools available that are quite like Blixem. The tools that come closest are BAM viewers such as the UGENE Assembly Browser. This displays multiple reads aligned under the reference/consensus sequence with differences highlighted in a similar manner to Blixem. However, it is very much aimed at BAM data rather than general alignment data, and as it only reads BAM files it cannot display other feature types .Artemis/BamView offers a similar stacked view for BAM reads, but again this is aimed solely at BAM. Artemis can also show alignments from a GFF file but does not combine them into the same stacked display—instead, they are shown next to the sequence display, but overlapped so that you have to select from a list to see a specific feature highlighted.Gap5 is another tool that superficially looks similar to Blixem because it stacks multiple matches against a reference sequence. However, this is an assembly editor and is a much larger, complicated system than Blixem. It requires data to be converted to a gap5 database so cannot be used to simply view the contents of a GFF file.Dotter is essential to the HAVANA manual annotation process and is used for two main purposes:Firstly, to identify sequence that is not represented (or is misrepresented) in the EST2genome or BLAST alignments produced by the analysis pipeline and displayed in Blixem. Identification of missing sequences using Dotter frequently allows annotation of models with alternative 5′ UTR and internal exons that are short in length, repeatmasked in the reference genome sequence, or contain transcript sequence errors/polymorphism that hinders their automated alignment. As the HAVANA group only annotate gene models to the extent they are supported by aligned evidence (i.e. they do not extend models by creating a tiling path of evidence or “borrowing” exons from other full-length models at the same locus), Dotter is useful to support the extension of gene models supported by evidence from paralogous and orthologous loci and locus-specific ESTs of inconsistent sequence quality. Secondly, to facilitate the rapid comparison of annotated gene models with transcriptional and protein evidence that putatively support them as breaks in alignment are more clearly identifiable than in a pairwise sequence alignment e.g. Clustal.There are several dot-matrix alignment programs available such as Gepard, SEROLIS, DNAdot, GenomeDiff, Dotlet and UGENE’s Dot Plot viewer, but most of them lack tools similar to Dotter’s Greyramp and Alignment tool. The only two programs we found that offer a Greyramp tool are Gepard and SEROLIS. SEROLIS only supports very short alignments (4k max) and even so it is very slow . Its greyramp tool is also very slow (taking around the same time again that it took to start up for each adjustment).Escherichia coli self plot, which would take Dotter several days). However, for small to medium sized plots Dotter still has some advantages—its alignment tool is more sophisticated , and Dotter can display gene models and HSPs loaded from a GFF file.Gepard on the other hand has a good greyramp tool with a similar level of control as Dotter. Gepard also has a reasonable alignment tool and crosshair control—it was the only other tool we found that has keyboard shortcuts to walk along the alignment. Gepard also has the advantage over Dotter is that it uses an alternative algorithm based on suffix arrays for large sequences, which means it can calculate the alignment very quickly , and neither UGENE nor BaseByBase has configurable thresholds like Belvu and Jevtrace. Other programs tend to just use the per-residue colours which are simply turned on or off based on a single threshold, which does not give such a clear view of the conservation patterns.While Belvu’s editing capabilities are not intended to be comprehensive, it still has more functionality than many of the tools available, particularly regarding automatic removal of sequences and columns. While many tools allow manual deletion of sequences/columns and manual removal of gaps etc., few are able to automatically delete columns and sequences based on customisable criteria. Some of the operations that are available in other tools are: removal of all-gap columns ; removal of all gaps ; removal of redundant sequences ; removal of a column by user-specified percentage of gaps ; and filtering of sequences by percent identity . Functionality that we did not find in any other programs includes: removal of sequences by percentage gaps; removal of partial sequences (those starting or ending with gaps); and removal of columns by conservation (with user-specified upper/lower cutoffs).Command-line operation is not available in most of the tools we tested. SeqView has a small number of command line options such as tree and distance-matrix construction, and conversion to other formats. UGENE offers many command-line operations, such as conversion to other formats and finding ORFs and repeats. However, none of these tools offer editing commands on the command line, so Belvu is the only tool that we are aware of that can do this. In conjunction with its many automated editing commands and customisable criteria, this makes Belvu the most powerful command-line editing tool available.Blixem is a unique tool that displays multiple match sequences aligned against a single reference sequence. This allows annotators to compare evidence from a variety of sources in a very detailed nucleotide-level view. Support for new data types such as short-reads means that the annotator can see all relevant information in one place in the context of selected features.Dotter gives a graphical view of a particular pairwise alignment. Its dynamically-adjustable contrast allows annotators to quickly tweak the display to get the best view of the results, and the alignment tool offers a detailed view of the aligned sequence. The alignment can easily be compared to annotated gene models and HSPs. Dotter is extremely useful for identifying alignments that cannot be found using automated methods, and for validating putative evidence.Belvu is one of many programs available for viewing and editing multiple alignments and generating phylogenetic trees. Belvu’s advantages are its extensive command-line mode, its automatic editing operations, and its highly configurable colour schemes, including similarity-based schemes which give a very clear view of conservation patterns. Belvu is also the only tool to implement the Scoredist algorithm .Project name: SeqTools;http://www.sanger.ac.uk/resources/software/seqtools/;Project home page: Operating system(s): Linux, Mac OS X, FreeBSD, Cygwin;Programming language: C;Other requirements: GTK+ 2.12 or higher;Licence: GNU GPL version 3;Any restrictions to use by non-academics: none.The source code for the production version of SeqTools at the time of writing is available as Additional file