vg
tools for working with variation graphs
Loading...
Searching...
No Matches
vg::Mapper Class Reference

#include <mapper.hpp>

Inheritance diagram for vg::Mapper:
vg::BaseMapper vg::AlignerClient vg::PairedEndMapper

Public Member Functions

 Mapper (PathPositionHandleGraph *xidex, gcsa::GCSA *g, gcsa::LCPArray *a, haplo::ScoreProvider *haplo_score_provider=nullptr)
 
 Mapper (void)
 
 ~Mapper (void)
 
bool alignments_consistent (const map< string, double > &pos1, const map< string, double > &pos2, int fragment_size_bound)
 
bool pair_consistent (Alignment &aln1, Alignment &aln2, double pval)
 use the fragment length annotations to assess if the pair is consistent or not
 
pair< bool, bool > pair_rescue (Alignment &mate1, Alignment &mate2, bool &tried1, bool &tried2, int match_score, int full_length_bonus, bool traceback, bool xdrop_alignment)
 use the fragment configuration statistics to rescue more precisely
 
vector< Alignmentmems_id_clusters_to_alignments (const Alignment &alignment, vector< MaximalExactMatch > &mems, int additional_multimaps)
 
set< const vector< MaximalExactMatch > * > clusters_to_drop (const vector< vector< MaximalExactMatch > > &clusters)
 
int32_t score_alignment (const Alignment &aln, bool use_approx_distance=false)
 
void remove_full_length_bonuses (Alignment &aln)
 Given an alignment scored with full length bonuses on, subtract out the full length bonus if it was applied.
 
Alignment patch_alignment (const Alignment &aln, int max_patch_length, bool trim_internal_deletions=true, bool xdrop_alignment=false)
 
Alignment align_cluster (const Alignment &aln, const vector< MaximalExactMatch > &mems, bool traceback, bool xdrop_alignment=false)
 
double compute_uniqueness (const Alignment &aln, const vector< MaximalExactMatch > &mems)
 
Alignment align_maybe_flip (const Alignment &base, HandleGraph &graph, bool flip, bool traceback, bool banded_global=false, bool xdrop_alignment=false)
 
Alignment align_maybe_flip (const Alignment &base, HandleGraph &graph, const vector< MaximalExactMatch > &mems, bool flip, bool traceback, bool banded_global=false, bool xdrop_alignment=false)
 
bool adjacent_positions (const Position &pos1, const Position &pos2)
 
int64_t get_node_length (int64_t node_id)
 
bool check_alignment (const Alignment &aln)
 
Alignment align (const string &seq, int kmer_size=0, int stride=0, int max_mem_length=0, int band_width=1000, int band_overlap=500, bool xdrop_alignment=false)
 
Alignment align (const Alignment &read, int kmer_size=0, int stride=0, int max_mem_length=0, int band_width=1000, int band_overlap=500, bool xdrop_alignment=false)
 
vector< Alignmentalign_multi (const Alignment &aln, int kmer_size=0, int stride=0, int max_mem_length=0, int band_width=1000, int band_overlap=500, bool xdrop_alignment=false)
 
pair< vector< Alignment >, vector< Alignment > > align_paired_multi (const Alignment &read1, const Alignment &read2, bool &queued_resolve_later, int max_mem_length=0, bool only_top_scoring_pair=false, bool retrying=false, bool xdrop_alignment=false)
 
double compute_cluster_mapping_quality (const vector< vector< MaximalExactMatch > > &clusters, int read_length)
 
double estimate_max_possible_mapping_quality (int length, double min_diffs, double next_min_diffs)
 
double max_possible_mapping_quality (int length)
 
int64_t graph_mixed_distance_estimate (pos_t pos1, pos_t pos2, int64_t maximum)
 
int64_t approx_distance (pos_t pos1, pos_t pos2)
 
int64_t approx_position (pos_t pos)
 
int64_t approx_alignment_position (const Alignment &aln)
 
Position alignment_end_position (const Alignment &aln)
 
int64_t approx_fragment_length (const Alignment &aln1, const Alignment &aln2)
 
vector< pos_tlikely_mate_positions (const Alignment &aln, bool is_first)
 
unordered_map< path_handle_t, int64_t > min_pair_fragment_length (const Alignment &aln1, const Alignment &aln2)
 
