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

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

NCBI C++ ToolKit: src/algo/primer/primercheck.cpp Source File

: m_TemplateHandle(template_handle),

m_WordSize(word_size),

m_AllowedTotalMismatch(allowed_total_mismatch),

m_Allowed3EndMismatch(allowed_3end_mismatch),

m_MaxMismatch(max_mismatch),

m_MismatchRegionLength3End(10),

m_NumNonSpecificTarget(20),

m_MaxTargetPerSequence(100)

(!input_seqalign.

().empty()){

m_FeatureScope(

)

master_gap_char,

slave_gap_char) {

(

= 0;

< (

)xcript.size();

++){

(xcript[

] == master_gap_char) {

(

= (

)xcript.size() - 1;

>= 0;

--){

(xcript[

] == master_gap_char) {

(master_start_gap == 0) {

(xcript[

] == slave_gap_char) {

(master_end_gap == 0){

(

= (

)xcript.size() - 1;

>= 0;

--){

(xcript[

] == slave_gap_char) {

& max_num_continuous_match,

num_continuous_match = 0;

num_total_mismatch = 0;

num_3end_mismatch = 0;

max_num_continuous_match = 0;

master_string;

master_letter_len = 0;

(

=0;

< (

)master_string.size();

++){

(master_string[

] != gap_char) {

master_letter_len ++;

(

=0;

< (

)master_string.size();

++){

(master_string[

] == gap_char) {

(is_left_primer) {

}

(slave_string[

] == gap_char) {

(is_left_primer) {

}

(master_string[

]!=slave_string[

]){

(is_left_primer) {

num_3end_mismatch ++;

num_3end_mismatch ++;

num_total_mismatch ++;

(master_string[

]== slave_string[

]){

num_continuous_match ++;

(max_num_continuous_match < num_continuous_match) {

max_num_continuous_match = num_continuous_match;

num_continuous_match = 0;

(master_string[0] == gap_char ||

master_string[(

)master_string.size() - 1] == gap_char ||

slave_string[0] == gap_char ||

slave_string[(

)slave_string.size() - 1] == gap_char ||

& nw_align_modified) {

nw_align_modified =

;

hit_full_start, hit_seq);

(hit_full_start, hit_full_stop + 1, hit_seq);

aligner->SetScoreMatrix(

);

xcript = aligner->GetTranscriptString();

den_ref = aligner->GetDense_seg(desired_align_range.

(),

(xcript, master_start_gap, master_end_gap, slave_start_gap, slave_end_gap,

,

);

(slave_start_gap > 0 || slave_end_gap > 0) {

new_hit_full_start =

((

)(hit_full_start - slave_start_gap), 0);

GetBioseqLength() - 1);

new_hit_full_start =

((

)(hit_full_start - slave_end_gap), 0);

GetBioseqLength() - 1);

(!(new_hit_full_start == hit_full_start &&

new_hit_full_stop == hit_full_stop)) {

(

= hit_full_start - new_hit_full_start - 1;

>= 0 ;

--){

(

= (

)xcript.size() - 1 - (new_hit_full_stop - hit_full_stop);

< (

)xcript.size();

++) {

(

= new_hit_full_stop - hit_full_stop - 1;

>= 0 ;

--){

(

= (

)xcript.size() - 1 - (hit_full_start - new_hit_full_start);

< (

)xcript.size();

++) {

hit_full_start = new_hit_full_start;

hit_full_stop = new_hit_full_stop;

den_ref->

().push_back(master_id);

den_ref->

().push_back(slave_id);

nw_align_modified =

;

(master_start_gap > 0 || master_end_gap > 0) {

xcript = xcript.substr(master_start_gap);

xcript = xcript.substr(0, xcript.size() - master_end_gap);

new_hit_full_start = hit_full_start + master_start_gap;

new_hit_full_stop = hit_full_stop - master_end_gap;

new_hit_full_start = hit_full_start + master_end_gap;

new_hit_full_stop = hit_full_stop - master_start_gap;

den_ref->

().push_back(master_id);

den_ref->

().push_back(slave_id);

nw_align_modified =

;

& max_num_continuous_match,

& nw_align_modified) {

desired_align_range.

() + 1, master_seq);

full_master_stop =

(desired_align_range.

(), master_local_stop);

full_master_range(full_master_start, full_master_stop);

longest_chunk_index = 0;

longest_chunk_size = 0;

(

chunk_index = 0; chunk_index < master_chunk->size(); chunk_index ++) {

chunk_ref = (*master_chunk)[chunk_index];

(!chunk_ref->IsGap()) {

(chunk_ref->GetAlnRange().GetLength() > longest_chunk_size) {

longest_chunk_size = chunk_ref->GetAlnRange().GetLength();

longest_chunk_index = chunk_index;

longest_chunk_range = (*master_chunk)[longest_chunk_index]->GetRange();

hit_start_adjust = longest_chunk_range.

() -

desired_align_range.

();

hit_stop_adjust = desired_align_range.

() -

longest_chunk_range.

();

hit_start_adjust), 0);

GetBioseqLength() - 1);

hit_stop_adjust), 0);

nw_align_modified =

;

master_seq, *av, hit_full_start,

hit_strand, xcript, nw_align_modified);

num_continuous_match = 0;

max_num_continuous_match = 0;

(!nw_align_modified) {

align_length = (

)xcript.size();

(

, iter, xcript) {

master_letter_len = (

)xcript.size() - num_master_gap;

(

, the_iter, xcript) {

(is_left_primer) {

num_continuous_match = 0;

(is_left_primer) {

num_continuous_match ++;

(max_num_continuous_match < num_continuous_match) {

max_num_continuous_match = num_continuous_match;

(is_left_primer) {

num_continuous_match = 0;

(is_left_primer) {

num_continuous_match = 0;

num_total_mismatch = total_mismatch;

num_total_gap = total_insertion + total_deletion;

num_3end_mismatch = mismatch_3end;

num_3end_gap = insertion_3end + deletion_3end;

num_total_mismatch = 0;

num_3end_mismatch = 0;

max_num_continuous_match = 0;

IntersectionWith(master_range);

(primer_master_overlap.

() >=

(is_left_primer) {

global_align =

.aln;

num_total_mismatch =

.num_total_mismatch;

num_3end_mismatch =

.num_3end_mismatch;

num_total_gap =

.num_total_gap;

num_3end_gap =

.num_3end_gap;

do_global_alignment =

;

(desired_align_range.

() >= master_local_start &&

desired_align_range.

() <= master_local_stop) {

do_global_alignment =

;

desired_align_range.

());

num_3end_mismatch, num_total_gap,num_3end_gap,

max_num_continuous_match, aln_range);

(!do_global_alignment) {

percent_ident = 1 - ((double)(num_total_mismatch + num_total_gap))/aln_range.

();

num_total_mismatch + num_total_gap < m_Hits->m_MaxMismatch &&

(num_total_mismatch + num_total_gap <= m_Hits->m_AllowedTotalMismatch ||

num_3end_mismatch + num_3end_gap <= m_Hits->m_Allowed3EndMismatch)) {

aln_ref->

().SetDenseg(*primer_denseg);

global_align = aln_ref;

(do_global_alignment) {

align_length = 1;

nw_align_modified =

;

num_total_mismatch = 0;

num_3end_mismatch = 0;

max_num_continuous_match = 0;

percent_ident;

num_total_mismatch, num_3end_mismatch,

num_total_gap, num_3end_gap,

is_left_primer, max_num_continuous_match,

master_local_stop, hit_strand,

(nw_align_modified) {

num_total_mismatch = 0;

num_3end_mismatch = 0;

max_num_continuous_match = 0;

num_3end_mismatch, num_total_gap,num_3end_gap,

max_num_continuous_match, aln_range);

percent_ident = 1 - ((double)(num_total_mismatch + num_total_gap))/aln_range.

();

percent_ident = 1 - ((double)(num_total_mismatch + num_total_gap))/align_length;

num_total_mismatch + num_total_gap < m_Hits->m_MaxMismatch &&

(num_total_mismatch + num_total_gap <= m_Hits->m_AllowedTotalMismatch ||

num_3end_mismatch + num_3end_gap <= m_Hits->m_Allowed3EndMismatch)) {

aln_ref->

().SetDenseg(*den_ref);

global_align = aln_ref;

temp_match.

= global_align;

[cache_id] = temp_match;

same_target =

;

cerr <<

<< endl;

(backbone_loc && component_loc) {

(backbone_component) {

allowed =

;

(

(*((*iter)->GetId()), hit_id, &scope) &&

(*iter)->GetTotalRange().IntersectionWith(hit_range).GetLength() >= hit_range.

()*0.95){

is_self_forward_primer,

is_self_reverse_primer)

.product_len = product_len;

.left_total_mismatch = left_total_mismatch;

.left_total_gap = left_total_gap;

.left_3end_mismatch = left_3end_mismatch;

.left_3end_gap = left_3end_gap;

.right_total_mismatch = right_total_mismatch;

.right_total_gap = right_total_gap;

.right_3end_mismatch = right_3end_mismatch;

.right_3end_gap = right_3end_gap;

.aln.first = &left_align;

.aln.second = &right_align;

.self_forward_primer = is_self_forward_primer;

.self_reverse_primer = is_self_reverse_primer;

GetBioseqCore()->

(),

(template_hit_same_id && left_template_aln_overlap && right_template_aln_overlap) {

!template_hit_same_id &&

cerr <<

<< endl;

hit_assigned =

;

(index == *iter) {

hit_assigned =

;

hit_assigned =

;

(!hit_assigned) {

start1 = 0, start2 = 0;

start1 <= start2;

& left_window_index_list_size,

& right_window_index_list_size,

vector<SHspInfo*>& hsp_list) {

left_window_index_list_size = 0;

right_window_index_list_size = 0;

left_window_desired_range_int.

(left_window_desired_range.

());

left_window_desired_range_int.

(left_window_desired_range.

());

right_window_desired_range_int.

(right_window_desired_range.

());

right_window_desired_range_int.

(right_window_desired_range.

());

(; left_window_tree_it; ++ left_window_tree_it) {

(hsp_list[temp->index]->master_range.IntersectionWith(left_window_desired_range).GetLength() >=

left_window_index_list[left_window_index_list_size].

= temp->index;

left_window_index_list[left_window_index_list_size].

= hsp_list[temp->index]->bit_score;

left_window_index_list_size ++;

(; right_window_tree_it; ++ right_window_tree_it) {

(hsp_list[temp->index]->master_range.IntersectionWith(right_window_desired_range).GetLength() >=

right_window_index_list[right_window_index_list_size].

= temp->index;

right_window_index_list[right_window_index_list_size].

= hsp_list[temp->index]->bit_score;

right_window_index_list_size ++;

(

= 0;

<(

) hsp_list.size();

++ ) {

(hsp_list[

]->master_range.GetFrom() >= right_window_desired_range.

()) {

(hsp_list[

]->master_range.IntersectionWith(left_window_desired_range).

left_window_index_list[left_window_index_list_size].

=

;

left_window_index_list[left_window_index_list_size].

= hsp_list[

]->bit_score;

left_window_index_list_size ++;

(hsp_list[

]->master_range.IntersectionWith(right_window_desired_range).

right_window_index_list[right_window_index_list_size].

=

;

right_window_index_list[right_window_index_list_size].

= hsp_list[

]->bit_score;

right_window_index_list_size ++;

(left_window_index_list_size > 0) {

(right_window_index_list_size > 0) {

HspOverlappingWithLeftPrimer_size;

HspOverlappingWithRightPrimer_size;

HspOverlappingWithLeftPrimerMinusStrand_size;

HspOverlappingWithRightPrimerMinusStrand_size;

HspOverlappingWithLeftPrimer_size,

HspOverlappingWithRightPrimer_size,

HspOverlappingWithLeftPrimerMinusStrand_size,

HspOverlappingWithRightPrimerMinusStrand_size,

analyze_plus_strand_first =

;

(sorted_hsp.first.size() > 0) {

(sorted_hsp.second.size() > 0 &&

sorted_hsp.first[0]->bit_score < sorted_hsp.second[0]->bit_score - 1) {

analyze_plus_strand_first =

;

analyze_plus_strand_first =

;

(analyze_plus_strand_first) {

HspOverlappingWithLeftPrimer_size,

HspOverlappingWithRightPrimer_size,

HspOverlappingWithLeftPrimerMinusStrand_size,

HspOverlappingWithRightPrimerMinusStrand_size,

HspOverlappingWithLeftPrimerMinusStrand_size,

HspOverlappingWithRightPrimerMinusStrand_size,

HspOverlappingWithLeftPrimer_size,

HspOverlappingWithRightPrimer_size,

HspOverlappingWithLeftPrimer_size,

HspOverlappingWithRightPrimer_size,

HspOverlappingWithLeftPrimerMinusStrand_size,

HspOverlappingWithRightPrimerMinusStrand_size,

slave_range = (*ij).second;

ExtractSlice(0, master_range.

(), master_range.

());

cerr <<

<< e.what() << endl;

HspOverlappingWithLeftPrimer_size,

HspOverlappingWithRightPrimer_size,

vector<CRange<TSeqPos> > right_slave_range_array(HspOverlappingWithRightPrimer_size);

(

j = 0; HspOverlappingWithLeftPrimer_size > 0 && j < HspOverlappingWithRightPrimer_size; j ++) {

right_slave_range_array[j] =

right_primer_master_overlap,

left_primer_hsp_index = 0;

(

= 0;

< HspOverlappingWithLeftPrimer_size;

++) {

left_slave_range_filled =

;

left_global_align_filled =

;

left_total_mismatch = 0;

left_3end_mismatch = 0;

(

j = 0; j < HspOverlappingWithRightPrimer_size; j ++) {

(!left_slave_range_filled) {

left_primer_hit_range =

left_primer_master_overlap,

left_slave_range_filled =

;

(left_primer_hit_range.

()) {

left_primer_hit_stop = left_primer_hit_range.

();

left_primer_hit_start = left_primer_hit_range.

();

(right_primer_hit_range.

()) {

right_primer_hit_stop = right_primer_hit_range.

();

right_primer_hit_start = right_primer_hit_range.

();

(left_primer_hit_start - right_primer_hit_stop + 1) +

(right_primer_hit_start - left_primer_hit_stop + 1) +

(product_len > 0 &&

(!left_global_align_filled) {

left_primer_hit_global_align

hsp_list[left_primer_hsp_index],

left_total_mismatch,

, hit_index, hit_strand);

left_global_align_filled =

;

(!left_primer_hit_global_align) {

right_total_mismatch = 0;

right_3end_mismatch = 0;

hsp_list[right_hsp_index],

right_total_mismatch, right_3end_mismatch,

right_total_gap, right_3end_gap,

,

hit_index, hit_strand);

(right_primer_hit_global_align) {

pcr_product_len = 0;

*right_primer_hit_global_align,

*right_primer_hit_global_align,

left_total_mismatch,

left_3end_mismatch, left_total_gap, left_3end_gap,

right_total_mismatch, right_3end_mismatch,

right_3end_gap, pcr_product_len,

hit_index,

,

);

primers_on_different_strand,

(primers_on_different_strand) {

product_len = right_primer_hit_stop - left_primer_hit_start + 1;

product_len = (left_primer_hit_stop - right_primer_hit_start + 1);

product_len = (right_primer_hit_start - left_primer_hit_stop + 1) +

vector<SHspInfo*>& minus_strand_hsp_list,

HspOverlappingWithLeftPrimer_size,

HspOverlappingWithRightPrimer_size,

HspOverlappingWithLeftPrimerMinusStrand_size,

HspOverlappingWithRightPrimerMinusStrand_size,

vector<CRange<TSeqPos> > right_primer_hit_range_array(HspOverlappingWithLeftPrimerMinusStrand_size);

(

j = 0; HspOverlappingWithLeftPrimer_size > 0 && j < HspOverlappingWithLeftPrimerMinusStrand_size; j ++) {

right_master_range = minus_strand_hsp_list[right_hsp_index]->master_range;

right_primer_hit_range_array[j] =

left_primer_window_right_align_overlap,

(

= 0;

< HspOverlappingWithLeftPrimer_size;

++) {

left_slave_range_filled =

;

left_global_align_filled =

;

left_total_mismatch = 0;

left_3end_mismatch = 0;

(

j = 0; j < HspOverlappingWithLeftPrimerMinusStrand_size; j ++) {

(!left_slave_range_filled) {

left_primer_hit_range =

left_primer_master_overlap,

left_slave_range_filled =

;

(left_primer_hit_range.

()) {

left_primer_hit_stop = left_primer_hit_range.

();

right_primer_hit_range = right_primer_hit_range_array[j];

(right_primer_hit_range.

()) {

right_primer_hit_start = right_primer_hit_range.

();

product_len = right_primer_hit_start - left_primer_hit_stop + 1 +

(!(product_len > 0 &&

right_total_mismatch = 0;

right_3end_mismatch = 0;

(!left_global_align_filled) {

left_primer_hit_global_align =

plus_strand_hsp_list[left_hsp_index],

left_total_mismatch,

left_total_gap, left_3end_gap,

left_global_align_filled =

;

(!left_primer_hit_global_align) {

minus_strand_hsp_list[right_hsp_index],

right_total_mismatch,

right_3end_mismatch,

right_total_gap, right_3end_gap,

(right_primer_hit_global_align) {

pcr_product_len = 0;

valid_pcr_length;

*right_primer_hit_global_align,

(valid_pcr_length) {

new_align_left = left_primer_hit_global_align;

new_align_right = right_primer_hit_global_align;

left_total_mismatch,

left_3end_mismatch, left_total_gap, left_3end_gap,

right_total_mismatch, right_3end_mismatch,

right_3end_gap, pcr_product_len, hit_index,

,

);

vector<CRange<TSeqPos> > right_primer_hit_range_array2(HspOverlappingWithRightPrimerMinusStrand_size);

(

j = 0; HspOverlappingWithRightPrimer_size > 0 && j < HspOverlappingWithRightPrimerMinusStrand_size; j ++) {

right_master_range = minus_strand_hsp_list[right_hsp_index]->master_range;

right_primer_hit_range_array2[j] =

right_primer_as_3_master_overlap,

(

= 0;

< HspOverlappingWithRightPrimer_size;

++) {

right_primer_as_5_slave_range_filled =

;

left_global_align_filled =

;

left_total_mismatch = 0;

left_3end_mismatch = 0;

(

j = 0; j < HspOverlappingWithRightPrimerMinusStrand_size; j ++) {

(!right_primer_as_5_slave_range_filled ) {

right_primer_as_5_hit_range =

right_primer_as_5_master_overlap,

right_primer_as_5_slave_range_filled =

;

(right_primer_as_5_hit_range.

()) {

right_primer_as_5_hit_start = right_primer_as_5_hit_range.

();

right_primer_as_3_hit_range = right_primer_hit_range_array2[j];

(right_primer_as_3_hit_range.

()) {

right_primer_as_3_hit_stop = right_primer_as_3_hit_range.

();

product_len = right_primer_as_5_hit_start

- right_primer_as_3_hit_stop + 1 +

(!(product_len > 0 &&

right_total_mismatch = 0;

right_3end_mismatch = 0;

(!left_global_align_filled) {

left_primer_hit_global_align =

plus_strand_hsp_list[left_hsp_index],

left_total_mismatch,

left_total_gap, left_3end_gap,

left_global_align_filled =

;

(!left_primer_hit_global_align) {

right_total_mismatch,

right_3end_mismatch,

right_total_gap, right_3end_gap,

(right_primer_hit_global_align) {

pcr_product_len = 0;

valid_pcr_length;

*left_primer_hit_global_align,

(valid_pcr_length) {

new_align_left->

(*left_primer_hit_global_align);

new_align_right->

(*right_primer_hit_global_align);

left_total_mismatch,

left_3end_mismatch, left_total_gap, left_3end_gap,

right_total_mismatch, right_3end_mismatch,

right_3end_gap, pcr_product_len, hit_index,

,

);

SPrimerHitInfo* info1,

SPrimerHitInfo* info2) {

mismatch1 =

(mismatch1,

(

)info1->right_total_mismatch +

(

)info1->right_total_gap +

(

)info1->left_total_mismatch +

(

)info1->left_total_gap);

mismatch2 =

(mismatch2,

(

)info2->right_total_mismatch +

(

)info2->right_total_gap +

(

)info2->left_total_mismatch +

(

)info2->left_total_gap);

mismatch1 < mismatch2;

SPrimerHitInfo*>* info1,

SPrimerHitInfo*>* info2) {

(vector<COligoSpecificityCheck::SPrimerHitInfo*>, iter, *info1) {

mismatch1 =

(mismatch1,

(

)(*iter)->right_total_mismatch +

(

)(*iter)->right_total_gap +

(

)(*iter)->left_total_mismatch +

(

)(*iter)->left_total_gap);

(vector<COligoSpecificityCheck::SPrimerHitInfo*>, iter, *info2) {

mismatch2 =

(mismatch2,

(

)(*iter)->right_total_mismatch +

(

)(*iter)->right_total_gap +

(

)(*iter)->left_total_mismatch +

(

)(*iter)->left_total_gap);

mismatch1 < mismatch2;

(

= 0;

< (

) primer_hit_list_list.size();

++){

vector<COligoSpecificityCheck::SPrimerHitInfo>* primer_hit_list = &primer_hit_list_list[

];

vector<vector<SPrimerHitInfo*>* >

;

vector<SPrimerHitInfo*>* temp;

(vector<COligoSpecificityCheck::SPrimerHitInfo>, iter, *primer_hit_list) {

& cur_id = iter->aln.first->GetSeq_id(1);

(previous_id.

()) {

temp =

vector<SPrimerHitInfo*>;

temp->push_back(&(*iter));

}

(cur_id.

(*previous_id)){

temp->push_back(&(*iter));

temp =

vector<SPrimerHitInfo*>;

temp->push_back(&(*iter));

previous_id = &cur_id;

vector<SPrimerHitInfo> temp2;

(vector<SPrimerHitInfo*>, iter2, **iter){

temp2.push_back(**iter2);

primer_hit_list->clear();

*primer_hit_list = temp2;

end = primer_info_list.size();

(from >= end)

;

(to > end || to < 0) to = end;

(

=from;

<to; ++

) {

vector<SPrimerHitInfo> temp;

vector<double> score1;

num_hsp = 2;

(info1.first.size() > 0) {

(

= 0;

< (

)info1.first.size() &&

< num_hsp;

++) {

(

== 0 || (

> 0 && !(info1.first[

]->master_range.IntersectingWith(previous_range)))) {

score1.push_back(info1.first[

]->bit_score);

previous_range = info1.first[

]->master_range;

(info1.second.size() > 0 && (score1.empty() || !(score1[0] > info1.second[0]->bit_score))) {

(

= 0;

< (

)info1.second.size() &&

< num_hsp;

++) {

(

== 0 || (

> 0 && !(info1.second[

]->master_range.IntersectingWith(previous_range)))) {

score1.push_back(info1.second[

]->bit_score);

previous_range = info1.second[

]->master_range;

vector<double> score2;

(info2.first.size() > 0) {

(

= 0;

< (

)info2.first.size() &&

< num_hsp;

++) {

(

== 0 || (

> 0 && !(info2.first[

]->master_range.IntersectingWith(previous_range)))) {

score2.push_back(info2.first[

]->bit_score);

previous_range = info2.first[

]->master_range;

(info2.second.size() > 0 && (score2.empty() || !(score2[0] > info2.second[0]->bit_score))) {

(

= 0;

< (

)info2.second.size() &&

< num_hsp;

++) {

(

== 0 || (

> 0 && !(info2.second[

]->master_range.IntersectingWith(previous_range)))) {

score2.push_back(info2.second[

]->bit_score);

previous_range = info2.second[

]->master_range;

stable_sort(score1.begin(), score1.end(), greater<double>());

stable_sort(score2.begin(), score2.end(), greater<double>());

(score1[0] > score2[0]) {

}

(score1[0] < score2[0]) {

}

(score1.size() > 1 && score2.size() > 1) {

(score1[1] > score2[1]);

}

(score1.size() > 1) {

}

(score2.size() > 1) {

(input_hits.

().empty()) {

is_first_aln =

;

highest_hit_score = 0;

last_highest_hit_score_index_found =

;

subid = &((*iter)->GetSeq_id(1));

cur_bit_score = 0;

(cur_bit_score == 0) {

(

.IsStr() &&

.GetStr() ==

) {

cur_bit_score = (*iter_score)->GetValue().GetReal();

(!is_first_aln && !subid->

(*previous_id)) {

(!last_highest_hit_score_index_found) {

(cur_bit_score < highest_hit_score) {

last_highest_hit_score_index_found =

;

(!(each_hit.first.empty())) {

highest_hit_score =

(highest_hit_score, each_hit.first[0]->bit_score);

(!(each_hit.second.empty())) {

highest_hit_score =

(highest_hit_score, each_hit.second[0]->bit_score);

each_hit.first.clear();

each_hit.second.clear();

temp ->

= *iter;

each_hit.second.push_back(temp);

temp ->

= *iter;

each_hit.first.push_back(temp);

is_first_aln =

;

previous_id = subid;

(!(each_hit.first.empty() && each_hit.second.empty())) {

num_hsp = (

)input_hits.

().size();

hsp_hit_ratio = 0;

hsp_hit_ratio = num_hsp/num_hits;

cerr <<

<< num_hits <<

<< num_hsp

<<

<< hsp_hit_ratio << endl;

(hsp_hit_ratio > 100) {

index_holder->index = j;

[

].first[j]->master_range.GetTo());

RangeTreeForEachHitPlusStrand->

(temp_master_range,

(

j = 0; j < (

)

[

].second.size(); j ++) {

index_holder->index = j;

[

].second[j]->master_range.GetTo());

RangeTreeForEachHitMinusStrand->

(temp_master_range,

static CRef< CScope > m_Scope

User-defined methods of the data storage class.

bool GetSeqData(ParserPtr pp, const DataBlk &entry, CBioseq &bioseq, Int4 nodetype, unsigned char *seqconv, Uint1 seq_data_type)

CRef< CAlnChunkVec > GetSeqChunks(TNumrow row, const TSignedRange &range, TGetChunkFlags flags=fAlnSegsOnly) const

const CSeq_id & GetSeqId(TNumrow row) const

bool IsPositiveStrand(TNumrow row) const

TSeqPos GetAlnStop(TNumseg seg) const

TSignedSeqPos GetSeqPosFromSeqPos(TNumrow for_row, TNumrow row, TSeqPos seq_pos, ESearchDirection dir=eNone, bool try_reverse_dir=true) const

const CBioseq_Handle & GetBioseqHandle(TNumrow row) const

TResidue GetGapChar(TNumrow row) const

void SetEndChar(TResidue gap_char)

void SetGapChar(TResidue gap_char)

string & GetAlnSeqString(string &buffer, TNumrow row, const CAlnMap::TSignedRange &aln_rng) const

void FromTranscript(TSeqPos query_start, ENa_strand query_strand, TSeqPos subj_start, ENa_strand subj_strand, const string &transcript)

Initialize from pairwise alignment transcript (a string representation produced by CNWAligner)

CRef< CDense_seg > ExtractSlice(TDim row, TSeqPos from, TSeqPos to) const

Extract a slice of the alignment that includes the specified range.

CRange< TSeqPos > GetSeqRange(TDim row) const

static string GetLoaderNameFromArgs(CReader *reader=0)

static TRegisterLoaderInfo RegisterInObjectManager(CObjectManager &om, CReader *reader=0, CObjectManager::EIsDefault is_default=CObjectManager::eDefault, CObjectManager::TPriority priority=CObjectManager::kPriority_NotSet)

const SPrimerInfo * m_PrimerInfo

bool x_IsPcrLengthInRange(const CSeq_align &left_primer_hit_align, const CSeq_align &right_primer_hit_align, bool primers_on_different_strand, ENa_strand hit_strand, int &product_len)

Test if the primer pair generates the pcr product in specified length range and fill the actual lengt...

const COligoSpecificityTemplate * m_Hits

the information about the blast results

SHspIndexInfo * m_HspOverlappingWithLeftPrimer

CRef< CScope > m_Scope

scope to fetch sequence

void CheckSpecificity(const vector< SPrimerInfo > &primer_info_list, int from=0, int to=-1)

check the specificity of the primer pairs.

void x_FindOverlappingHSP(SHspIndexInfo *left_window_index_list, int &left_window_index_list_size, SHspIndexInfo *right_window_index_list, int &right_window_index_list_size, const CRange< TSeqPos > &left_window_desired_range, const CRange< TSeqPos > &right_window_desired_range, ENa_strand hit_strand, TSeqPos hit_index, const vector< SHspInfo * > &hsp_list)

SHspIndexInfo * m_HspOverlappingWithLeftPrimerMinusStrand

void x_AnalyzeLeftAndRightPrimer(const vector< SHspInfo * > &hsp_list, ENa_strand hit_strand, int HspOverlappingWithLeftPrimer_size, int HspOverlappingWithRightPrimer_size, TSeqPos hit_index)

void x_AnalyzeTwoPrimers(const TSortedHsp &sorted_hsp, TSeqPos index)

Analyze the the primer pair specificity usign both left and right primer at ends.

COligoSpecificityCheck(const COligoSpecificityTemplate *temp, CScope &scope)

vector< vector< SPrimerHitInfo > > m_SelfHit

the hit represent the input template

vector< vector< SPrimerHitInfo > > m_VariantHit

the hits represent the transcript variants from the same gene as the input template

CRef< CScope > m_FeatureScope

bool x_SequencesMappedToSameTarget(CSeq_id::EAccessionInfo hit_type, const CSeq_align &left_align, const CSeq_align &right_align)

SHspIndexInfo * m_HspOverlappingWithRightPrimerMinusStrand

TSeqPos m_SpecifiedProductLen

the requested pcr length for non-specific template

vector< map< SSlaveRange, CRange< TSeqPos >, slave_range_sort_order > > m_SlaveRangeCache

vector< vector< SPrimerHitInfo > > m_PrimerHit

the non-specific hit for the primer pair

vector< int > m_NumTargetFromSameSequence

max number of targets allowed from a single subject sequence for a primer.

void x_FindMatchInfoForAlignment(CDense_seg &primer_denseg, bool &end_gap, TSeqPos &num_total_mismatch, TSeqPos &num_3end_mismatch, TSeqPos &num_total_gap, TSeqPos &num_3end_gap, bool is_left_primer, int &max_num_continuous_match, CRange< TSignedSeqPos > &aln_range)

void x_SavePrimerInfo(CSeq_align &left_align, CSeq_align &right_align, TSeqPos left_total_mismatch, TSeqPos left_3end_mismatch, TSeqPos left_total_gap, TSeqPos left_3end_gap, TSeqPos right_total_mismatch, TSeqPos right_3end_mismatch, TSeqPos right_total_gap, TSeqPos right_3end_gap, int product_len, TSeqPos index, bool is_self_forward_primer, bool is_self_reverse_primer)

save the primer informaton

void x_AnalyzePrimerSpecificity()

Analyze the primer pair specificity.

vector< const SPrimerInfo * > m_PrimerInfoList

the information about primer to be checked

void x_AnalyzeOnePrimer(const vector< SHspInfo * > &plus_strand_hsp_list, const vector< SHspInfo * > &minus_strand_hsp_list, int HspOverlappingWithLeftPrimer_size, int HspOverlappingWithRightPrimer_size, int HspOverlappingWithLeftPrimerMinusStrand_size, int HspOverlappingWithRightPrimerMinusStrand_size, TSeqPos hit_index)

analyze the case where the left primer itself can serve as both left and right primer

CRef< CObjectManager > m_FeatureOM

void x_SortPrimerHit(vector< vector< SPrimerHitInfo > > &primer_hit_list_list)

~COligoSpecificityCheck()

CRange< TSeqPos > x_GetSlaveRangeGivenMasterRange(const CSeq_align &input_align, CRange< TSeqPos > &master_range, int index)

map< SAlnCache, SPrimerMatch, sort_order > m_Cache

cache coordinate-alignment mapping

CRef< CSeq_align > x_FillGlobalAlignInfo(const CRange< TSeqPos > &desired_align_range, SHspInfo *input_hsp_info, TSeqPos &num_total_mismatch, TSeqPos &num_3end_mismatch, TSeqPos &num_total_gap, TSeqPos &num_3end_gap, bool is_left_primer, TSeqPos index, ENa_strand hit_strand)

return alignment for the full primer window.

SHspIndexInfo * m_HspOverlappingWithRightPrimer

CRef< CDense_seg > x_NW_alignment(const CRange< TSeqPos > &desired_align_range, const CSeq_align &input_hit, TSeqPos &num_total_mismatch, TSeqPos &num_3end_mismatch, TSeqPos &num_total_gap, TSeqPos &num_3end_gap, bool is_left_primer, int &max_num_continuous_match, int &align_length, TSeqPos master_local_start, TSeqPos master_local_stop, ENa_strand hit_strand, bool &nw_align_modified)

vector< vector< SPrimerHitInfo > > m_AllowedHit

the hit that user choose to ingnore for specificity

int m_NumNonSpecificTarget

the number non-specific targets to return

void x_SortHit(CSeq_align_set &input)

sort the hit

CRange< TSeqPos > m_TemplateRange

range on the input template

CConstRef< CSeq_id > m_Id

seqid

COligoSpecificityTemplate(const CBioseq_Handle &template_handle, CSeq_align_set &input_seqalign, CScope &scope, int word_size, TSeqPos allowed_total_mismatch=1, TSeqPos allowed_3end_mismatch=1, TSeqPos max_mismatch=7)

constructor @template_handle: bioseq represents the pcr template

TSeqPos m_MismatchRegionLength3End

the length or region at the 3' end for checking mismatches

vector< TSeqPos > m_AllowedSeqidIndex

user specified hits that can be disregarded for specificity checking

CSeq_id::EAccessionInfo m_TemplateType

const CBioseq_Handle & m_TemplateHandle

bioseq handle for input bioseq

vector< TSortedHsp > m_SortHit

the processed sorted hit list corresponding to the input seqalign

const list< CRef< CSeq_id > > * m_Allowed_Splice_Variants

TSeqPos m_TargetSizeMax

the requested target max length

int m_WordSize

minimal continuous match required

int m_MaxTargetPerSequence

~COligoSpecificityTemplate()

const list< CRef< CSeq_loc > > * m_AllowedSeqloc

vector< CIntervalTree * > m_RangeTreeListMinusStrand

vector< CIntervalTree * > m_RangeTreeListPlusStrand

void Reverse(void)

Reverse the segments' orientation NOTE: currently *only* works for dense-seg.

CRange< TSeqPos > GetSeqRange(TDim row) const

GetSeqRange NB: On a Spliced-seg, in case the product-type is protein, these only return the amin par...

TSeqPos GetSeqStop(TDim row) const

const CSeq_id & GetSeq_id(TDim row) const

Get seq-id (the first one if segments have different ids).

TSeqPos GetSeqStart(TDim row) const

@ eBackwards

Towards lower seq coord (to the left if plus strand, right if minus)

container_type::iterator iterator

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

unsigned int TSeqPos

Type for sequence locations and lengths.

#define ITERATE(Type, Var, Cont)

ITERATE macro to sequence through container elements.

#define NON_CONST_ITERATE(Type, Var, Cont)

Non constant version of ITERATE macro.

virtual void Assign(const CSerialObject &source, ESerialRecursionMode how=eRecursive)

Set object to copy of another one.

iterator Insert(const interval_type &interval, const mapped_type &value)

reference GetValue(void) const

static EAccessionInfo IdentifyAccession(const CTempString &accession, TParseFlags flags=fParse_AnyRaw)

Deduces information from a bare accession a la WHICH_db_accession; may report false negatives on prop...

virtual void Assign(const CSerialObject &source, ESerialRecursionMode how=eRecursive)

Optimized implementation of CSerialObject::Assign, which is not so efficient.

EAccessionInfo

For IdentifyAccession (below)

bool Match(const CSeq_id &sid2) const

Match() - TRUE if SeqIds are equivalent.

static int WorstRank(const CRef< CSeq_id > &id)

const CSeq_id & GetId(const CSeq_loc &loc, CScope *scope)

If all CSeq_ids embedded in CSeq_loc refer to the same CBioseq, returns the first CSeq_id found,...

TSeqPos GetLength(const CSeq_id &id, CScope *scope)

Get sequence length if scope not null, else return max possible TSeqPos.

sequence::ECompare Compare(const CSeq_loc &loc1, const CSeq_loc &loc2, CScope *scope)

Returns the sequence::ECompare containment relationship between CSeq_locs.

CSeq_id_Handle GetIdHandle(const CSeq_loc &loc, CScope *scope)

bool IsSameBioseq(const CSeq_id &id1, const CSeq_id &id2, CScope *scope, CScope::EGetBioseqFlag get_flag=CScope::eGetBioseq_All)

Determines if two CSeq_ids represent the same CBioseq.

@ fCompareOverlapping

Check if seq-locs are overlapping.

@ eContains

First CSeq_loc contains second.

@ eSame

CSeq_locs contain each other.

@ eContained

First CSeq_loc contained by second.

CRef< CSeq_loc > Map(const CSeq_loc &src_loc)

Map seq-loc.

void AddDataLoader(const string &loader_name, TPriority pri=kPriority_Default)

Add data loader by name.

static CRef< CObjectManager > GetInstance(void)

Return the existing object manager or create one.

CBioseq_Handle GetBioseqHandle(const CSeq_id &id)

Get bioseq handle by seq-id.

CSeq_loc_Mapper_Base & KeepNonmappingRanges(void)

Keep ranges which can not be mapped.

@ eSeqMap_Down

map from a segmented bioseq to segments

TBioseqCore GetBioseqCore(void) const

Get bioseq core structure.

TSeqPos GetBioseqLength(void) const

CConstRef< CSeq_id > GetSeqId(void) const

Get id which can be used to access this bioseq handle Throws an exception if none is available.

CSeqVector GetSeqVector(EVectorCoding coding, ENa_strand strand=eNa_strand_plus) const

Get sequence: Iupacna or Iupacaa if use_iupac_coding is true.

@ eCoding_Iupac

Set coding to printable coding (Iupacna or Iupacaa)

bool Empty(void) const THROWS_NONE

Check if CConstRef is empty – not pointing to any object which means having a null value.

position_type GetLength(void) const

bool IntersectingWith(const TThisType &r) const

TThisType IntersectionWith(const TThisType &r) const

static TThisType GetEmpty(void)

TThisType & Set(position_type from, position_type to)

#define END_NCBI_SCOPE

End previously defined NCBI scope.

#define BEGIN_NCBI_SCOPE

Define ncbi namespace.

NCBI_NS_STD::string::size_type SIZE_TYPE

C::value_type FindBestChoice(const C &container, F score_func)

Find the best choice (lowest score) for values in a container.

void SetFrom(TFrom value)

Assign a value to From data member.

TTo GetTo(void) const

Get the To member data.

TFrom GetFrom(void) const

Get the From member data.

void SetTo(TTo value)

Assign a value to To data member.

TId GetId(void) const

Get the variant data.

const TDenseg & GetDenseg(void) const

Get the variant data.

Tdata & Set(void)

Assign a value to data member.

void SetSegs(TSegs &value)

Assign a value to Segs data member.

void SetType(TType value)

Assign a value to Type data member.

vector< CRef< CScore > > TScores

list< CRef< CSeq_align > > Tdata

TIds & SetIds(void)

Assign a value to Ids data member.

const Tdata & Get(void) const

Get the member data.

const TSegs & GetSegs(void) const

Get the Segs member data.

@ eType_partial

mapping pieces together

ENa_strand

strand of nucleic acid

E_Choice Which(void) const

Which variant is currently selected.

const TId & GetId(void) const

Get the Id member data.

unsigned int

A callback function used to compare two keys in a database.

const struct ncbi::grid::netcache::search::fields::SIZE size

Defines the CNcbiApplication and CAppException classes for creating NCBI applications.

Defines command line argument related classes.

Defines unified interface to application:

NCBI C++ stream class wrappers for triggering between "new" and "old" C++ stream libraries.

static int match(PCRE2_SPTR start_eptr, PCRE2_SPTR start_ecode, uint16_t top_bracket, PCRE2_SIZE frame_size, pcre2_match_data *match_data, match_block *mb)

static bool SortIndexListByScoreDescending(const COligoSpecificityCheck::SHspIndexInfo &info1, const COligoSpecificityCheck::SHspIndexInfo &info2)

static bool SortPrimerHitByMismatchAscending(const vector< COligoSpecificityCheck::SPrimerHitInfo * > *info1, const vector< COligoSpecificityCheck::SPrimerHitInfo * > *info2)

static bool SortHitByTopHspScores(TSortedHsp const &info1, TSortedHsp const &info2)

static bool SeqLocAllowed(const list< CRef< CSeq_loc > > &allowed_seq, const CSeq_id &hit_id, const CRange< TSeqPos > &hit_range, CScope &scope)

static bool SortPrimerHitInGroupByMismatchAscending(const COligoSpecificityCheck::SPrimerHitInfo *info1, const COligoSpecificityCheck::SPrimerHitInfo *info2)

static const double k_Min_Percent_Identity

static const int k_MaxReliableGapNum

CRef< CDense_seg > s_DoNWalign(const CRange< TSeqPos > &desired_align_range, string &master_seq, const CAlnVec &av, TSeqPos hit_full_start, TSeqPos hit_full_stop, ENa_strand hit_strand, string &xcript, bool &nw_align_modified)

static void s_CountGaps(const string &xcript, TSeqPos &master_start_gap, TSeqPos &master_end_gap, TSeqPos &slave_start_gap, TSeqPos &slave_end_gap, char master_gap_char, char slave_gap_char)

static bool SortHspByMasterStartAscending(const SHspInfo *info1, const SHspInfo *info2)

static const double k_MinOverlapLenFactor

primer specificity checking tool

pair< vector< SHspInfo * >, vector< SHspInfo * > > TSortedHsp

static bool GetSeqId(const T &d, set< string > &labels, const string name="", bool detect=false, bool found=false)

key for coordinate-alignment cache

primer hit to the blast dababase

value for coordinate-alignment cache

TSeqPos num_3end_mismatch

total mismatchs

CRef< CSeq_align > aln

3' end gaps

TSeqPos num_3end_gap

total gaps

TSeqPos num_total_mismatch

TSeqPos num_total_gap

3' end mismatches

const CSeq_align * align_index

CRange< TSeqPos > master_range

CRange< TSeqPos > slave_range

CConstRef< CSeq_align > hsp

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