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

#include <filter.hpp>

Public Member Functions

 Filter ()
 ~Filter ()
bool perfect_filter (Alignment &aln)
bool anchored_filter (Alignment &aln)
bool mark_sv_alignments (Alignment &a, Alignment &b)
bool mark_smallVariant_alignments (Alignment &a, Alignment &b)
Alignment depth_filter (Alignment &aln)
Alignment qual_filter (Alignment &aln)
Alignment coverage_filter (Alignment &aln)
Alignment avg_qual_filter (Alignment &aln)
Alignment percent_identity_filter (Alignment &aln)
bool soft_clip_filter (Alignment &aln)
bool unmapped_filter (Alignment &aln)
bool split_read_filter (Alignment &aln)
Alignment path_divergence_filter (Alignment &aln)
Alignment reversing_filter (Alignment &aln)
vector< Alignment > remap (Alignment &aln)
vector< Alignment > remap (string seq)
bool is_left_clipped (Alignment &a)
pair< Alignment, int > refactor_split_alignment (Alignment &a)
Alignment path_length_filter (Alignment &aln)
bool one_end_anchored_filter (Alignment &aln_first, Alignment &aln_second)
bool interchromosomal_filter (Alignment &aln_first, Alignment &aln_second)
bool insert_size_filter (Alignment &aln_first, Alignment &aln_second)
bool pair_orientation_filter (Alignment &aln_first, Alignment &aln_second)
pair< Alignment, Alignment > deletion_filter (Alignment &aln_first, Alignment &aln_second)
pair< Locus, Locus > insertion_filter (Alignment &aln_first, Alignment &aln_second)
pair< Locus, Locus > duplication_filter (Alignment &aln_first, Alignment &aln_second)
bool inversion_filter (Alignment &aln_first, Alignment &aln_second)
pair< Locus, Locus > breakend_filter (Alignment &aln_first, Alignment &aln_second)
void set_min_depth (int depth)
void set_min_qual (int qual)
void set_min_percent_identity (double pct_id)
void set_avg (bool do_avg)
void set_filter_matches (bool fm)
void set_remove_failing_edits (bool fm)
void set_soft_clip_limit (int max_clip)
void set_split_read_limit (int split_limit)
void set_window_length (int window_length)
void set_my_vg (vg::VG *vg)
void set_my_path_position_graph (PathPositionHandleGraph *graph)
void set_inverse (bool do_inv)
void init_mapper ()
void fill_node_to_position (string pathname)
int64_t distance_between_positions (Position first, Position second)
string get_clipped_seq (Alignment &a)
int64_t get_clipped_ref_position (Alignment &a)
Position get_clipped_position (Alignment &a)
Alignment remove_clipped_portion (Alignment &a)

Public Attributes

vg::VG * my_vg = NULL
PathPositionHandleGraph * my_path_position_graph = NULL
gcsa::GCSA * gcsa_ind
gcsa::LCPArray * lcp_ind
Mapper * my_mapper
map< int64_t, int64_t > node_to_position
unordered_map< string, unordered_map< string, int > > pos_to_edit_to_depth
unordered_map< int, int > pos_to_qual
bool inverse = false
bool do_remap = false
bool remove_failing_edits = false
bool filter_matches = false
bool use_avg = false
int min_depth = 0
int min_qual = 0
int min_cov = 0
int window_length = 0
int qual_offset = 0
int soft_clip_limit = -1
int split_read_limit = -1
double min_percent_identity = 0.0
double min_avg_qual = 0.0
int max_path_length = 0
int my_max_distance = 1000
float insert_mean = 1000
float insert_sd = 100

Constructor & Destructor Documentation

◆ Filter()

vg::Filter::Filter ( )

◆ ~Filter()

vg::Filter::~Filter ( )

Member Function Documentation

◆ anchored_filter()

bool vg::Filter::anchored_filter ( Alignment & aln)

◆ avg_qual_filter()

Alignment vg::Filter::avg_qual_filter ( Alignment & aln)

Helper function. Sums qual scores from start : start + window_length if start + window_len > qualstr.size(), return a negative float otherwise return the average quality within the window

◆ breakend_filter()

pair< Locus, Locus > vg::Filter::breakend_filter ( Alignment & aln_first,
Alignment & aln_second )

split reads or discordant reads/insert size may indicate a breakend but not a clean SV type we'd like to report all possible breakends, even if that don't match an SV type very well.

