Configuration

Provides configuration elements for the pairwise alignment configuration. More...

Collaboration diagram for Configuration:

Classes
class	seqan3::align_cfg::band_fixed_size
	Configuration element for setting a fixed size band. More...
struct	seqan3::align_cfg::free_end_gaps_sequence1_leading
	A strong type representing free_end_gaps_sequence1_leading of the seqan3::align_cfg::method_global. More...
struct	seqan3::align_cfg::free_end_gaps_sequence1_trailing
	A strong type representing free_end_gaps_sequence1_trailing of the seqan3::align_cfg::method_global. More...
struct	seqan3::align_cfg::free_end_gaps_sequence2_leading
	A strong type representing free_end_gaps_sequence2_leading of the seqan3::align_cfg::method_global. More...
struct	seqan3::align_cfg::free_end_gaps_sequence2_trailing
	A strong type representing free_end_gaps_sequence2_trailing of the seqan3::align_cfg::method_global. More...
class	seqan3::align_cfg::gap_cost_affine
	A configuration element for the affine gap cost scheme. More...
struct	seqan3::align_cfg::lower_diagonal
	A strong type representing the lower diagonal of the seqan3::align_cfg::band_fixed_size. More...
class	seqan3::align_cfg::method_global
	Sets the global alignment method. More...
class	seqan3::align_cfg::method_local
	Sets the local alignment method. More...
class	seqan3::align_cfg::min_score
	Sets the minimal score (maximal errors) allowed during an distance computation e.g. edit distance. More...
class	seqan3::align_cfg::on_result< callback_t >
	Configuration element to provide a user defined callback function for the alignment. More...
class	seqan3::align_cfg::output_alignment
	Configures the alignment result to output the alignment. More...
class	seqan3::align_cfg::output_begin_position
	Configures the alignment result to output the begin positions. More...
class	seqan3::align_cfg::output_end_position
	Configures the alignment result to output the end position. More...
class	seqan3::align_cfg::output_score
	Configures the alignment result to output the score. More...
class	seqan3::align_cfg::output_sequence1_id
	Configures the alignment result to output the id of the first sequence. More...
class	seqan3::align_cfg::output_sequence2_id
	Configures the alignment result to output the id of the second sequence. More...
class	seqan3::align_cfg::detail::result_type< alignment_result_t >
	Configuration element capturing the configured seqan3::alignment_result for the alignment algorithm. More...
class	seqan3::align_cfg::score_type< score_t >
	A configuration element to set the score type used in the alignment algorithm. More...
struct	seqan3::align_cfg::scoring_scheme< scoring_scheme_t >
	Sets the scoring scheme for the alignment algorithm. More...
struct	seqan3::align_cfg::upper_diagonal
	A strong type representing the upper diagonal of the seqan3::align_cfg::band_fixed_size. More...
class	seqan3::align_cfg::vectorised
	Enables the vectorised alignment computation if possible for the current configuration. More...

Typedefs
using	seqan3::align_cfg::detail::debug = seqan3::detail::debug_mode< std::integral_constant< seqan3::detail::align_config_id, seqan3::detail::align_config_id::debug > >
	Configuration element for debugging the alignment algorithm. More...
using	seqan3::align_cfg::parallel = seqan3::detail::parallel_mode< std::integral_constant< seqan3::detail::align_config_id, seqan3::detail::align_config_id::parallel > >
	Enables the parallel execution of the alignment algorithm if possible for the given configuration. More...

Enumerations
enum class	seqan3::detail::align_config_id : uint8_t {   seqan3::detail::band , seqan3::detail::debug , seqan3::detail::gap , seqan3::detail::global ,   seqan3::detail::local , seqan3::detail::min_score , seqan3::detail::on_result , seqan3::detail::output_alignment ,   seqan3::detail::output_begin_position , seqan3::detail::output_end_position , seqan3::detail::output_sequence1_id , seqan3::detail::output_sequence2_id ,   seqan3::detail::output_score , seqan3::detail::parallel , seqan3::detail::result_type , seqan3::detail::score_type ,   seqan3::detail::scoring , seqan3::detail::vectorised , seqan3::detail::SIZE }
	An internal enum to check for a consistent configuration object. More...

Variables
constexpr configuration	seqan3::align_cfg::edit_scheme
	Shortcut for edit distance configuration. More...

Detailed Description

Provides configuration elements for the pairwise alignment configuration.

See also

Alignment

Typedef Documentation

debug

using seqan3::align_cfg::detail::debug = typedef seqan3::detail::debug_mode<std::integral_constant<seqan3::detail::align_config_id, seqan3::detail::align_config_id::debug> >

Configuration element for debugging the alignment algorithm.

Using this configuration allows to output the alignment matrices from the DP algorithm using the returned seqan3::alignment_result. The score matrix is always accessible, while the trace matrix can only be computed if an alignment was requested via the seqan3::align_cfg::output_alignment configuration.

Note