- Public Member Functions inherited from vg::BaseMapper
 BaseMapper (PathPositionHandleGraph *xidex, gcsa::GCSA *g, gcsa::LCPArray *a, haplo::ScoreProvider *haplo_score_provider=nullptr)
 
 BaseMapper (void)
 
int random_match_length (double chance_random)
 
void set_alignment_scores (int8_t match, int8_t mismatch, int8_t gap_open, int8_t gap_extend, int8_t full_length_bonus, double haplotype_consistency_exponent=1)
 Override alignment score setting to support haplotype consistency exponent.
 
void set_alignment_scores (istream &matrix_stream, int8_t gap_open, int8_t gap_extend, int8_t full_length_bonus, double haplotype_consistency_exponent=1)
 Same, but loading a 4x4 substitution score matrix from a stream.
 
vector< MaximalExactMatchfind_mems_deep (string::const_iterator seq_begin, string::const_iterator seq_end, double &lcp_avg, double &fraction_filtered, int max_mem_length=0, int min_mem_length=1, int reseed_length=0, bool use_lcp_reseed_heuristic=false, bool use_diff_based_fast_reseed=false, bool include_parent_in_sub_mem_count=false, bool record_max_lcp=false, int reseed_below_count=0)
 
vector< MaximalExactMatchfind_mems_simple (string::const_iterator seq_begin, string::const_iterator seq_end, int max_mem_length=0, int min_mem_length=1, int reseed_length=0)
 
vector< MaximalExactMatchfind_stripped_matches (string::const_iterator seq_begin, string::const_iterator seq_end, size_t strip_length, size_t max_match_length, size_t target_count)
 
vector< MaximalExactMatchfind_fanout_mems (string::const_iterator seq_begin, string::const_iterator seq_end, string::const_iterator qual_begin, int max_fans_out, char max_fanout_base_quality, vector< deque< pair< string::const_iterator, char > > > *mem_fanout_breaks=nullptr)
 
vector< pos_twalk_fanout_path (string::const_iterator begin, string::const_iterator end, const deque< pair< string::const_iterator, char > > &fanout_breaks, gcsa::node_type pos)
 
void rescue_high_count_order_length_mems (vector< MaximalExactMatch > &mems, size_t max_rescue_hit_count)
 
void precollapse_order_length_runs (string::const_iterator seq_begin, vector< MaximalExactMatch > &mems)
 
void prefilter_redundant_sub_mems (vector< MaximalExactMatch > &mems, vector< pair< int, vector< size_t > > > &sub_mem_containment_graph)
 
void find_sub_mems (const vector< MaximalExactMatch > &mems, int parent_layer_begin, int parent_layer_end, int mem_idx, string::const_iterator next_mem_end, int min_mem_length, vector< pair< MaximalExactMatch, vector< size_t > > > &sub_mems_out)
 
void find_sub_mems_fast (const vector< MaximalExactMatch > &mems, int parent_layer_begin, int parent_layer_end, int mem_idx, string::const_iterator leftmost_guaranteed_disjoint_bound, string::const_iterator leftmost_seeding_bound, int min_sub_mem_length, vector< pair< MaximalExactMatch, vector< size_t > > > &sub_mems_out)
 
gcsa::range_type accelerate_mem_query (string::const_iterator begin, string::const_iterator &cursor) const
 
set< pos_tsequence_positions (const string &seq)
 
size_t get_adaptive_min_reseed_length (size_t parent_mem_length)
 
void apply_haplotype_consistency_scores (const vector< Alignment * > &alns)
 
- Public Member Functions inherited from vg::AlignerClient
virtual void set_alignment_scores (int8_t match, int8_t mismatch, int8_t gap_open, int8_t gap_extend, int8_t full_length_bonus)
 Set all the aligner scoring parameters and create the stored aligner instances.
 
virtual void set_alignment_scores (std::istream &matrix_stream, int8_t gap_open, int8_t gap_extend, int8_t full_length_bonus)
 
virtual void set_alignment_scores (const int8_t *score_matrix, int8_t gap_open, int8_t gap_extend, int8_t full_length_bonus)
 
- Public Member Functions inherited from vg::PairedEndMapper
void set_fragment_length_distr_params (size_t maximum_sample_size=1000, size_t reestimation_frequency=1000, double robust_estimation_fraction=0.95)
 
bool has_fixed_fragment_length_distr ()
 Returns true if fragment length distribution has been fixed.
 
void force_fragment_length_distr (double mean, double stddev)
 

Public Attributes