◆ coverage_filter()

Alignment vg::Filter::coverage_filter ( Alignment & aln)

◆ deletion_filter()

pair< Alignment, Alignment > vg::Filter::deletion_filter ( Alignment & aln_first,
Alignment & aln_second )

◆ depth_filter()

Alignment vg::Filter::depth_filter ( Alignment & aln)

If an edit fails the filter, either return a new empty alignment OR return a new alignment identical to the old one EXCEPT where the offending edit has been replaced by a match to the reference.

◆ distance_between_positions()

int64_t vg::Filter::distance_between_positions ( Position first,
Position second )

◆ duplication_filter()

pair< Locus, Locus > vg::Filter::duplication_filter ( Alignment & aln_first,
Alignment & aln_second )

Find reads that support duplications

◆ fill_node_to_position()

void vg::Filter::fill_node_to_position ( string pathname)

◆ get_clipped_position()

Position vg::Filter::get_clipped_position ( Alignment & a)

Get the position of the first match

Get the position of the first match

◆ get_clipped_ref_position()

int64_t vg::Filter::get_clipped_ref_position ( Alignment & a)

Get the position of the first match

Get the position of the first match

◆ get_clipped_seq()

string vg::Filter::get_clipped_seq ( Alignment & a)

◆ init_mapper()

void vg::Filter::init_mapper ( )

◆ insert_size_filter()

bool vg::Filter::insert_size_filter ( Alignment & aln_first,
Alignment & aln_second )

◆ insertion_filter()

pair< Locus, Locus > vg::Filter::insertion_filter ( Alignment & aln_first,
Alignment & aln_second )

Filters insertion-characterizing reads based upon discordant pairs (fragment length too short) one-end anchored / softclipped portions and read depth, one day

◆ interchromosomal_filter()

bool vg::Filter::interchromosomal_filter ( Alignment & aln_first,
Alignment & aln_second )

◆ inversion_filter()

bool vg::Filter::inversion_filter ( Alignment & aln_first,
Alignment & aln_second )

Find reads that support inversions split reads discordant insert size bad orientation instead of ----> <--— we'll see <-— <--— or ----> ----->

◆ is_left_clipped()

bool vg::Filter::is_left_clipped ( Alignment & a)

◆ mark_smallVariant_alignments()

bool vg::Filter::mark_smallVariant_alignments ( Alignment & a,
Alignment & b )

◆ mark_sv_alignments()

bool vg::Filter::mark_sv_alignments ( Alignment & a,
Alignment & b )

◆ one_end_anchored_filter()

bool vg::Filter::one_end_anchored_filter ( Alignment & aln_first,
Alignment & aln_second )

◆ pair_orientation_filter()

bool vg::Filter::pair_orientation_filter ( Alignment & aln_first,
Alignment & aln_second )

◆ path_divergence_filter()

Alignment vg::Filter::path_divergence_filter ( Alignment & aln)

Looks for alignments that transition from one path to another over their length. This may occur for one of several reasons:

  1. The read covers a translocation
  2. The read looks a lot like two different (but highly-similar paths)
  3. The read is shattered (e.g. as in chromothripsis)

Default behavior: if the Alignment is path divergent, return an empty Alignment, else return aln Inverse behavior: if the Alignment is path divergent, return aln, else return an empty Alignment

◆ path_length_filter()

Alignment vg::Filter::path_length_filter ( Alignment & aln)

◆ percent_identity_filter()

Alignment vg::Filter::percent_identity_filter ( Alignment & aln)

Filter reads that are less than <PCTID> reference. I.E. if a read matches the reference along 80% of its length, and your cutoff is 90% PCTID, throw it out.

◆ perfect_filter()

bool vg::Filter::perfect_filter ( Alignment & aln)

◆ qual_filter()

Alignment vg::Filter::qual_filter ( Alignment & aln)

Looks for Alignments that have large overhangs at the end of them.

Default behavior: if an alignment has a right- or left- clip that is longer than the maximum allowed, return an empty alignment.

Inverse Behavior: if the alignment has a clip that is larger than the maximum allowed at either end, return the alignment. CLI: vg filter -d 10 -q 40 -r -R -r: track depth of both novel variants and those in the graph. -R: remove edits that fail the filter (otherwise toss the whole alignment)

◆ refactor_split_alignment()