This configuration is only useful for debugging purposes as it can have a significant impact on the performance.

parallel

using seqan3::align_cfg::parallel = typedef seqan3::detail::parallel_mode<std::integral_constant<seqan3::detail::align_config_id, seqan3::detail::align_config_id::parallel> >

Enables the parallel execution of the alignment algorithm if possible for the given configuration.

With this configuration you can enable the parallel execution of the pairwise sequence alignment. This means that for a batch of pairwise sequence alignments the specified number of threads will be spawned to compute them in parallel. Note that only independent alignment computations can be executed in parallel, i.e. you use this method when computing a batch of alignments rather than executing them separately. Depending on your processor architecture you can gain a significant speed-up.

The value represents the number of threads to be used and must be greater than 0.

Example

#include <seqan3/alignment/configuration/align_config_parallel.hpp>
#include <thread>
 
int main()
{
    // Enables parallel computation with two threads.
    seqan3::align_cfg::parallel cfg_2{2};
 
    // Enables parallel computation with the number of concurrent threads supported by the current architecture.
    seqan3::align_cfg::parallel cfg_n{std::thread::hardware_concurrency()};
    ;
}

Enumeration Type Documentation

align_config_id

enum seqan3::detail::align_config_id : uint8_t

strong

An internal enum to check for a consistent configuration object.

Enumerator
band	ID for the band option.
debug	ID for the debug option.
gap	ID for the gap_cost_affine option.
global	ID for the global alignment option.
local	ID for the local alignment option.
min_score	ID for the min_score option.
on_result	ID for the on_result option.
output_alignment	ID for the alignment output option.
output_begin_position	ID for the begin position output option.
output_end_position	ID for the end position output option.
output_sequence1_id	ID for the sequence1 id output option.
output_sequence2_id	ID for the sequence2 id output option.
output_score	ID for the score output option.
parallel	ID for the parallel option.
result_type	ID for the result_type option.
score_type	ID for the score_type option.
scoring	ID for the scoring_scheme option.
vectorised	ID for the vectorised option.
SIZE	Represents the number of configuration elements.

Variable Documentation

edit_scheme

constexpr configuration seqan3::align_cfg::edit_scheme

inlineconstexpr

Initial value:

= scoring_scheme{nucleotide_scoring_scheme{}} |
                                             gap_cost_affine{open_score{0}, extension_score{-1}}

Shortcut for edit distance configuration.

The edit distance computation is a specific sub-problem of the alignment computation with the aim to count the number of edits to transform one sequence into another. An edit operation can be a substitution, an insertion, or a deletion. Accordingly, this algorithm uses a predefined scoring scheme as well as a gap scheme, where the score for a match is 0, for a mismatch -1, for a gap -1, and for a gap open 0.

Performance

Under the hood SeqAn uses a fast bit-vector algorithm to compute the edit distance whenever possible. This depends on the final alignment configuration. Currently, the fast edit distance algorithm is only triggered for global alignments with the with free ends in the first sequence. So make sure to configure the seqan3::align_cfg::method_global configuration element accordingly (see class documentation).

The performance of the algorithm can further be improved if the number of maximal errors (edits) is known by using the align_cfg::min_score configuration.

#include <seqan3/alignment/configuration/align_config_edit.hpp>
#include <seqan3/alignment/configuration/align_config_method.hpp>
#include <seqan3/alignment/configuration/align_config_min_score.hpp>
 
int main()
{
    // Computes semi global edit distance using fast-bit vector algorithm.
    auto cfg_fast = seqan3::align_cfg::method_global{
                        seqan3::align_cfg::free_end_gaps_sequence1_leading{true},
                        seqan3::align_cfg::free_end_gaps_sequence2_leading{false},
                        seqan3::align_cfg::free_end_gaps_sequence1_trailing{true},
                        seqan3::align_cfg::free_end_gaps_sequence2_trailing{false}} |
                    seqan3::align_cfg::edit_scheme;
 
    // Computes semi global edit distance using slower standard pairwise algorithm.
    auto cfg_slow = seqan3::align_cfg::method_global{
                        seqan3::align_cfg::free_end_gaps_sequence1_leading{false},
                        seqan3::align_cfg::free_end_gaps_sequence2_leading{true},
                        seqan3::align_cfg::free_end_gaps_sequence1_trailing{false},
                        seqan3::align_cfg::free_end_gaps_sequence2_trailing{true}} |
                    seqan3::align_cfg::edit_scheme;
 
    // Computes global distance allowing a minimal score of 3 (Default: edit distance).
    auto cfg_errors = seqan3::align_cfg::method_global{} |
                      seqan3::align_cfg::edit_scheme |
                      seqan3::align_cfg::min_score{-3};
}

Attention

If the edit distance configuration is combined with any other configuration element or setting, the algorithm falls back to the slower standard pairwise algorithm. For example the cfg_slow in the above example will trigger the slower algorithm which can handle the case if the ends are free in the second sequence instead of the first sequence.