vector< pair< Alignment, Alignment > > imperfect_pairs_to_retry
 
int min_cluster_length
 
int max_attempts
 
int thread_extension
 
int max_target_factor
 
int max_multimaps
 
int softclip_threshold
 
int max_softclip_iterations
 
float min_identity
 
int min_banded_mq
 
int extra_multimaps
 
int min_multimaps
 
int band_multimaps
 
bool patch_alignments
 
double maybe_mq_threshold
 
int max_cluster_mapping_quality
 
bool use_cluster_mq
 
double identity_weight
 
bool always_rescue
 
bool include_full_length_bonuses
 
int max_xdrop_gap_length
 
bool simultaneous_pair_alignment
 
int max_band_jump
 
float drop_chain
 
float mq_overlap
 
int mate_rescues
 
double pair_rescue_hang_threshold
 
double pair_rescue_retry_threshold
 
FragmentLengthStatistics frag_stats
 
atomic< int > warned_about_chunking {0}
 
- Public Attributes inherited from vg::BaseMapper
int sub_mem_thinning_burn_in = 16
 
int sub_mem_count_thinning = 4
 
int min_mem_length
 
int mem_reseed_length
 
bool fast_reseed = true
 
double fast_reseed_length_diff = 0.45
 
bool adaptive_reseed_diff = true
 
double adaptive_diff_exponent = 0.065
 
int hit_max = 0
 
int hard_hit_max = 0
 
bool use_approx_sub_mem_count = false
 
bool prefilter_redundant_hits = true
 
int max_sub_mem_recursion_depth = 2
 
bool use_greedy_mem_restarts = false
 
int greedy_restart_min_length = 40
 
int greedy_restart_max_count = 2
 
int greedy_restart_max_lcp = 0
 
bool greedy_restart_assume_substitution = false
 
bool filter_short_mems = false
 
double short_mem_filter_factor = 0.45
 
int unpaired_penalty = 17
 
bool precollapse_order_length_hits = true
 
double avg_node_length = 0
 
size_t total_seq_length = 0
 
int fanout_length_threshold = 0
 
double recombination_penalty = 20.7
 
bool strip_bonuses
 
bool assume_acyclic
 
MappingQualityMethod mapping_quality_method
 
int max_mapping_quality
 
bool exclude_unaligned = false
 
bool debug = false
 Set to enable debugging messages to cerr from the mapper, so a user can understand why a read maps the way it does.
 
PathPositionHandleGraphxindex = nullptr
 
gcsa::GCSA * gcsa = nullptr
 
gcsa::LCPArray * lcp = nullptr
 
MEMAcceleratoraccelerator = nullptr
 
haplo::ScoreProviderhaplo_score_provider = nullptr
 
double haplotype_consistency_exponent = 1
 
- Public Attributes inherited from vg::AlignerClient
bool adjust_alignments_for_base_quality = false
 

Protected Member Functions

Alignment align_to_graph (const Alignment &aln, HandleGraph &graph, bool do_flip, bool traceback, bool pinned_alignment=false, bool pin_left=false, bool banded_global=false, bool keep_bonuses=true)
 
Alignment align_to_graph (const Alignment &aln, HandleGraph &graph, const vector< MaximalExactMatch > &mems, bool do_flip, bool traceback, bool pinned_alignment=false, bool pin_left=false, bool banded_global=false, int xdrop_alignment=0, bool keep_bonuses=true)
 
vector< Alignmentmake_bands (const Alignment &read, int band_width, int band_overlap, vector< pair< int, int > > &to_strip)
 
- Protected Member Functions inherited from vg::AlignerClient
 AlignerClient (double gc_content_estimate=vg::default_gc_content)
 
const GSSWAlignerget_aligner (bool have_qualities=true) const
 
const QualAdjAlignerget_qual_adj_aligner () const
 
const Alignerget_regular_aligner () const
 

Private Member Functions

vector< Alignmentalign_multi_internal (bool compute_unpaired_qualities, const Alignment &aln, int kmer_size, int stride, int max_mem_length, int band_width, int band_overlap, double &cluster_mq, int keep_multimaps=0, int additional_multimaps=0, vector< MaximalExactMatch > *restricted_mems=nullptr, bool xdrop_alignment=false)
 
void compute_mapping_qualities (vector< Alignment > &alns, double cluster_mq, double mq_estimate, double mq_cap)
 