pair< Alignment, int > vg::Filter::refactor_split_alignment ( Alignment & a)

◆ remap() [1/2]

vector< Alignment > vg::Filter::remap ( Alignment & aln)

◆ remap() [2/2]

vector< Alignment > vg::Filter::remap ( string seq)

◆ remove_clipped_portion()

Alignment vg::Filter::remove_clipped_portion ( Alignment & a)

◆ reversing_filter()

Alignment vg::Filter::reversing_filter ( Alignment & aln)

Looks for alignments that change direction over their length. This may happen because of:

  1. Mapping artifacts
  2. Cycles
  3. Highly repetitive regions
  4. Inversions (if you're lucky enough)

Default behavior: if the Alignment reverses, return an empty Alignment. inverse behavior: if the Alignment reverses, return the Alignment.

◆ set_avg()

void vg::Filter::set_avg ( bool do_avg)

◆ set_filter_matches()

void vg::Filter::set_filter_matches ( bool fm)

◆ set_inverse()

void vg::Filter::set_inverse ( bool do_inv)

◆ set_min_depth()

void vg::Filter::set_min_depth ( int depth)

◆ set_min_percent_identity()

void vg::Filter::set_min_percent_identity ( double pct_id)

◆ set_min_qual()

void vg::Filter::set_min_qual ( int qual)

◆ set_my_path_position_graph()

void vg::Filter::set_my_path_position_graph ( PathPositionHandleGraph * graph)

◆ set_my_vg()

void vg::Filter::set_my_vg ( vg::VG * vg)

◆ set_remove_failing_edits()

void vg::Filter::set_remove_failing_edits ( bool fm)

◆ set_soft_clip_limit()

void vg::Filter::set_soft_clip_limit ( int max_clip)

◆ set_split_read_limit()

void vg::Filter::set_split_read_limit ( int split_limit)

◆ set_window_length()

void vg::Filter::set_window_length ( int window_length)

◆ soft_clip_filter()

bool vg::Filter::soft_clip_filter ( Alignment & aln)

◆ split_read_filter()

bool vg::Filter::split_read_filter ( Alignment & aln)

Split reads map to two separate paths in the graph OR vastly separated non-consecutive nodes in a single path.

They're super important for detecting structural variants, so we may want to filter them out or collect only split reads.

◆ unmapped_filter()

bool vg::Filter::unmapped_filter ( Alignment & aln)

Member Data Documentation

◆ do_remap

bool vg::Filter::do_remap = false

◆ filter_matches

bool vg::Filter::filter_matches = false

◆ gcsa_ind

gcsa::GCSA* vg::Filter::gcsa_ind

◆ insert_mean

float vg::Filter::insert_mean = 1000

◆ insert_sd

float vg::Filter::insert_sd = 100

◆ inverse

bool vg::Filter::inverse = false

◆ lcp_ind

gcsa::LCPArray* vg::Filter::lcp_ind

◆ max_path_length

int vg::Filter::max_path_length = 0

◆ min_avg_qual

double vg::Filter::min_avg_qual = 0.0

◆ min_cov

int vg::Filter::min_cov = 0

◆ min_depth

int vg::Filter::min_depth = 0

◆ min_percent_identity

double vg::Filter::min_percent_identity = 0.0

◆ min_qual

int vg::Filter::min_qual = 0

◆ my_mapper

Mapper* vg::Filter::my_mapper

◆ my_max_distance

int vg::Filter::my_max_distance = 1000

◆ my_path_position_graph

PathPositionHandleGraph* vg::Filter::my_path_position_graph = NULL

◆ my_vg

vg::VG* vg::Filter::my_vg = NULL

◆ node_to_position

map<int64_t, int64_t> vg::Filter::node_to_position

◆ pos_to_edit_to_depth

unordered_map<string, unordered_map<string, int> > vg::Filter::pos_to_edit_to_depth

◆ pos_to_qual

unordered_map<int, int> vg::Filter::pos_to_qual

◆ qual_offset

int vg::Filter::qual_offset = 0

◆ remove_failing_edits

bool vg::Filter::remove_failing_edits = false

◆ soft_clip_limit

int vg::Filter::soft_clip_limit = -1

◆ split_read_limit

int vg::Filter::split_read_limit = -1

◆ use_avg

bool vg::Filter::use_avg = false

◆ window_length

int vg::Filter::window_length = 0

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