Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://www.ncbi.nlm.nih.gov/IEB/ToolBox/CPP_DOC/doxyhtml/hspfilter__mapper_8c_source.html below:

NCBI C++ ToolKit: src/algo/blast/core/hspfilter_mapper.c Source File

chain->

;

(!list || !chain) {

(check_for_duplicates &&

(check_for_duplicates &&

cutoff_edit_dist)

(chain->

>= cutoff_score) {

num_identical = 0;

(cutoff_edit_dist < 0) {

(; h; h = h->

) {

(align_len - num_identical <= cutoff_edit_dist) {

list_score, chain_score;

(!list || !chain) {

(list_score > chain_score) {

(list_score < chain_score) {

(check_for_duplicates &&

(check_for_duplicates &&

cutoff_score,

cutoff_edit_dist,

(!list || !chain) {

(cutoff_score <= 0) {

(ch->

>= cutoff_score) {

best_score = list->

;

(ch->

&& best_score - ch->

->

<= margin) {

chain = chain->

;

chain = chain->

;

chain = chain->

;

(; chain; chain = chain->

,

=

->next) {

length * seq_error;

open_score +

(length, 4) * extend_score;

gap_open_score,

gap_extend_score)

kGap = 15;

num_identical = 0;

subject_gap = 0;

(num_matches >= 0);

score += num_matches;

num_identical += num_matches;

(subject_gap > 0) {

score += mismatch_score;

(subject_gap > 0) {

(subject_gap > 0) {

score += hsp->

.

- last_pos;

num_identical += hsp->

.

- last_pos;

overlap_f, overlap_s;

((

->query.offset <=

->query.offset &&

->query.end >=

->query.end) ||

(

->query.offset >=

->query.offset &&

->query.end <=

->query.end)) {

(

->score,

->score);

((

->query.end <

->query.offset &&

->query.offset <

->query.end) ||

(

->query.end <

->query.offset &&

->query.offset <

->query.end)) {

(

->query.offset <=

->query.offset) {

overlap_f = overlap_s =

->query.end - s->

.

;

(overlap_f >= 0 && overlap_s >= 0);

(

= 0;

<

->map_info->edits->num_edits;

++) {

(

->map_info->edits->edits[

].query_pos >= s->

.

) {

overlap_f -= edit_penalty;

overlap_s -= edit_penalty;

(overlap_f, overlap_s);

(!chain || !score_options) {

(comp_hsp_score) {

(comp_hsp_score) {

kGap = 15;

num_matches = hsp->

.

- last_pos - 1;

gap_open_score,

gap_extend_score,

* query_seq)

d = is_start ? 1 : -1;

delta_query = 0, delta_subject = 0;

is_subject = !is_query;

kGap = 15;

(

!= end && num_left > 0) {

delta_query += num_left;

delta_subject += num_left;

delta_subject += num_left;

delta_query += num_left;

(is_start &&

> 0) {

overhangs->

= realloc(overhangs->

,

(overhangs->

+ delta_subject) *

(!overhangs->

) {

subject_bases = overhangs->

+ overhangs->

;

overhangs->

+= delta_subject;

memcpy(subject_bases, query_seq + hsp->

.

, delta_subject);

subject_bases = overhangs->

;

memcpy(subject_bases, query_seq + hsp->

.

- delta_subject,

(k < hsp->map_info->edits->num_edits &&

kGap = 15;

(k < hsp->map_info->edits->num_edits &&

{0, 2, 0, 3, 1, 2, 2, 0, 0, 2, 0, 2},

{0, 3, 2, 2, 0, 0, 3, 3, 1, 3, 1, 2},

{1, 3, 2, 3, 1, 3, 1, 3, 3, 0, 3, 0},

{2, 0, 3, 1, 2, 2, 0, 0, 2, 0, 2, 1, 0, 1, 0, 1, 2, 3, 1, 3}};

adapter_start = -1;

from = hsp_from, to = hsp_to;

kMaxErrors = 1;

(adptr_idx = 0;!found && adptr_idx <

;adptr_idx++) {

* adapter = adapters_tab[adptr_idx];

q =

(to - lengths[adptr_idx], from);

(q < query_len - 4 && q +

< query_len &&

< lengths[adptr_idx]) {

(q < query_len - 4 && *(

*)(

+ q) != word) {

(q < query_len - 4) {

errors = kMaxErrors + 1;

(q +

< query_len &&

< lengths[adptr_idx] &&

(

[q +

] != adapter[

]) {

(q +

== query_len ||

== lengths[adptr_idx]) {

(adapter_start <= query_len);

adapter_start;

kMinAdapterLen = 3;

(!chains_ptr || !*chains_ptr || adapter_pos < 0) {

chain = *chains_ptr;

(query_len - h->

->

.

< kMinAdapterLen) {

chain = chain->

;

chain = chain->

;

chain->

= adapter_pos;

(

&&

->next != chain) {

(h && h->

->

.

<= adapter_pos) {

(hh && hh->

!= h) {

pos_minus = query_len - adapter_pos - 1;

(h && h->

->

.

<= pos_minus + 5) {

(

&&

->next != chain) {

(h != chain->

) {

(hh && hh->

!= h) {

chain = chain->

;

*chains_ptr =

;

(query_idx = 0;query_idx < query_info->

;query_idx++) {

from = -1, to = -1;

adapter_pos = -1;

(!saved[query_idx]) {

chain = saved[query_idx];

(; ch; ch = ch->

) {

(from >= 0 && to >= 0);

(from < 20 && to > query_len - 3) {

chain = saved[query_idx];

(; ch; ch = ch->

) {

(query_len - h->

->

.

> overhang) {

from = query_len - hsp->

.

;

(to >= query_len - 3) {

(adapter_pos >= 0) {

kBaseA = 0;

kMaxErrors = 3;

(

>= 0 && err < kMaxErrors) {

(sequence[

] != kBaseA) {

(

< length - 1 &&

(sequence[

] != kBaseA || sequence[

+ 1] != kBaseA)) {

(sequence[

] != kBaseA) {

num_a = length -

- err;

(num_a < 3 || (num_a < 5 && err > 0)) {

negative_start,

query_len)

(ch = chains; ch; ch = ch->

) {

((h->

->

.

< 0 && negative_start >= 0) ||

(query_idx = 0;query_idx < query_info->

;query_idx++) {

from = -1, to = -1;

positive_start, negative_start;

(!saved[query_idx] || saved[query_idx]->adapter >= 0) {

chain = saved[query_idx];

(; ch; ch = ch->

) {

(from >= 0 && to >= 0);

(from < 4 && to > query_len - 3) {

(positive_start >= 0 || negative_start >= 0) {

(saved[query_idx], positive_start, negative_start,

mismatches = 0;

kGap = 15;

(!

|| !second || !

|| !score_opts) {

(query_gap < 0 || subject_gap < 0) {

(

(query_gap, subject_gap) < 4) {

mismatches =

(query_gap, subject_gap);

query_gap -= mismatches;

subject_gap -= mismatches;

edits_size =

->map_info->edits->num_edits +

mismatches + query_gap + subject_gap;

(mismatches > 0) {

(query_gap > 0) {

(subject_gap > 0) {

(mismatches > 0) {

(k = 0;k < mismatches;k++) {

->subject_base =

->subject_base =

->query_base;

(query_gap > 0) {

(k = 0;k < query_gap;k++) {

->query_pos = merged_hsp->

.

+ mismatches;

->query_base = kGap;

->subject_base =

->subject_base = 0;

(subject_gap > 0) {

(k = 0;k < subject_gap;k++) {

->query_pos = merged_hsp->

.

+ mismatches + k;

->subject_base = kGap;

new_right_len *

(

));

new_right_len *

(

));

(query_idx = 0;query_idx + 1 < query_info->

; query_idx++) {

* chain = saved[query_idx];

* thepair = saved[query_idx + 1];

(!chain || !thepair) {

(chain->

== thepair->

) {

chain->

= thepair;

thepair->

= chain;

(

->score <

->score) {

(

->score >

->score) {

array_size = 10;

(query_idx = 0; query_idx < num_queries; query_idx++) {

* chain = saved[query_idx];

best_score = 0;

(!chain || !chain->

) {

(chain = saved[query_idx]; chain; chain = chain->

) {

(chain->

> best_score) {

best_score = chain->

;

chain = saved[query_idx];

(score < best_score) {

saved[query_idx] =

;

chain = chain->

;

(query_idx = 0; query_idx < num_queries; query_idx++) {

* chain = saved[query_idx];

best_score = 0;

best_pair_score = 0;

num_chains = 0;

(!chain->

) {

(chain = saved[query_idx]; chain; chain = chain->

) {

(score >= best_score) {

(num_chains >= array_size) {

[num_chains++] = chain;

(

= 0;

< num_chains;

++) {

(k < num_chains &&

[k]->score ==

[

]->score) {

(;

< k;

++) {

chain = saved[query_idx];

((!chain->

&& score < best_score) ||

saved[query_idx] =

;

chain = chain->

;

(

->oid >

->oid) {

(

->oid <

->oid) {

(

->hsps->hsp->subject.offset >

->hsps->hsp->subject.offset) {

(

->hsps->hsp->subject.offset <

->hsps->hsp->subject.offset) {

(*comp)(

*,

*))

array_size = 50;

(!saved || num_queries < 0) {

(

= 0;

< num_queries;

++) {

num_chains = 0;

(; chain; chain = chain->

) {

(num_chains >= array_size) {

chain_array = realloc(chain_array, array_size *

chain_array[num_chains++] = chain;

(num_chains > 1) {

qsort(chain_array, num_chains,

(

*), comp);

(k = 0;k < num_chains - 1;k++) {

chain_array[k]->

= chain_array[k + 1];

chain_array[num_chains - 1]->

=

;

saved[

] = chain_array[0];

(; h; h = h->

) {

memcpy(new_chain, chain,

(

));

new_chain->

= h;

->next = new_chain;

(; chain; chain = chain->

) {

cutoff_edit_distance)

(chain && !

(chain, cutoff_score, cutoff_edit_distance)

*chains_ptr = chain;

(chain && chain->

) {

chain = chain->

;

cutoff_edit_dist)

kPairBonus = 21;

(!getenv(

)) {

(getenv(

)) {

(query_idx = 0; query_idx < query_info->

; query_idx++) {

* chain = saved[query_idx];

(; chain; chain = chain->

) {

(query_idx = 0; query_idx < query_info->

; query_idx++) {

(&saved[query_idx], cutoff_score, cutoff_edit_dist);

(query_idx = 0; query_idx < query_info->

; query_idx++) {

* chain = saved[query_idx];

num_unique = 1;

chain = chain->

;

(; chain; chain = chain->

,

=

->next) {

(

->oid != chain->

||

(chain = saved[query_idx]; chain; chain = chain->

) {

chain->

= num_unique;

(query_idx = 0; query_idx < query_info->

; query_idx++) {

* chain = saved[query_idx];

(; chain; chain = chain->

) {

(; h; h = h->

) {

->chain_array = saved;

(!dest || !

) {

(

= 0;

< num;

++) {

(path->

) {

(!retval->

) {

kGap = 15;

((

->map_info->edits->num_edits > 0 &&

->map_info->edits->edits[

->map_info->edits->num_edits - 1].query_pos >=

num_second = 0;

(

=

->map_info->edits->num_edits - 1;

>= 0;

--) {

(edits[

].query_pos < second->

.offset) {

(edits[

].query_pos >=

->query.end) {

(num_first > num_second) {

(

->map_info->edits->num_edits > 0 &&

->map_info->edits->edits[

->map_info->edits->num_edits - 1].query_pos >=

num_edits =

->map_info->edits->num_edits;

(edits[num_edits - 1].query_pos >=

->query.end - 1) {

(edits[num_edits - 1].subject_base != kGap) {

(edits[num_edits - 1].query_pos == query_len - 2 &&

edits[num_edits - 1].subject_base == kGap) {

edge = (edge << 2) |

[query_len - 1];

(edits[num_edits - 1].subject_base != kGap &&

edits[num_edits - 1].query_base != kGap) {

[edits[num_edits - 1].query_pos + 1];

(edits[num_edits - 1].subject_base == kGap) {

[edits[num_edits - 1].query_pos + 2];

[edits[num_edits - 1].query_pos];

trim_by =

->query.end - edits[

(edits[num_edits - 1].query_base == kGap) {

->map_info->right_edge = edge;

(num_second > num_first) {

->query.end) {

(edits[0].query_pos == 0) {

(edits[0].subject_base != kGap) {

(edits[0].query_pos == 1 &&

edits[0].subject_base == kGap) {

edge = (edge << 2) |

[0];

edits[0].subject_base;

(edits[0].subject_base == kGap) {

[edits[0].query_pos - 1];

(edits[0].query_base == kGap) {

((

->map_info->edits->num_edits > 0 &&

->map_info->edits->edits[

->map_info->edits->num_edits - 1].query_pos >=

overlap_len *

(

));

[2 + overlap_len] = (

->map_info->right_edge & 0xf) >> 2;

[2 + overlap_len + 1] =

->map_info->right_edge & 3;

(k = 0;k < num_signals;k++) {

(

= 0;

<= overlap_len && !found;

++) {

(seq == signals[k]) {

->query.end -= d;

->subject.end -= d;

->gap_info->num[

->gap_info->size - 1] -= d;

->num_ident -= d;

->map_info->right_edge = (seq & 0xf0) >> 4;

second->

-= d;

->subject.end -

->subject.offset);

subject_from,

subject_to,

query_gap = query_to - query_from + 1;

subject_gap = subject_to - subject_from + 1;

query_ext_len, subject_ext_len;

ungapped_ext_len;

jumper_mismatch[] = {{1, 1, 0, 0}};

jumper_insertion[] = {{1, 1, 2, 0},

jumper_deletion[] = {{1, 1, 2, 0},

(

= 0;

< o_len;

++, k-=2) {

(!gap_align->

) {

(

(query_gap - subject_gap)) {

0: jumper_table = jumper_mismatch;

-1: jumper_table = jumper_deletion;

1: jumper_table = jumper_insertion;

query_gap, subject_gap,

&query_ext_len, &subject_ext_len,

(query_ext_len <= query_gap);

(subject_ext_len <= subject_gap);

(query_ext_len < query_gap) {

(subject_ext_len < subject_gap) {

(query_ext_len == query_gap);

(subject_ext_len == subject_gap);

gap_align->

= query_from + query_ext_len;

gap_align->

= subject_from + subject_ext_len;

hsp->

.

+= query_ext_len;

first_len, second_len;

(!

|| !second) {

(!

->map_info->subject_overhangs ||

!

->map_info->subject_overhangs->right ||

(query_gap >

->map_info->subject_overhangs->right_len - 2 ||

first_len =

->map_info->subject_overhangs->right_len;

(q = 0; !found && q < 4;q++) {

(

->query.end - q <= first->

.offset) {

seq = (

->map_info->subject_overhangs->right[0] << 6) |

(

->map_info->subject_overhangs->right[1] << 4);

seq = (

[

->query.end - 1] << 6) |

(

->map_info->subject_overhangs->right[0] << 4);

seq = (

[

->query.end - q] << 6) |

(seq != (signals[k] & 0xf0)) {

(

=

(start - 1, 0);

<=

(start + 1, second_len - 2);

++) {

(seq == signals[k]) {

subject_gap = second_len - (

+ 2) + q;

(query_gap - subject_gap < -1 ||

query_gap - subject_gap > 1) {

(q = 0; !found && q < 4;q++) {

(seq != (signals[k] & 0xf)) {

end = query_gap + q;

(

=

(end - 1, 0);

<=

(end + 1, first_len - 2);

++) {

seq |= (

->map_info->subject_overhangs->right[

] << 6) |

(

->map_info->subject_overhangs->right[

+ 1] << 4);

(seq == signals[k]) {

subject_gap =

- q;

(query_gap - subject_gap < -1 ||

query_gap - subject_gap > 1) {

->map_info->right_edge = (signal & 0xf0) >> 4;

->subject.end -

->subject.offset);

h->

= following;

(!chains || !query_blk || !query_info || !scoring_opts) {

(ch = chains; ch; ch = ch->

) {

scoring_opts,

);

h->

= following;

consensus_only =

;

query_len, consensus_only);

query_len, scoring_opts);

longest_intron,

best_score = 0;

kMaxIntronLength = longest_intron;

(!path || !nodes || !num) {

(

= num - 1;

>= 0;

--) {

(k =

+ 1;k < num && is_spliced;k++) {

new_score = nodes[k].

+ self_score - overlap_cost;

hsp_len = hsp->query.end - hsp->query.offset;

subj_overlap_len =

(newhsp->

.

> hsp->query.offset &&

newhsp->

.

> hsp->query.end &&

newhsp->

.

- hsp->subject.end < kMaxIntronLength &&

(

)overlap_len / hsp_len < 0.75 &&

(

)overlap_len / newhsp_len < 0.75 &&

(

)subj_overlap_len / hsp_len < 0.75 &&

(

)subj_overlap_len / newhsp_len < 0.75) {

new_score += chain->

+ overlap_cost -

(newhsp->

+ self_score);

(newhsp->

.

- hsp->query.end == 1) {

(new_score > nodes[

].best_score) {

(nodes[

].best_score == best_score) {

(nodes[

].best_score > best_score) {

path->

[0] = &(nodes[

]);

(!path->

[

]) {

(!path->

[k]) {

(node_i->

[0] == node_k->

[0]) {

node = path->

[

];

(path->

< cutoff_score) {

(

->score >

->score) {

(

->score <

->score) {

(

->conf <

->conf) {

(

->conf >

->conf) {

(

->distance <

->distance) {

(

->distance >

->distance) {

mismatch_score,

gap_open_score,

gap_extend_score,

(!chain || subj_pos < 0) {

old_score = hsp->

;

gap_extend_score,

);

mismatch_score,

gap_open_score,

gap_extend_score,

(!chain || subj_pos <= 0 || !query_blk || !query_info) {

old_score = hsp->

;

gap_extend_score,

);

(chain->

!= h) {

(hc && hc->

!= h) {

* max_num_pairs,

* pair_info = *pair_info_ptr;

conv_bonus = 0;

kMaxInsertSize = is_spliced ?

(second = *second_list; second; second = second->

) {

first_frame =

->hsps->hsp->query.frame;

(num_pairs >= *max_num_pairs) {

*max_num_pairs *= 2;

realloc(pair_info, *max_num_pairs *

(

));

(!new_pair_info) {

pair_info = new_pair_info;

*pair_info_ptr = new_pair_info;

pair_info[num_pairs].

= second;

pair_info[num_pairs].

= 0;

(first_frame != 0 && second_frame != 0);

(

(first_frame) !=

(second_frame)) {

plus_start, minus_start;

(first_frame > 0) {

(second_frame > 0) {

plus_start =

->hsps->hsp->subject.offset;

(hsp->

) {

distance = minus_start - plus_start;

pair_info[num_pairs].

= distance;

(distance > 0 && distance < kMaxInsertSize) {

plus_end, minus_end;

(hsp->

) {

minus_end =

->hsps->hsp->subject.offset;

(plus_end > minus_start || minus_end < plus_start) {

(plus_end > minus_start) {

(plus_end - minus_start > 0);

pair_info[num_pairs].

-=

plus_end - minus_start;

(

== pair_info[num_pairs].

) {

pair_info[num_pairs].

= minus_start;

(minus_end < plus_start) {

(plus_start - minus_end > 0);

pair_info[num_pairs].

-=

plus_start - minus_end;

(

== pair_info[num_pairs].

) {

pair_info[num_pairs].

= plus_start;

pair_info[num_pairs].

+= conv_bonus;

(pair_info[num_pairs].score < min_score) {

pair_info[num_pairs].

-= 1;

(num_pairs > 0) {

(

=0;

< num_pairs;

++) {

convergent_found =

;

(best_score - pair_info[

].score > margin) {

(ch = *first_list; ch; ch = ch->

) {

(

< num_pairs &&

(pair_info[

].

!= ch || !pair_info[

].second->

||

best_score - pair_info[

].

> margin)) {

(

>= num_pairs) {

pair_info[

].

= pair;

(ch = *second_list; ch; ch = ch->

) {

(

< num_pairs &&

(pair_info[

].second != ch || !pair_info[

].

->pair ||

best_score - pair_info[

].

> margin)) {

(

>= num_pairs) {

pair_info[

].

= pair;

(

= 0;

< num_pairs;

++) {

(!pair_info[

].valid_pair ||

(pair_info[

].trim_first > 0) {

(pair_info[

].

->hsps->hsp->query.frame > 0) {

pair_info[

].trim_first,

pair_info[

].trim_first,

(pair_info[

].trim_second > 0) {

pair_info[

].trim_second,

pair_info[

].trim_second,

(chain = saved[

]; chain; chain = chain->

) {

(chain->

!= oid) {

(chain->

< 30) {

kDefaultMaxHsps = 1000;

max_hsps = kDefaultMaxHsps;

workspace_size = 40;

kPairBonus = is_spliced ? 21 : 5;

(!params || !nodes) {

chain_array[0] =

;

chain_array[1] =

;

(i < hsp_list->hspcnt) {

context_next_fragment = has_pair ? (query_idx + 2) *

:

(i < hsp_list->hspcnt &&

hsp_array[

]->

< context_next_fragment) {

memset(nodes, 0, num_hsps *

(

));

(i < hsp_list->hspcnt && hsp_array[

]->

==

) {

(num_hsps >= max_hsps) {

nodes[num_hsps].

= &(hsp_array[

]);

(cutoff_score_fun[1] != 0) {

cutoff_score = (cutoff_score_fun[0] +

cutoff_score_fun[1] * query_len) / 100;

hsp_list->

, is_spliced,

kLongestIntron, cutoff_score,

query_blk, query_info, scoring_opts);

&new_chains, cutoff_score, cutoff_edit_dist,

(i < hsp_list->hspcnt && hsp_array[

]->

==

) {

(is_spliced && chain_array[0]) {

(is_spliced && chain_array[1]) {

= chain_array[0];

second = chain_array[1];

(

&& second) {

&workspace_size, is_spliced, scoring_opts,

query_blk, query_info);

cutoff_edit_dist,

);

(!saved_chains[query_idx] ||

cutoff_score, cutoff_edit_dist,

);

(!saved_chains[query_idx + 1] ||

chain_array[0] = chain_array[1] =

;

->params = params;

->query_info = query_info;

(hit_options ==

)

writer_info->

= params;

#define sfree(x)

Safe free a pointer: belongs to a higher level header.

#define NUM_STRANDS

Number of frames in a nucleotide sequence.

BlastGapAlignStruct * BLAST_GapAlignStructFree(BlastGapAlignStruct *gap_align)

Deallocates memory in the BlastGapAlignStruct structure.

Structures and API used for saving BLAST hits.

BlastHSP * Blast_HSPClone(const BlastHSP *hsp)

Make a deep copy of an HSP.

BlastHSP * Blast_HSPFree(BlastHSP *hsp)

Deallocate memory for an HSP structure.

BlastHSPList * Blast_HSPListFree(BlastHSPList *hsp_list)

Deallocate memory for an HSP list structure as well as all it's components.

#define MAGICBLAST_MAX_INSERT_SIZE_NONSPLICED

#define MAGICBLAST_MAX_INSERT_SIZE_SPLICED

Default maximum insert size: distance on the subject between reads that belong to a pair,...

@ eFirstSegment

The first sequence of a pair with both sequences read and accepted.

Various auxiliary BLAST utility functions.

static DLIST_TYPE *DLIST_NAME() first(DLIST_LIST_TYPE *list)

static DLIST_TYPE *DLIST_NAME() last(DLIST_LIST_TYPE *list)

static DLIST_TYPE *DLIST_NAME() prev(DLIST_LIST_TYPE *list, DLIST_TYPE *item)

static DLIST_TYPE *DLIST_NAME() next(DLIST_LIST_TYPE *list, DLIST_TYPE *item)

EGapAlignOpType

Operation types within the edit script.

@ eGapAlignIns

Insertion: a gap in subject.

@ eGapAlignSub

Substitution.

@ eGapAlignDel

Deletion: a gap in query.

GapEditScript * GapEditScriptDelete(GapEditScript *esp)

Free edit script structure.

uint8_t Uint1

1-byte (8-bit) unsigned integer

int16_t Int2

2-byte (16-bit) signed integer

int32_t Int4

4-byte (32-bit) signed integer

uint32_t Uint4

4-byte (32-bit) unsigned integer

static BlastHSP * s_MergeHSPs(const BlastHSP *first, const BlastHSP *second, const Uint1 *query, const ScoringOptions *score_opts)

static Int4 HSPChainListTrim(HSPChain *list, Int4 margin)

static Int4 s_HSPChainListInsertOne(HSPChain **list, HSPChain *chain, Boolean check_for_duplicates)

static Int4 s_HSPChainListInsertOne_OLD(HSPChain **list, HSPChain *chain, Boolean check_for_duplicates)

static Int4 s_TrimOverlap(BlastHSP *first, BlastHSP *second, const Uint1 *query)

static Boolean s_TestCutoffs(HSPChain *chain, Int4 cutoff_score, Int4 cutoff_edit_dist)

static Int4 s_ComputeGapScore(Int4 length, Int4 open_score, Int4 extend_score, Int4 seq_error)

static Int4 s_FindPolyATails(HSPChain **saved, const BLAST_SequenceBlk *query_blk, const BlastQueryInfo *query_info)

static Int4 s_FindSpliceJunctionsForOverlaps(BlastHSP *first, BlastHSP *second, Uint1 *query, Int4 query_len, Boolean consensus_only)

static Boolean s_TestHSPRanges(const BlastHSP *hsp)

#define MAX_NUM_HSP_PATHS

static void s_ExtendAlignmentCleanup(Uint1 *subject, BlastGapAlignStruct *gap_align, GapEditScript *edit_script, JumperEditsBlock *edits)

static int s_CompareHSPsByContextScore(const void *v1, const void *v2)

static Int2 s_SetAdapter(HSPChain **chains_ptr, Int4 adapter_pos, const Uint1 *query, Int4 query_len, const ScoringOptions *scores)

static Int4 s_SetPolyATail(HSPChain *chains, Int4 positive_start, Int4 negative_start, Int4 query_len)

static int s_FindRearrangedPairs(HSPChain **saved, const BlastQueryInfo *query_info)

static Int4 s_GetChainScore(const HSPChain *chain)

HSPChain * FindPartialyCoveredQueries(void *data, Int4 oid, Int4 word_size)

Find HSP chains that do not cover full extend of queries for a given subject.

BlastHSPWriterInfo * BlastHSPMapperInfoNew(BlastHSPMapperParams *params)

WriterInfo to create a default writer: the collecter.

static Int4 s_ExtendAlignment(BlastHSP *hsp, const Uint1 *query, Int4 query_from, Int4 query_to, Int4 subject_from, Int4 subject_to, const ScoringOptions *score_options, Boolean is_left)

#define NUM_SIGNALS_CONSENSUS

static HSPPath * HSPPathFree(HSPPath *path)

static BlastHSPWriter * s_BlastHSPMapperFree(BlastHSPWriter *writer)

Free the writer.

static Int4 s_TrimHSP(BlastHSP *hsp, Int4 num, Boolean is_query, Boolean is_start, Int4 mismatch_score, Int4 gap_open_score, Int4 gap_extend_score, const Uint1 *query_seq)

static BlastHSPWriter * s_BlastHSPMapperPairedNew(void *params, BlastQueryInfo *query_info, BLAST_SequenceBlk *query)

create the writer

static Int4 s_GetOverlapCost(const BlastHSP *a, const BlastHSP *b, Int4 edit_penalty)

static Boolean s_TestChains(HSPChain *chain)

static int s_BlastHSPMapperFinal(void *data, void *mapping_results)

Perform post-run clean-ups.

static int s_FilterChains(HSPChain **chains_ptr, Int4 cutoff_score, Int4 cutoff_edit_distance)

static Int4 s_ComputeAlignmentScore(BlastHSP *hsp, Int4 mismatch_score, Int4 gap_open_score, Int4 gap_extend_score)

static Int4 s_FindFragmentStart(HSPChain *chain)

BlastHSPMapperParams * BlastHSPMapperParamsNew(const BlastHitSavingOptions *hit_options, const BlastScoringOptions *scoring_options)

The following are exported functions to be used by APP.

static Int4 s_FindSpliceJunctions(HSPChain *chains, const BLAST_SequenceBlk *query_blk, const BlastQueryInfo *query_info, const ScoringOptions *scoring_opts)

static Int4 s_IntronToGap(HSPContainer *h, HSPContainer *next, const Uint1 *query, const ScoringOptions *scoring_opts)

static Int4 s_ComputeChainScore(HSPChain *chain, const ScoringOptions *score_options, Int4 query_len, Boolean comp_hsp_score)

static int s_CompareChainsByOid(const void *cha, const void *chb)

struct BlastHSPMapperData BlastHSPMapperData

Data structure used by the writer.

static int s_CompareHSPsByContextSubjectOffset(const void *v1, const void *v2)

static int s_HSPNodeArrayCopy(HSPNode *dest, HSPNode *source, Int4 num)

static Int4 s_FindSpliceJunctionsForGap(BlastHSP *first, BlastHSP *second, Uint1 *query, Int4 query_len, const ScoringOptions *score_options)

static HSPChain * s_FindBestPath(HSPNode *nodes, Int4 num, HSPPath *path, Int4 oid, Boolean is_spliced, Int4 longest_intron, Int4 cutoff_score, const BLAST_SequenceBlk *query_blk, const BlastQueryInfo *query_info, const ScoringOptions *scoring_opts)

static Int4 s_FindPolyAInSequence(Uint1 *sequence, Int4 length)

static int s_Finalize(HSPChain **saved, BlastMappingResults *results, const BlastQueryInfo *query_info, const BLAST_SequenceBlk *query_blk, const ScoringOptions *score_opts, Boolean is_paired, Int4 cutoff_score, Int4 cutoff_edit_dist)

static Boolean s_FindBestPairs(HSPChain **first_list, HSPChain **second_list, Int4 min_score, Pairinfo **pair_info_ptr, Int4 *max_num_pairs, Boolean is_spliced, const ScoringOptions *scoring_options, const BLAST_SequenceBlk *query_blk, const BlastQueryInfo *query_info)

static Int4 s_SortChains(HSPChain **saved, Int4 num_queries, int(*comp)(const void *, const void *))

static int s_RemoveOverlaps(HSPChain *chain, const ScoringOptions *score_opts, Int4 query_len)

static HSPPath * HSPPathNew(void)

static int s_BlastHSPMapperPairedInit(void *data, void *results)

The following are implementations for BlastHSPWriter ADT.

static Int4 HSPChainListInsert(HSPChain **list, HSPChain **chain, Int4 cutoff_score, Int4 cutoff_edit_dist, Boolean check_for_duplicates)

static int s_CompareChainsByScore(const void *cha, const void *chb)

static Boolean s_TestChainsSorted(HSPChain *chain)

static void s_BlastHSPMapperSplicedRunCleanUp(HSPPath *path, HSPNode *nodes, Pairinfo *pair_data)

static Int4 s_FindAdapterInSequence(Int4 hsp_from, Int4 hsp_to, Uint1 *query, Int4 query_len)

BlastHSPMapperParams * BlastHSPMapperParamsFree(BlastHSPMapperParams *opts)

Deallocates the BlastHSPMapperParams structure passed in.

static Int4 s_TrimChainStartToSubjPos(HSPChain *chain, Int4 subj_pos, Int4 mismatch_score, Int4 gap_open_score, Int4 gap_extend_score, const BLAST_SequenceBlk *query_blk, const BlastQueryInfo *query_info)

static Int4 s_FindAdapters(HSPChain **saved, const BLAST_SequenceBlk *query_blk, const BlastQueryInfo *query_info, const ScoringOptions *score_opts)

static int s_ComparePairs(const void *v1, const void *v2)

static int s_PruneChains(HSPChain **saved, Int4 num_queries, Int4 pair_bonus)

static int s_BlastHSPMapperSplicedPairedRun(void *data, BlastHSPList *hsp_list)

Perform writing task for paired reads ownership of the HSP list and sets the dereferenced pointer to ...

static Int4 s_TrimChainEndToSubjPos(HSPChain *chain, Int4 subj_pos, Int4 mismatch_score, Int4 gap_open_score, Int4 gap_extend_score, const BLAST_SequenceBlk *query_blk, const BlastQueryInfo *query_info)

Implementation of a number of BlastHSPWriters to save the best chain of RNA-Seq hits to a genome.

JumperEditsBlock * JumperEditsBlockFree(JumperEditsBlock *block)

JumperGapAlign * JumperGapAlignNew(Int4 size)

JumperEditsBlock * JumperEditsBlockCombine(JumperEditsBlock **block_ptr, JumperEditsBlock **append_ptr)

Int4 JumperPrelimEditBlockAdd(JumperPrelimEditBlock *block, JumperOpType op)

GapEditScript * GapEditScriptCombine(GapEditScript **edit_script_ptr, GapEditScript **append_ptr)

JumperEditsBlock * JumperFindEdits(const Uint1 *query, const Uint1 *subject, BlastGapAlignStruct *gap_align)

GapEditScript * JumperPrelimEditBlockToGapEditScript(JumperPrelimEditBlock *rev_prelim_block, JumperPrelimEditBlock *fwd_prelim_block)

Convert Jumper's preliminary edit script to GapEditScript.

Int4 GetCutoffScore(Int4 query_length)

Get alignment cutoff score for a given query length.

Int4 JumperExtendRightWithTraceback(const Uint1 *query, const Uint1 *subject, int query_length, int subject_length, Int4 match_score, Int4 mismatch_score, Int4 gap_open_score, Int4 gap_extend_score, int max_mismatches, int window, Int4 *query_ext_len, Int4 *subject_ext_len, JumperPrelimEditBlock *edit_script, Int4 *num_identical, Boolean left_extension, Int4 *ungapped_ext_len, JUMP *jumper)

Right extension with traceback.

#define MAPPER_SPLICE_SIGNAL

if(yy_accept[yy_current_state])

const CharType(& source)[N]

#define MIN(a, b)

returns smaller of a and b.

#define SIGN(a)

return +1 for a > 0, -1 for a < 0

Uint1 Boolean

bool replacment for C

#define TRUE

bool replacment for C indicating true.

#define FALSE

bool replacment for C indicating false.

#define ASSERT

macro for assert.

#define MAX(a, b)

returns larger of a and b.

double r(size_t dimension_, const Int4 *score_, const double *prob_, double theta_)

HSPChain * HSPChainFree(HSPChain *chain_list)

Deallocate a chain or list of chains.

HSPContainer * HSPContainerNew(BlastHSP **hsp)

Create HSPContainer and take ownership of the HSP.

HSPChain * HSPChainNew(Int4 context)

Allocate a chain.

HSPContainer * HSPContainerFree(HSPContainer *hc)

Free the list of HSPs, along with the stored HSPs.

HSPChain * CloneChain(const HSPChain *chain)

Clone a single HSP chain.

Structure to hold a sequence.

Uint1 * sequence

Sequence used for search (could be translation).

Int4 query_length

Length of this query, strand or frame.

Int4 segment_flags

Flags describing segments for paired reads.

Int4 query_offset

Offset of this query, strand or frame in the concatenated super-query.

Structure supporting the gapped alignment.

Int4 query_stop

query end offseet of current alignment

Int4 subject_start

subject start offset current alignment

Int4 query_start

query start offset of current alignment

Int4 subject_stop

subject end offset of current alignment

JumperGapAlign * jumper

data for jumper alignment

The structure to hold all HSPs for a given sequence after the gapped alignment.

Int4 oid

The ordinal id of the subject sequence this HSP list is for.

Int4 hspcnt

Number of HSPs saved.

BlastHSP ** hsp_array

Array of pointers to individual HSPs.

Data structure used by the writer.

BlastQueryInfo * query_info

information about queries

HSPChain ** saved_chains

HSP chains are stored here.

BLAST_SequenceBlk * query

query sequence

BlastHSPMapperParams * params

how many hits to save

Keeps prelim_hitlist_size and HitSavingOptions together.

Int4 cutoff_edit_dist

max edit distance to accept a chain alignment

Int4 hitlist_size

number of hits saved during preliminary part of search.

Boolean paired

mapping with paired reads

EBlastProgramType program

program type

Int4 cutoff_score

min score to accept a chain alignment

ScoringOptions scoring_options

scores for match, mismatch, and gap

Int4 cutoff_score_fun[2]

coefficients for cutoff score as a function of query length: x[0] + x[1] * length

Boolean splice

mapping spliced reads (RNA-seq to a genome)

Int4 longest_intron

max intron length

Uint1 left_edge

Two subject bases before the alignment in the four least significant bits and flags in most significa...

JumperEditsBlock * edits

Information about mismatches and gaps, used for mapping short reads.

SequenceOverhangs * subject_overhangs

Unaligned subject subsequence.

The structure to contain all BLAST results, for multiple queries.

A wrap of data structure used to create a writer.

BlastHSPWriterNewFn NewFnPtr

ADT definition of BlastHSPWriter.

void * data

data structure

BlastHSPWriterFinalFn FinalFnPtr

BlastHSPWriterFreeFn FreeFnPtr

BlastHSPWriterRunFn RunFnPtr

BlastHSPWriterInitFn InitFnPtr

Structure holding all information about an HSP.

Int4 num_ident

Number of identical base pairs in this HSP.

BlastSeg query

Query sequence info.

Int4 context

Context number of query.

BlastSeg subject

Subject sequence info.

GapEditScript * gap_info

ALL gapped alignment is here.

Int4 score

This HSP's raw score.

BlastHSPMappingInfo * map_info

Options used when evaluating and saving hits These include: a.

EBlastProgramType program_number

indicates blastn, blastp, etc.

Int4 longest_intron

The longest distance between HSPs allowed for combining via sum statistics with uneven gaps.

Int4 cutoff_score

The (raw) score cut-off threshold.

Boolean paired

Splice HSPs for each query (for mapping RNA-Seq to a genome)

Int4 hitlist_size

Maximal number of database sequences to return results for.

Int4 max_edit_distance

Maximum number of mismatches and gaps.

Int4 cutoff_score_fun[2]

Coefficients x100 for the raw score cut-off threshold as a function of query length: x[0] + x[1] * qu...

Structure that contains BLAST mapping results.

The query related information.

BlastContextInfo * contexts

Information per context.

int num_queries

Number of query sequences.

Scoring options block Used to produce the BlastScoreBlk structure This structure may be needed for lo...

Int2 penalty

Penalty for a mismatch.

Int4 gap_open

Extra penalty for starting a gap.

Int4 gap_extend

Penalty for each gap residue.

Int2 reward

Reward for a match.

Int2 frame

Translation frame.

Int4 offset

Start of hsp.

Edit script: linked list of correspondencies between two sequences.

Int4 * num

Array of number of operations.

Int4 size

Size of above arrays.

EGapAlignOpType * op_type

Array of type of operation.

A chain of HSPs: spliced alignment.

Int4 score

Alignment score for the chain.

Int4 count

Number of placements for the read.

HSPContainer * hsps

A list of HSPs that belong to this chain.

Int4 polyA

Position of detected PolyA sequence in the query.

Uint1 pair_conf

Pair configuration.

Int4 context

Contex number of query sequence.

struct HSPChain * next

Pointer to the next chain in a list.

struct HSPChain * pair

Pointer to mapped mate alignmemt (for paired reads)

Int4 adapter

Position of detected adapter sequence in the query.

struct HSPContainer * next

struct HSPNode * path_next

Uint1 query_base

Query base at this position.

Uint1 subject_base

Subject base at this position.

Int4 query_pos

Query position.

Alignment edit script for gapped alignment.

JumperPrelimEditBlock * left_prelim_block

JumperPrelimEditBlock * right_prelim_block

Structure to save short unaligned subsequences outside an HSP.

Uint1 * left

Left subsequence.

Uint1 * right

Rught subsequence.

Int4 right_len

Length of the right subsequence.

Int4 left_len

Length of the left subsequence.

static CS_CONTEXT * context

voidp calloc(uInt items, uInt size)

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4