void compute_mapping_qualities (pair< vector< Alignment >, vector< Alignment > > &pair_alns, double cluster_mq, double mq_estmate1, double mq_estimate2, double mq_cap1, double mq_cap2)
 
vector< Alignmentscore_sort_and_deduplicate_alignments (vector< Alignment > &all_alns, const Alignment &original_alignment)
 
void filter_and_process_multimaps (vector< Alignment > &all_alns, int total_multimaps)
 
vector< Alignmentalign_banded (const Alignment &read, int kmer_size=0, int stride=0, int max_mem_length=0, int band_width=1000, int band_overlap=500, bool xdrop_alignment=false)
 
vector< Alignmentalign_mem_multi (const Alignment &aln, vector< MaximalExactMatch > &mems, double &cluster_mq, double lcp_avg, double fraction_filtered, int max_mem_length, int keep_multimaps, int additional_multimaps, bool xdrop_alignment=false)
 

Additional Inherited Members

- Static Public Member Functions inherited from vg::BaseMapper
static double estimate_gc_content (const gcsa::GCSA *gcsa)
 
- Static Public Member Functions inherited from vg::AlignerClient
static int8_t * parse_matrix (std::istream &matrix_stream)
 Allocates an array to hold a 4x4 substitution matrix and returns it.
 
- Static Public Attributes inherited from vg::BaseMapper
static thread_local vector< size_t > adaptive_reseed_length_memo
 
- Protected Attributes inherited from vg::PairedEndMapper
FragmentLengthDistribution fragment_length_distr
 Holds the actual fragment length distribution and estimation information.
 

Constructor & Destructor Documentation

◆ Mapper() [1/2]

vg::Mapper::Mapper ( PathPositionHandleGraph * xidex,
gcsa::GCSA * g,
gcsa::LCPArray * a,
haplo::ScoreProvider * haplo_score_provider = nullptr )

◆ Mapper() [2/2]

vg::Mapper::Mapper ( void )

◆ ~Mapper()

vg::Mapper::~Mapper ( void )

Member Function Documentation

◆ adjacent_positions()

bool vg::Mapper::adjacent_positions ( const Position & pos1,
const Position & pos2 )

◆ align() [1/2]

Alignment vg::Mapper::align ( const Alignment & read,
int kmer_size = 0,
int stride = 0,
int max_mem_length = 0,
int band_width = 1000,
int band_overlap = 500,
bool xdrop_alignment = false )

◆ align() [2/2]

Alignment vg::Mapper::align ( const string & seq,
int kmer_size = 0,
int stride = 0,
int max_mem_length = 0,
int band_width = 1000,
int band_overlap = 500,
bool xdrop_alignment = false )

◆ align_banded()

vector< Alignment > vg::Mapper::align_banded ( const Alignment & read,
int kmer_size = 0,
int stride = 0,
int max_mem_length = 0,
int band_width = 1000,
int band_overlap = 500,
bool xdrop_alignment = false )
private

◆ align_cluster()

Alignment vg::Mapper::align_cluster ( const Alignment & aln,
const vector< MaximalExactMatch > & mems,
bool traceback,
bool xdrop_alignment = false )

◆ align_maybe_flip() [1/2]

Alignment vg::Mapper::align_maybe_flip ( const Alignment & base,
HandleGraph & graph,
bool flip,
bool traceback,
bool banded_global = false,
bool xdrop_alignment = false )

◆ align_maybe_flip() [2/2]

Alignment vg::Mapper::align_maybe_flip ( const Alignment & base,
HandleGraph & graph,
const vector< MaximalExactMatch > & mems,
bool flip,
bool traceback,
bool banded_global = false,
bool xdrop_alignment = false )

◆ align_mem_multi()

vector< Alignment > vg::Mapper::align_mem_multi ( const Alignment & aln,
vector< MaximalExactMatch > & mems,
double & cluster_mq,
double lcp_avg,
double fraction_filtered,
int max_mem_length,
int keep_multimaps,
int additional_multimaps,
bool xdrop_alignment = false )
private

◆ align_multi()

vector< Alignment > vg::Mapper::align_multi ( const Alignment & aln,
int kmer_size = 0,
int stride = 0,
int max_mem_length = 0,
int band_width = 1000,
int band_overlap = 500,
bool xdrop_alignment = false )

◆ align_multi_internal()

vector< Alignment > vg::Mapper::align_multi_internal ( bool compute_unpaired_qualities,
const Alignment & aln,
int kmer_size,
int stride,
int max_mem_length,
int band_width,
int band_overlap,
double & cluster_mq,
int keep_multimaps = 0,
int additional_multimaps = 0,
vector< MaximalExactMatch > * restricted_mems = nullptr,
bool xdrop_alignment = false )
private

◆ align_paired_multi()

pair< vector< Alignment >, vector< Alignment > > vg::Mapper::align_paired_multi ( const Alignment & read1,
const Alignment & read2,
bool & queued_resolve_later,
int max_mem_length = 0,
bool only_top_scoring_pair = false,
bool retrying = false,
bool xdrop_alignment = false )

◆ align_to_graph() [1/2]

Alignment vg::Mapper::align_to_graph ( const Alignment & aln,
HandleGraph & graph,
bool do_flip,
bool traceback,
bool pinned_alignment = false,
bool pin_left = false,
bool banded_global = false,
bool keep_bonuses = true )
protected

◆ align_to_graph() [2/2]

Alignment vg::Mapper::align_to_graph ( const Alignment & aln,
HandleGraph & graph,
const vector< MaximalExactMatch > & mems,
bool do_flip,
bool traceback,
bool pinned_alignment = false,
bool pin_left = false,
bool banded_global = false,
int xdrop_alignment = 0,
bool keep_bonuses = true )
protected

◆ alignment_end_position()

Position vg::Mapper::alignment_end_position ( const Alignment & aln)

◆ alignments_consistent()

bool vg::Mapper::alignments_consistent ( const map< string, double > & pos1,
const map< string, double > & pos2,
int fragment_size_bound )

◆ approx_alignment_position()

int64_t vg::Mapper::approx_alignment_position ( const Alignment & aln)

returns approximate position of alignnment start in xindex or -1.0 if alignment is unmapped

◆ approx_distance()

int64_t vg::Mapper::approx_distance ( pos_t pos1,
pos_t pos2 )

◆ approx_fragment_length()

int64_t vg::Mapper::approx_fragment_length ( const Alignment & aln1,
const Alignment & aln2 )

returns approximate distance between alignment starts or -1.0 if not possible to determine

◆ approx_position()

int64_t vg::Mapper::approx_position ( pos_t pos)

◆ check_alignment()

bool vg::Mapper::check_alignment ( const Alignment & aln)

◆ clusters_to_drop()

set< const vector< MaximalExactMatch > * > vg::Mapper::clusters_to_drop ( const vector< vector< MaximalExactMatch > > & clusters)

◆ compute_cluster_mapping_quality()

double vg::Mapper::compute_cluster_mapping_quality ( const vector< vector< MaximalExactMatch > > & clusters,
int read_length )

◆ compute_mapping_qualities() [1/2]

void vg::Mapper::compute_mapping_qualities ( pair< vector< Alignment >, vector< Alignment > > & pair_alns,
double cluster_mq,
double mq_estmate1,
double mq_estimate2,
double mq_cap1,
double mq_cap2 )
private

◆ compute_mapping_qualities() [2/2]

void vg::Mapper::compute_mapping_qualities ( vector< Alignment > & alns,
double cluster_mq,
double mq_estimate,
double mq_cap )
private

◆ compute_uniqueness()

double vg::Mapper::compute_uniqueness ( const Alignment & aln,
const vector< MaximalExactMatch > & mems )

◆ estimate_max_possible_mapping_quality()

double vg::Mapper::estimate_max_possible_mapping_quality ( int length,
double min_diffs,
double next_min_diffs )

◆ filter_and_process_multimaps()

void vg::Mapper::filter_and_process_multimaps ( vector< Alignment > & all_alns,
int total_multimaps )
private

◆ get_node_length()

int64_t vg::Mapper::get_node_length ( int64_t node_id)

◆ graph_mixed_distance_estimate()

int64_t vg::Mapper::graph_mixed_distance_estimate ( pos_t pos1,
pos_t pos2,
int64_t maximum )

◆ likely_mate_positions()

vector< pos_t > vg::Mapper::likely_mate_positions ( const Alignment & aln,
bool is_first )

◆ make_bands()

vector< Alignment > vg::Mapper::make_bands ( const Alignment & read,
int band_width,
int band_overlap,
vector< pair< int, int > > & to_strip )
protected

◆ max_possible_mapping_quality()

double vg::Mapper::max_possible_mapping_quality ( int length)

◆ mems_id_clusters_to_alignments()

vector< Alignment > vg::Mapper::mems_id_clusters_to_alignments ( const Alignment & alignment,
vector< MaximalExactMatch > & mems,
int additional_multimaps )

◆ min_pair_fragment_length()

unordered_map< path_handle_t, int64_t > vg::Mapper::min_pair_fragment_length ( const Alignment & aln1,
const Alignment & aln2 )

◆ pair_consistent()

bool vg::Mapper::pair_consistent ( Alignment & aln1,
Alignment & aln2,
double pval )

use the fragment length annotations to assess if the pair is consistent or not

◆ pair_rescue()

pair< bool, bool > vg::Mapper::pair_rescue ( Alignment & mate1,
Alignment & mate2,
bool & tried1,
bool & tried2,
int match_score,
int full_length_bonus,
bool traceback,
bool xdrop_alignment )

use the fragment configuration statistics to rescue more precisely

◆ patch_alignment()

Alignment vg::Mapper::patch_alignment ( const Alignment & aln,
int max_patch_length,
bool trim_internal_deletions = true,
bool xdrop_alignment = false )

◆ remove_full_length_bonuses()

void vg::Mapper::remove_full_length_bonuses ( Alignment & aln)

Given an alignment scored with full length bonuses on, subtract out the full length bonus if it was applied.

◆ score_alignment()

int32_t vg::Mapper::score_alignment ( const Alignment & aln,
bool use_approx_distance = false )

Use the scoring provided by the internal aligner to re-score the alignment, scoring gaps between nodes using graph distance from the PathPositionHandleGraph index. Can use either approximate or exact (with approximate fallback) PathPositionHandleGraph-based distance estimation. Will strip out bonuses if the appropriate Mapper flag is set. Does not apply a haplotype consistency bonus, as this function is intended for alignments with large gaps.

◆ score_sort_and_deduplicate_alignments()

vector< Alignment > vg::Mapper::score_sort_and_deduplicate_alignments ( vector< Alignment > & all_alns,
const Alignment & original_alignment )
private

Member Data Documentation

◆ always_rescue

bool vg::Mapper::always_rescue

◆ band_multimaps

int vg::Mapper::band_multimaps

◆ drop_chain

float vg::Mapper::drop_chain

◆ extra_multimaps

int vg::Mapper::extra_multimaps

◆ frag_stats

FragmentLengthStatistics vg::Mapper::frag_stats

◆ identity_weight

double vg::Mapper::identity_weight

◆ imperfect_pairs_to_retry

vector<pair<Alignment, Alignment> > vg::Mapper::imperfect_pairs_to_retry

◆ include_full_length_bonuses

bool vg::Mapper::include_full_length_bonuses

◆ mate_rescues

int vg::Mapper::mate_rescues

◆ max_attempts

int vg::Mapper::max_attempts

◆ max_band_jump

int vg::Mapper::max_band_jump

◆ max_cluster_mapping_quality

int vg::Mapper::max_cluster_mapping_quality

◆ max_multimaps

int vg::Mapper::max_multimaps

◆ max_softclip_iterations

int vg::Mapper::max_softclip_iterations

◆ max_target_factor

int vg::Mapper::max_target_factor

◆ max_xdrop_gap_length

int vg::Mapper::max_xdrop_gap_length

◆ maybe_mq_threshold

double vg::Mapper::maybe_mq_threshold

◆ min_banded_mq

int vg::Mapper::min_banded_mq

◆ min_cluster_length

int vg::Mapper::min_cluster_length

◆ min_identity

float vg::Mapper::min_identity

◆ min_multimaps

int vg::Mapper::min_multimaps

◆ mq_overlap

float vg::Mapper::mq_overlap

◆ pair_rescue_hang_threshold

double vg::Mapper::pair_rescue_hang_threshold

◆ pair_rescue_retry_threshold

double vg::Mapper::pair_rescue_retry_threshold

◆ patch_alignments

bool vg::Mapper::patch_alignments

◆ simultaneous_pair_alignment

bool vg::Mapper::simultaneous_pair_alignment

◆ softclip_threshold

int vg::Mapper::softclip_threshold

◆ thread_extension

int vg::Mapper::thread_extension

◆ use_cluster_mq

bool vg::Mapper::use_cluster_mq

◆ warned_about_chunking

atomic<int> vg::Mapper::warned_about_chunking {0}

The documentation for this class was generated from the following files: