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

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

NCBI C++ ToolKit: src/algo/gnomon/aligncollapser.cpp Source File

(

= shift; id_pool[

] != 0; ++

)

target.push_back(id_pool[

]);

(

.Strand() ==

)

ss =

.front().m_sig.substr(0,2);

ss =

.front().m_sig.substr(2,2);

(

.Strand() ==

) {

(

.Strand() ==

)

amap(

.Exons(),

.FrameShifts(),

.Strand());

(

.m_range ==

.m_range)

(

.m_range.GetFrom() !=

.m_range.GetFrom())

.m_range.GetFrom() <

.m_range.GetFrom();

.m_range.GetTo() >

.m_range.GetTo();

.m_target_id <

.m_target_id;

(

= 1;

< (

)e.size(); ++

) {

(e[

-1].m_ssplice && e[

].m_fsplice) {

sig = e[

-1].m_ssplice_sig+e[

].m_fsplice_sig;

sig = e[

].m_fsplice_sig+e[

-1].m_ssplice_sig;

(ri != right_exon_ends.

())

(ri != right_exon_ends.

())

(li != left_exon_ends.

())

arg_desc->

(

,

);

arg_desc->

(

,

);

arg_desc->

(

,

);

arg_desc->

(

,

);

arg_desc->

(

,

);

arg_desc->

(

,

);

arg_desc->

(

,

);

arg_desc->

(

,

);

arg_desc->

(

,

,

,

arg_desc->

(

,

,

,

arg_desc->

(

,

,

,

arg_desc->

(

,

,

,

arg_desc->

(

,

,

,

arg_desc->

(

,

,

,

arg_desc->

(

,

,

,

arg_desc->

(

,

,

,

arg_desc->

(

,

);

length (sv.

());

(

= from;

<=to; ++

) {

++current_gap->second;

(nofilteringcollapsing) {

= args[

].AsDouble();

(

!= 0 && contig !=

) {

covered_length = 0;

(

p =

->Limits().GetFrom(); p <= i->Limits().GetTo(); ++p)

(coverage[p-left_end] >= mincoverage)

intron_oriented_nosig(

,

, strand,

,

);

good_intron = (introns.

(intron_oriented_nosig) != introns.

() || introns.

(intron_notoriented_nosig) != introns.

());

(!good_intron && check_introns_on_both_strands) {

good_intron = (introns.

(intron_otherstrand_nosig) != introns.

());

(

= e->GetFrom(); i <= e->GetTo(); ++

) {

threshold =

(clip_threshold*cov, min_lim);

(++exnl == (

)align.

().size()) {

left_lim = align.

()[exnl].GetFrom();

exnr = (

)align.

().size()-1;

right_lim = align.

()[exnr].GetTo();

(right_lim >= left_lim);

(

= e->GetFrom(); i <= e->GetTo(); ++

) {

lim =

(clip_threshold*cov, min_lim);

not_aligned_left = tlim.

();

(not_aligned_left,not_aligned_right);

(not_aligned_left > 30) {

(

< align.

()[ie].GetTo())

= align.

()[++ie].GetFrom();

(not_aligned_right > 30) {

ie = (

)align.

().size()-1;

(

> align.

()[ie].GetFrom())

= align.

()[--ie].GetTo();

keepdoing =

;

(

k = 1; k < (

)align.

().size(); ++k) {

(

!= exonl.

())

(

prev_exon = -1; prev_exon < (

)align.

().size()-1; ++prev_exon) {

piece_begin = prev_exon+1;

(align.

()[piece_begin].m_fsplice)

piece_end = piece_begin;

( ; piece_end < (

)align.

().size() && align.

()[piece_end].m_ssplice; ++piece_end);

= align.

()[piece_begin].GetFrom();

= align.

()[piece_end].GetTo();

keepdoing =

;

(

k = 1; k < (

)align.

().size(); ++k) {

(CAlignModel::TExons::const_iterator piece_begin = align.

().begin(); piece_begin != align.

().end(); ++piece_begin) {

( !piece_begin->m_fsplice );

CAlignModel::TExons::const_iterator piece_end = piece_begin;

( ; piece_end != align.

().end() && piece_end->m_ssplice; ++piece_end) ;

new_left =

.Limits().GetFrom();

(

k = 1; k < (

)

.Exons().size(); ++k) {

new_right =

.Limits().GetTo();

(

k = (

)

.Exons().size()-1; k > 0 &&

.Exons()[k-1].GetTo() > new_left; --k) {

new_right = exonl.

();

(new_lim !=

.Limits()) {

(!editedmodel.

().empty())

editedmodel.

(e->Limits(), e->m_fsplice_sig, e->m_ssplice_sig, e->m_ident);

editedmodel.

().insert(editedmodel.

().end(),

.FrameShifts().begin(),

.FrameShifts().end());

piece_begin = piece_end;

good_alignment =

;

good_alignment =

;

keepdoing =

;

(

k = 1; k < (

)editedmodel.

().size() && good_alignment; ++k) {

good_alignment =

;

vector<TSignedSeqRange> transcript_exons;

transcript_exons.push_back(te);

good_alignment;

transcript = trans;

(tlen == (

)transcript.size());

vector<TSignedSeqRange> transcript_exons;

transcript_exons.reserve(exons.size());

(

ie = 0; ie < (

)exons.size(); ++ie) {

(

ie = 0; ie < (

)exons.size(); ++ie) {

(

ie = 0; ie < (

)exons.size(); ++ie) {

(!exons[ie].m_fsplice) {

glim = (ie > 0) ? exons[ie-1].GetTo() : -1;

tlim = (ie > 0) ? transcript_exons[ie-1].GetTo() : -1;

= exons[ie].GetFrom();

= transcript_exons[ie].GetFrom();

(

> glim+1 &&

> tlim+1 && transcript[

-1] ==

[

-1]) {

(

< exons[ie].GetFrom()) {

exons[ie].AddFrom(

-exons[ie].GetFrom());

exons[ie].m_fsplice_sig.clear();

transcript_exons[ie].SetFrom(

);

(!exons[ie].m_ssplice) {

tlim = (ie+1 < (

)exons.size()) ? transcript_exons[ie+1].GetFrom() : (

)transcript.size();

= exons[ie].GetTo();

= transcript_exons[ie].GetTo();

(

< glim-1 &&

< tlim-1 && transcript[

+1] ==

[

+1]) {

(

> exons[ie].GetTo()) {

exons[ie].AddTo(

-exons[ie].GetTo());

exons[ie].m_ssplice_sig.clear();

transcript_exons[ie].SetTo(

);

vector<TSignedSeqRange> edited_transcript_exons;

(

piece_begin = 0; piece_begin < (

)exons.size(); ++piece_begin) {

( !exons[piece_begin].m_fsplice );

piece_end = piece_begin;

( ; exons[piece_end].m_ssplice; ++piece_end);

(piece_end < (

)exons.size());

indels = align.

(exons[piece_begin].GetFrom(), exons[piece_end].GetTo(),

);

TInDels::const_iterator indl = indels.begin();

exons_to_align;

tp = transcript_exons[piece_begin].GetFrom();

(

ie = piece_begin; ie <= piece_end; ++ie) {

(gp <= exons[ie].GetTo()) {

(indl == indels.end() || indl->Loc() != gp) {

tseq.push_back(transcript[tp++]);

}

(indl->IsDeletion()) {

tseq += transcript.substr(tp,indl->Len());

gseq.insert(gseq.end(),indl->Len(),

);

tseq.insert(tseq.end(),indl->Len(),

);

(indl != indels.end() && indl->Loc() == gp) {

tseq += transcript.substr(tp,indl->Len());

gseq.insert(gseq.end(), indl->Len(),

);

exons_to_align.push_back((

)gseq.size()-1);

(tseq.size() == gseq.size() && indl == indels.end());

score(tseq.size());

(

= 0;

< (

)score.size(); ++

) {

(tseq[

] == gseq[

] && tseq[

] !=

)

(tseq[

] ==

|| gseq[

] ==

)

score[

] += score[

-1];

score[

] =

(0,score[

]);

align_right = (

)(max_element(score.begin(),score.end())-score.begin());

(score[align_right] > 0) {

align_left = align_right;

(align_left > 0 && score[align_left-1] > 0)

agaps = (

)

(tseq.begin(), tseq.begin()+align_left,

);

bgaps = (

)

(tseq.begin(), tseq.begin()+align_right,

);

trange(transcript_exons[piece_begin].GetFrom()+align_left-agaps, transcript_exons[piece_begin].GetFrom()+align_right-bgaps);

= piece_begin;

(exons[

].GetTo() < grange.

())

(exons[pe].GetFrom() > grange.

())

(

= align_left;

<= (pe >

? exons_to_align[

-piece_begin] : align_right); ++

) {

(tseq[

] == gseq[

])

(

= align_right;

>= (pe >

? exons_to_align[pe-1-piece_begin]+1 : align_left); --

) {

(tseq[

] == gseq[

])

(

ie =

; ie <= pe; ++ie) {

.SetTo(trange.

());

edited_exons.push_back(e);

edited_transcript_exons.push_back(

);

piece_begin = piece_end;

(

piece_begin = 0; piece_begin < (

)edited_exons.size(); ++piece_begin) {

( !edited_exons[piece_begin].m_fsplice );

piece_end = piece_begin;

( ; edited_exons[piece_end].m_ssplice; ++piece_end);

(piece_end < (

)edited_exons.size());

distance_to_lgap = -1;

distance_to_lgap = elim.

()-(igap->first+igap->second);

(distance_to_lgap == 0) {

edited_exons[piece_begin].m_fsplice_sig =

;

}

(tlim.

() >

&& (piece_begin == 0 || tlim.

() > edited_transcript_exons[piece_begin-1].GetTo()+1)) {

splice = (align.

() ==

) ?

:

;

(indl->IsDeletion() &&

(elim, indl->Loc()))

del_len += indl->Len();

errors = (1.-edited_exons[piece_begin].m_ident)*(elim.

()+del_len);

edited_exons[piece_begin].m_ident = 1.-errors/(elim.

()+del_len);

edited_exons[piece_begin].m_fsplice_sig = splice;

distance_to_rgap = -1;

distance_to_rgap = igap->first-elim.

()-1;

(distance_to_rgap == 0) {

edited_exons[piece_end].m_ssplice_sig =

;

}

(tlen-tlim.

()-1 >

&& (piece_end == (

)edited_exons.size()-1 || tlim.

() < edited_transcript_exons[piece_end+1].GetFrom()-1)) {

splice = (align.

() ==

) ?

:

;

(indl->IsDeletion() &&

(elim, indl->Loc()))

del_len += indl->Len();

errors = (1.-edited_exons[piece_end].m_ident)*(elim.

()+del_len);

edited_exons[piece_end].m_ident = 1.-errors/(elim.

()+del_len);

edited_exons[piece_end].m_ssplice_sig = splice;

(

ie = piece_begin; ie <= piece_end; ++ie) {

(indl->Loc() > edited_exons[piece_begin].GetFrom() && indl->Loc() < edited_exons[piece_end].GetTo())

edited_indels.push_back(*indl);

piece_begin = piece_end;

(

ie = 0; ie < (

)edited_transcript_exons.size(); ++ie) {

align = editedalign;

(indl->IsMismatch() || !indl->IntersectingWith(

,

))

(indl->IsInsertion())

count_m_aligns = 0;

(deque<SAlignIndividual>, k,

->second) {

right_end =

(right_end, k->m_range.GetTo());

TAlignModelList::iterator

= it++;

& intron = it->first;

right_end =

(right_end,

);

right_end =

(right_end,

->Limits().GetTo());

map<TSignedSeqRange, tuple<double,bool>> intervals;

& intron = it->first;

& rslt = intervals[intron.

];

get<0>(rslt) +=

.m_weight;

not_long =

.m_sr_support > 0 ||

.m_other_support > 0;

get<1>(rslt) =

;

multimap<int, TAlignIntrons::iterator> left_intronsp;

multimap<int, TAlignIntrons::iterator> right_intronsp;

& intron = it->first;

(!get<1>(intervals[intron.

])) {

right_intronsp.emplace(intron.

.

(), it);

set<SIntron> deleted_introns;

(

& interval : intervals) {

il = left_intronsp.lower_bound(range.

()-

);

(il == left_intronsp.end() || il->first > range.

()+

)

ir = left_intronsp.upper_bound(range.

()+

);

set<TAlignIntrons::value_type*> close_lefts;

(

= il;

!= ir; ++

) {

& intronb =

->second->first;

(intronb.

!= range)

close_lefts.insert(&(*

->second));

(close_lefts.empty())

jl = right_intronsp.lower_bound(range.

()-

);

(jl == right_intronsp.end() || jl->first > range.

()+

)

jr = right_intronsp.upper_bound(range.

()+

);

set<TAlignIntrons::value_type*> close_rights;

(

j = jl; j != jr; ++j) {

& intronb = j->second->first;

(intronb.

!= range)

close_rights.insert(&(*j->second));

(close_rights.empty())

vector<TAlignIntrons::value_type*>

(

(close_lefts.size(),close_rights.size()),

);

close_end = set_intersection(close_lefts.begin(), close_lefts.end(), close_rights.begin(), close_rights.end(),

.begin());

(

it =

.begin(); it != close_end; ++it) {

& intronb = (*it)->first;

(get<0>(intervals[intronb.

]) < get<0>(interval.second))

deleted_introns.insert(intronb);

(

& intron : deleted_introns) {

(

->first.isEST() &&

->first.GetIntrons().size() > 1)

factor =

->first.GetIntrons().size();

(deque<SAlignIndividual>, k,

->second) {

= k->m_weight*factor;

(

=

->m_range.GetFrom()+1; l <= in->

.

()-1; ++

)

(

& exon : align.Exons()) {

(

= exon.GetFrom();

<= exon.GetTo(); ++

)

vector<double> left_coverage(

,0.);

(

= 0;

<

; ++

) {

vector<double> right_coverage(

,0.);

(

=

-1;

>= 0; --

) {

minconsensussupport = args[

].AsInteger();

minnonconsensussupport = args[

].AsInteger();

bad_intron =

;

(!

.m_selfsp_support)

(

.m_keep_anyway)

(intron->first.m_sig ==

&& intron->first.m_oriented)

(intron->first.m_sig ==

|| (intron->second.m_intron_num >= 3 && intron->first.m_sig ==

)) {

(

.m_weight < minconsensussupport)

(

.m_weight < minnonconsensussupport)

minspliceexpression = args[

].AsDouble();

minintronexpression = args[

].AsDouble();

multimap<int,CAlignCollapser::TAlignIntrons::iterator> TIntronsBySplice;

TIntronsBySplice introns_by_left_splice;

(TIntronsBySplice::iterator

= introns_by_left_splice.begin();

!= introns_by_left_splice.end(); ) {

splice =

->first;

TIntronsBySplice::iterator

= introns_by_left_splice.upper_bound(splice);

(TIntronsBySplice::iterator

=

;

!=

; ++

) {

+=

->second->second.m_weight*

->second->second.m_intron_num;

(TIntronsBySplice::iterator it =

; it !=

; ) {

TIntronsBySplice::iterator

= it++;

(!

.m_keep_anyway && (

.m_weight*

.m_intron_num < minintronexpression*mean ||

< minspliceexpression*left_coverage[splice-

])) {

introns_by_left_splice.erase(

);

TIntronsBySplice introns_by_right_splice;

(TIntronsBySplice::iterator

= introns_by_right_splice.begin();

!= introns_by_right_splice.end(); ) {

splice =

->first;

TIntronsBySplice::iterator

= introns_by_right_splice.upper_bound(splice);

(TIntronsBySplice::iterator

=

;

!=

; ++

) {

+=

->second->second.m_weight*

->second->second.m_intron_num;

(TIntronsBySplice::iterator it =

; it !=

; ) {

TIntronsBySplice::iterator

= it++;

(!

.m_keep_anyway && (

.m_weight*

.m_intron_num < minintronexpression*mean ||

< minspliceexpression*right_coverage[splice-

])) {

introns_by_right_splice.erase(

);

(intron->second.m_weight < 0) {

(introns.empty())

all_good =

;

(

= 0; all_good &&

< (

)introns.size(); ++

) {

(

= 1;

< e.size(); ++

) {

e[

-1].m_ssplice =

;

e[

].m_fsplice =

;

(

&

: aligns) {

(

.Exons().size() > 1) {

mincrossexpression = args[

].AsDouble();

& intron = intron_data.first;

(right_coverage[

+1-

] < mincrossexpression*two_side_exon_coverage) {

.m_not_cross =

;

.m_not_cross =

;

(left_coverage[

-1-

] < mincrossexpression*two_side_exon_coverage) {

.m_not_cross =

;

.m_not_cross =

;

(

= 1;

<

; ++

) {

right_plus[

] =

(right_plus[

],right_plus[

-1]);

right_minus[

] =

(right_minus[

],right_minus[

-1]);

(

=

-2;

>= 0; --

) {

left_plus[

] =

(left_plus[

],left_plus[

+1]);

left_minus[

] =

(left_minus[

],left_minus[

+1]);

clip_threshold = args[

].AsDouble();

deque<SAlignIndividual>& aligns =

->second;

exnum = align.

().size();

(align.

() == lim)

(exnum != align.

().size() || cap_polya0 != cap_polya1) {

(align.

().size() > 1 || exnum == 1) {

->m_range = align.

();

minsingleexpression = args[

].AsInteger();

trim = args[

].AsInteger();

deque<SAlignIndividual>& aligns =

->second;

=

->m_range.GetFrom()+trim;

=

->m_range.GetTo()-trim;

(align.

().front().Limits().GetLength() > trim) {

= align.

().front().Limits().GetFrom()+trim;

= align.

().front().Limits().GetTo();

(align.

().back().Limits().GetLength() > trim) {

= align.

().back().Limits().GetFrom();

= align.

().back().Limits().GetTo()-trim;

->m_range = new_lim;

(

= 1;

< (

)align.

().size()-1 &&

->m_weight > 0; ++

) {

= align.

()[

].Limits().GetFrom();

= align.

()[

].Limits().GetTo();

pair<TIntronsBySplice::iterator,TIntronsBySplice::iterator> eqr(introns_by_right_splice.end(),introns_by_right_splice.end());

eqr = introns_by_right_splice.equal_range(right_plus[

-

]);

eqr = introns_by_right_splice.equal_range(right_minus[

-

]);

(TIntronsBySplice::iterator

= eqr.first;

!= eqr.second; ++

) {

(

->second->first.m_range.GetFrom() >

)

(aligns.empty()) {

deque<SAlignIndividual>& aligns_ind =

->second;

(introns.empty()) {

= ali.m_range.GetFrom();

= ali.m_range.GetTo();

(ali.m_range.GetLength() > 2*trim) {

strands.push_back(

);

strands.push_back(

);

(

strand : strands) {

(

= 0;

< (

)introns.size()-1; ++

) {

(

(exon,

->first.m_range) &&

->second.m_not_cross)

save_and_delete =

;

= ali.m_range.GetFrom();

= introns.front().m_range.GetFrom();

save_and_delete =

;

save_and_delete =

;

= introns.back().m_range.GetTo();

= ali.m_range.GetTo();

save_and_delete =

;

save_and_delete =

;

(!save_and_delete)

ali.m_range = new_lim;

(

strand : strands) {

(

(exon,

->first.m_range) &&

->second.m_not_cross)

(

strand : strands) {

(

(exon,

->first.m_range) &&

->second.m_not_cross)

bad_exons.

(introns.size());

(save_and_delete || !bad_exons.

()) {

(new_lim != align.

())

(!bad_exons.

()) {

(

: bad_exons) {

e[

-1].m_ssplice =

;

e[

].m_fsplice =

;

e[

].m_ssplice =

;

(

!= introns.size())

e[

+1].m_fsplice =

;

(

&

: aligns) {

(

.Exons().size() > 1) {

(aligns_ind.empty()) {

total +=

.second.size();

TAlignModelList::iterator

= it++;

good_alignment =

;

(reversed.

().size() > align.

().size()) {

good_alignment = good_reversed_alignment;

(!align.

().empty())

(indl->IsDeletion()) {

(

p = indl->Loc(); p < indl->

()+indl->Len(); ++p)

TAlignModelList::iterator

= it++;

=

(right_end, ie->GetTo());

(

p =

; p <=

; ++p) {

pair<TSignedSeqRange,TInDels> TGapEnd;

set<TGapEnd> right_gends;

set<TGapEnd> left_gends;

TAlignModelList::iterator

= it++;

left_gends.insert(TGapEnd(ie->Limits(),fs));

right_gends.insert(TGapEnd(ie->Limits(),fs));

(editedalign.

().size() > align.

().size()) {

(align.

().front().Limits().GetLength() >

) {

=

.GetLength();

(

.Exons()[ie+1].m_ssplice) {

.SetTo(

.Exons()[ie+1].GetTo());

+=

.Exons()[ie+1].Limits().GetLength();

=

.GetAlignMap().ShrinkToRealPoints(

,

);

(

.NotEmpty()) {

(editedalign.

().size() >

.Exons().size()) {

(

ie = 0; ie < (

)align.

().size()-1; ++ie) {

((!align.

()[ie].m_ssplice || !align.

()[ie+1].m_fsplice) &&

left =

.Exons()[ie].GetFrom();

=

.Exons()[ie].Limits().GetLength();

(

.Exons()[iie-1].m_fsplice) {

left =

.Exons()[iie-1].GetFrom();

+=

.Exons()[iie-1].Limits().GetLength();

right =

.Exons()[ie+1].GetTo();

=

.Exons()[ie+1].Limits().GetLength();

(

.Exons()[iie+1].m_ssplice) {

right =

.Exons()[iie+1].GetTo();

+=

.Exons()[iie+1].Limits().GetLength();

(left >= 0 && right >= 0) {

=

.GetAlignMap().ShrinkToRealPoints(

,

);

(

.NotEmpty()) {

(editedalign.

().size() >

.Exons().size()) {

(align.

().back().Limits().GetLength() >

) {

=

.GetLength();

(

.Exons()[ie-1].m_fsplice) {

.SetFrom(

.Exons()[ie-1].GetFrom());

+=

.Exons()[ie-1].Limits().GetLength();

=

.GetAlignMap().ShrinkToRealPoints(

,

);

(

.NotEmpty()) {

(editedalign.

().size() >

.Exons().size()) {

EnpPoint {

= 0, eRightPlus = 1, eRightMinus = 2, eLeftPlus = 4, eLeftMinus = 8};

vector<unsigned char> end_status(

, 0);

(

ie = 0; ie < (

)align.

().size(); ++ie) {

(align.

()[ie].Limits().Empty()) {

= align.

()[ie-1].GetTo();

(

< right_end) {

end_status[al] |= eLeftPlus;

left_minus[al] =

;

end_status[al] |= eLeftMinus;

(ie < (

)align.

().size()-1) {

= align.

()[ie+1].GetFrom();

right_plus[bl] =

;

end_status[bl] |= eRightPlus;

right_minus[bl] =

;

end_status[bl] |= eRightMinus;

(

= 1;

<

; ++

) {

right_plus[

] =

(right_plus[

],right_plus[

-1]);

right_minus[

] =

(right_minus[

],right_minus[

-1]);

(

=

-2;

>= 0; --

) {

left_plus[

] =

(left_plus[

],left_plus[

+1]);

left_minus[

] =

(left_minus[

],left_minus[

+1]);

TAlignModelList::iterator

= it++;

good_alignment =

;

keepdoing =

;

(keepdoing && good_alignment) {

(

ie = 0; ie < (

)align.

().size(); ++ie) {

rights = &right_plus;

rights = &right_minus;

firstclip = new_l;

(ig->first.GetFrom() <= putativel && ig->first.GetTo() >= firstclip) {

(prot_fs == tsa_fs)

(

= 0;

< (

)pindels.size() && pindels[

].Loc() <= new_l+

; ++

)

new_l =

(new_l,pindels[

].

());

good_alignment =

;

good_alignment =

;

lefts = &left_minus;

firstclip = new_r;

(ig->first.GetFrom() <= firstclip && ig->first.GetTo() >= putativer) {

(prot_fs == tsa_fs)

(

= (

)pindels.size()-1;

>= 0 && pindels[

].Loc() >= new_r-

; --

)

new_r =

(new_r,pindels[

].

()-1);

good_alignment =

;

good_alignment =

;

(ie == (

)align.

().size()-1) {

(!good_alignment)

cerr <<

<<

.

() <<

<< total <<

<< endl;

(

->Limits().NotEmpty()) {

(ig->GetSource().m_range.NotEmpty())

(TAlignModelList::const_iterator

, TAlignModelList::const_iterator

) {

(

->Limits() ==

->Limits()) {

(

->Ident() !=

->Ident())

->Ident() >

->Ident();

->TargetAccession() <

->TargetAccession();

}

(

->Limits().GetFrom() !=

->Limits().GetFrom()) {

->Limits().GetFrom() <

->Limits().GetFrom();

->Limits().GetTo() >

->Limits().GetTo();

(!

.m_seq.empty() || !

.m_seq.empty()) {

.m_seq <

.m_seq;

}

(

.Limits().Empty()) {

}

(

.Limits().Empty()) {

}

(

.m_fsplice !=

.m_fsplice) {

.m_fsplice <

.m_fsplice;

}

(

.m_ssplice !=

.m_ssplice) {

.m_ssplice <

.m_ssplice;

.Limits() <

.Limits();

(

.size() !=

.size()) {

.size() <

.size();

(

= 0;

< (

)

.size(); ++

) {

cerr <<

<<

<<

<<

<< endl;

oep = args[

].AsInteger();

max_extend = args[

].AsInteger();

left_exon_ends, right_exon_ends;

& intron = it->first;

right_exon_ends.

(

);

deque<SAlignIndividual>& alideque =

->second;

(deque<SAlignIndividual>, k, alideque) {

rnaseq_or_est.push_back(align);

notspliced = alc.

().empty();

list<SAlignExtended> TEA_List;

TEA_List extended_aligns;

collapsed =

;

(TEA_List::iterator itloop = extended_aligns.begin(); itloop != extended_aligns.end(); ) {

TEA_List::iterator ita = itloop++;

rnaseq_or_est.push_back(align);

extended_aligns.erase(ita);

}

(!collapsed) {

(aj.

.

()-ita->m_initial_right_end > max_extend)

extended_aligns.push_back(

(aj,left_exon_ends,right_exon_ends));

(TEA_List, ita, extended_aligns) {

rnaseq_or_est.push_back(align);

* mp = (align.

() ==

) ? &strandedplus_len : &strandedminus_len;

(mp->

() || mp->rbegin()->first+mp->rbegin()->second < align.

().

()) {

mp->rbegin()->second =

(mp->rbegin()->second, align.

().

()-mp->rbegin()->first+1);

forced_orientation = 0;

included_in_plus =

;

included_in_plus =

;

included_in_minus =

;

included_in_minus =

;

(included_in_plus != included_in_minus) {

++forced_orientation;

cerr <<

<< forced_orientation << endl;

map<CGeneModel::TExons, vector<TAlignModelList::iterator>,

> TEstHolder;

TEstHolder est_for_collapsing;

(exons.size() == 1) {

(exons.front().m_seq.empty());

(exons.front().m_ssplice_sig !=

)

exons.front().Limits().SetFrom(exons.front().GetTo());

(exons.back().m_fsplice_sig !=

)

exons.back().Limits().SetTo(exons.back().GetFrom());

est_for_collapsing[exons].push_back(

);

list<TAlignModelList::iterator> ests(

->second.begin(),

->second.end());

(list<TAlignModelList::iterator>::iterator ihost = ests.begin(); ihost != ests.end(); ++ihost) {

(ri != right_exon_ends.

())

(li != left_exon_ends.

())

list<TAlignModelList::iterator>::iterator iloop = ihost;

(++iloop; iloop != ests.end(); ) {

list<TAlignModelList::iterator>::iterator iguest = iloop++;

flex_cap = 0;

flex_polya = 0;

(status_align.second.Limits().GetFrom() >= 0 && status_align.second.Limits().GetTo() <

.

() &&

(status_align.second, clsset)) {

cerr <<

<< total <<

<< flex_cap <<

<< flex_polya <<

<< endl;

vector<TSignedSeqRange> transcript_exons;

chainer_tsa = (acc.find(

) != string::npos);

left_seq, right_seq;

left_seq = transcript.substr(0,tlim.

());

left_src.

= left_texon;

right_seq = transcript.substr(tlim.

()+1);

right_src.

= right_texon;

(left_seq, right_seq);

(left_texon, right_texon);

(left_src, right_src);

(!left_seq.empty() && (fill&

) != 0 && !chainer_tsa) {

transcript_exons.push_back(left_texon);

(

= 0;

< (

)align.

().size(); ++

) {

transcript_exons.push_back(texon);

(!right_seq.empty() && (fill&

) != 0 && !chainer_tsa) {

transcript_exons.push_back(right_texon);

galign.

() |= status;

& stored = rslt.first->second;

stored.SetWeight(stored.Weight()+

);

acc =

.TargetAccession();

(

& c : acc)

(acc.find(

) != string::npos) {

(gap->first <=

.Limits().GetTo() && gap->first+gap->second-1 >=

.Limits().GetFrom())

corrections =

.FrameShifts();

(

->IsMismatch()) {

seq =

->GetInDelV();

(

= 0;

<

->Len(); ++

)

(acc.find(

) != string::npos)

(acc.find(

) != string::npos)

pos =

.Limits().GetFrom();

pos =

.Limits().GetTo();

(

.Exons().size() == 1)

long_read = acc.find(

) != string::npos && acc.find(

) == string::npos;

(long_read &&

.Exons().front().m_ident == 0) {

& indels =

.FrameShifts();

it = indels.begin();

align_len = exon.Limits().GetLength();

matches = align_len;

( ;it != indels.end() && it->IntersectingWith(exon.GetFrom(), exon.GetTo()); ++it) {

(it->IsMismatch() || it->IsInsertion())

matches -= it->Len();

(it->IsDeletion())

align_len += it->Len();

exon.m_ident = matches/align_len;

shift =

.TranscriptLimits().GetFrom();

(

= 0;

< (

)

.Exons().size(); ++

) {

te =

.TranscriptExon(

);

eseq = transcript.substr(te.GetFrom()-shift, te.GetLength());

(

== (

)

.Exons().size()-1) {

lim.

(

.Exons()[

+1].GetFrom());

(

.Exons()[

].m_ssplice &&

.Exons()[

+1].m_fsplice)

cerr <<

<<

.ID() <<

<<

<<

<<

.Exons()[

].GetTo()+1 <<

<<

.Exons()[

+1].GetFrom()+1 <<

<< eseq <<

;

(lim.

()) {

cerr <<

<<

.ID() <<

;

(

= (

)

.Exons().size()-1;

> 0; --

) {

te =

.TranscriptExon(

);

eseq = transcript.substr(te.GetFrom()-shift, te.GetLength());

lim.

(

.Exons()[

-1].GetTo());

(

.Exons()[

-1].m_ssplice &&

.Exons()[

].m_fsplice)

cerr <<

<<

.ID() <<

<<

<<

<<

.Exons()[

-1].GetTo()+1 <<

<<

.Exons()[

].GetFrom()+1 <<

<< eseq <<

;

(lim !=

.Limits()) {

use_alignment =

;

not_aligned_5p = tlim.

();

not_aligned_3p =

.TargetLen()-1-tlim.

();

(not_aligned_5p, not_aligned_3p);

use_alignment =

;

(use_alignment) {

(

.Strand() ==

) {

pos =

.Limits().GetFrom();

pos =

.Limits().GetTo();

(

= 1;

< e.size(); ++

) {

(e[

-1].m_ssplice && e[

].m_fsplice) {

ident =

(e[

-1].m_ident, e[

].m_ident);

sig = e[

-1].m_ssplice_sig+e[

].m_fsplice_sig;

sig = e[

].m_fsplice_sig+e[

-1].m_ssplice_sig;

.m_keep_anyway =

;

e[

-1].Limits().GetLength() > 15 && e[

-1].m_ident > 0.99 &&

e[

].Limits().GetLength() > 15 && e[

].m_ident > 0.99)) {

.m_selfsp_support =

;

.m_sr_support += align.

()+0.5;

.m_est_support += align.

()+0.5;

.m_other_support += align.

()+0.5;

.m_intron_num =

(

.m_intron_num, (

)e.size()-1);

.m_weight += align.

();

.m_ident =

(

.m_ident,ident);

(

.Strand() ==

) {

pos =

.Limits().GetFrom();

pos =

.Limits().GetTo();

(

.Strand() ==

) {

pos =

.Limits().GetFrom();

pos =

.Limits().GetTo();

cerr <<

<<

<<

<< endl;

deque<SAlignIndividual>& alideque =

->second;

(!alideque.empty()) {

deque<SAlignIndividual>::iterator ali = alideque.begin();

(deque<SAlignIndividual>::iterator farp = ali+1; farp != alideque.end(); ++farp) {

(farp->m_range == ali->m_range) {

ali->m_weight += farp->m_weight;

(deque<char>::iterator p = id_pool.begin()+farp->m_target_id; *p != 0; ++p) {

(ali-alideque.begin()+1 <= (

)alideque.size());

alideque.resize(ali-alideque.begin()+1);

deque<char>::iterator

= id_pool.begin();

ali = alideque.begin();

(deque<char>::iterator farp =

; farp != id_pool.end(); ) {

(farp != id_pool.end() && *farp == 0) {

(farp != id_pool.end()) {

(farp-id_pool.begin() == ali->m_target_id) {

ali->m_target_id -= shift;

(ali->m_target_id >= 0);

(*farp != 0) {

id_pool.resize(

-id_pool.begin());

(ali == alideque.end());

bool OneExonCompare(const CModelExon &a, const CModelExon &b)

bool OriginalOrder(const SAlignIndividual &a, const SAlignIndividual &b)

bool isGoodIntron(int a, int b, EStrand strand, const CAlignCollapser::TAlignIntrons &introns, bool check_introns_on_both_strands)

string GetTargetAcc(int shift, const deque< char > &id_pool)

int TotalFrameShift(const TInDels &indels, int a, int b)

bool AlignmentMarkedForDeletion(const SAlignIndividual &ali)

#define MAX_DIST_TO_FLANK_GAP

bool AlignmentIsSupportedBySR(const CAlignModel &align, const vector< double > &coverage, int mincoverage, int left_end)

#define NOT_ALIGNED_PHONY_CAGE

#define SPECIAL_ALIGN_LEN

void remove_if(Container &c, Predicate *__pred)

TSignedSeqPos FullLength() const

void Init(const CSeqVector &sv, TSignedSeqPos from, TSignedSeqPos to)

string substr(TSignedSeqPos p, TSignedSeqPos l) const

CAlignModel FillGapsInAlignmentAndAddToGenomicGaps(const CAlignModel &align, int fill)

bool RemoveNotSupportedIntronsFromProt(CAlignModel &align)

CAlignCollapser(string contig="", CScope *scope=0, bool nofilteringcollapsing=false)

void AddAlignment(CAlignModel &align)

bool m_no_lr_only_introns

void InitContig(string contig, CScope *scope)

vector< double > m_coverage

map< tuple< int, TSignedSeqPos, EStrand >, CAlignModel > m_special_aligns

void ClipNotSupportedFlanks(CAlignModel &align, double clip_threshold, double min_lim=0)

bool RemoveNotSupportedIntronsFromTranscript(CAlignModel &align, bool check_introns_on_both_strands) const

void GetOnlyOtherAlignments(TAlignModelClusterSet &clsset)

bool CheckAndInsert(const CAlignModel &align, TAlignModelClusterSet &clsset) const

TAlignIntrons m_align_introns

SCorrectionData m_correction_data

void ClipESTorSR(CAlignModel &align, double clip_threshold, double min_lim)

TIntMap m_genomic_gaps_len

void GetCollapsedAlgnments(TAlignModelClusterSet &clsset)

TAlignModelList m_aligns_for_filtering_only

bool m_use_long_reads_tss

void CleanSelfTranscript(CAlignModel &align, const string &trans) const

void AddFlexible(int status, TSignedSeqPos pos, EStrand strand, Int8 id, double weight)

static void SetupArgDescriptions(CArgDescriptions *arg_desc)

CAlignModel GetAlignment(const SAlignIndividual &ali, const deque< char > &target_id_pool) const

vector< SIntron > Tintrons

const Tintrons & GetIntrons() const

TSignedSeqRange MapRangeEditedToOrig(TSignedSeqRange edited_range, bool withextras=true) const

void EditedSequence(const In &original_sequence, Out &edited_sequence, bool includeholes=false) const

TSignedSeqRange ShrinkToRealPoints(TSignedSeqRange orig_range, bool snap_to_codons=false) const

int FShiftedLen(TSignedSeqRange ab, ERangeEnd lend, ERangeEnd rend) const

TSignedSeqRange MapRangeOrigToEdited(TSignedSeqRange orig_range, ERangeEnd lend, ERangeEnd rend) const

string TargetAccession() const

virtual void Clip(TSignedSeqRange limits, EClipMode mode, bool ensure_cds_invariant=true)

CConstRef< objects::CSeq_id > GetTargetId() const

virtual void CutExons(TSignedSeqRange hole)

virtual CAlignMap GetAlignMap() const

void SetTargetId(const objects::CSeq_id &id)

void AddExon(TSignedSeqRange exon, const string &fs="", const string &ss="", double ident=0, const string &seq="", const CInDelInfo::SSource &src=CInDelInfo::SSource())

virtual void CutExons(TSignedSeqRange hole)

TSignedSeqRange TranscriptLimits() const

EStrand Orientation() const

const TExons & Exons() const

virtual CAlignMap GetAlignMap() const

TSignedSeqRange TranscriptExon(int i) const

void ReverseComplementModel()

void SetStrand(EStrand s)

TSignedSeqRange Limits() const

vector< CModelExon > TExons

TInDels GetInDels(bool fs_only) const

static CRef< CSeq_id > ToSeq_id(const string &str)

void Insert(const typename Cluster::TModel &a)

TSignedSeqPos GetFrom() const

const TSignedSeqRange & Limits() const

TSignedSeqPos GetTo() const

static CNcbiApplication * Instance(void)

Singleton method.

container_type::const_iterator const_iterator

container_type::iterator iterator

const_iterator begin() const

const_iterator end() const

const_iterator lower_bound(const key_type &key) const

iterator_bool insert(const value_type &val)

const_iterator upper_bound(const key_type &key) const

container_type::value_type value_type

const_iterator find(const key_type &key) const

iterator_bool insert(const value_type &val)

const_iterator begin() const

parent_type::iterator iterator

const_iterator upper_bound(const key_type &key) const

const_iterator end() const

const_iterator lower_bound(const key_type &key) const

parent_type::const_iterator const_iterator

struct parameters_t * pb[]

double Entropy(const string &seq)

list< CAlignModel > TAlignModelList

bool Include(TSignedSeqRange big, TSignedSeqRange small)

void ReverseComplement(const BidirectionalIterator &first, const BidirectionalIterator &last)

EStrand OtherStrand(EStrand s)

vector< CInDelInfo > TInDels

list< Model > GetAlignParts(const Model &algn, bool settrimflags)

virtual const CArgs & GetArgs(void) const

Get parsed command line arguments.

#define ITERATE(Type, Var, Cont)

ITERATE macro to sequence through container elements.

int TSignedSeqPos

Type for signed sequence position.

#define NON_CONST_ITERATE(Type, Var, Cont)

Non constant version of ITERATE macro.

void swap(NCBI_NS_NCBI::pair_base_member< T1, T2 > &pair1, NCBI_NS_NCBI::pair_base_member< T1, T2 > &pair2)

void AddFlag(const string &name, const string &comment, CBoolEnum< EFlagValue > set_value=eFlagHasValueIfSet, TFlags flags=0)

Add description for flag argument.

void SetCurrentGroup(const string &group)

Set current arguments group name.

void AddDefaultKey(const string &name, const string &synopsis, const string &comment, EType type, const string &default_value, TFlags flags=0, const string &env_var=kEmptyStr, const char *display_value=nullptr)

Add description for optional key with default value.

@ eDouble

Convertible into a floating point number (double)

@ eInteger

Convertible into an integer number (int or Int8)

#define NCBI_THROW(exception_class, err_code, message)

Generic macro to throw an exception, given the exception class, error code and message string.

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

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

const CMolInfo * GetMolInfo(const CBioseq &bioseq)

Retrieve the MolInfo object for a given bioseq handle.

CBioseq_Handle GetBioseqHandle(const CSeq_id &id)

Get bioseq handle by seq-id.

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 IsInGap(TSeqPos pos) const

true if sequence at 0-based position 'pos' has gap Note: this method is not MT-safe,...

int64_t Int8

8-byte (64-bit) signed integer

position_type GetLength(void) const

bool NotEmpty(void) const

static TThisType GetEmpty(void)

CRange< TSignedSeqPos > TSignedSeqRange

static TThisType GetWhole(void)

#define END_SCOPE(ns)

End the previously defined scope.

#define BEGIN_SCOPE(ns)

Define a new scope.

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.

TTech GetTech(void) const

Get the Tech member data.

bool IsSetTech(void) const

Check if a value has been assigned to Tech data member.

@ eTech_tsa

transcriptome shotgun assembly

unsigned int

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

string GetDNASequence(CConstRef< objects::CSeq_id > id, CScope &scope)

constexpr auto sort(_Init &&init)

double value_type

The numeric datatype used by the parser.

Magic spell ;-) needed for some weird compilers... very empiric.

Defines command line argument related classes.

std::istream & in(std::istream &in_, double &x_)

Int4 delta(size_t dimension_, const Int4 *score_)

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

static SLJIT_INLINE sljit_ins l(sljit_gpr r, sljit_s32 d, sljit_gpr x, sljit_gpr b)

bool operator()(TAlignModelList::const_iterator a, TAlignModelList::const_iterator b)

const deque< char > & id_pool

LeftAndLongFirstOrder(const deque< char > &idp)

bool operator()(const SAlignIndividual &a, const SAlignIndividual &b)

bool operator()(const CGeneModel::TExons &a, const CGeneModel::TExons &b) const

SAlignExtended(SAlignIndividual &ali, const set< int > &left_exon_ends, const set< int > &right_exon_ends)

TSignedSeqPos m_target_id

list< TSignedSeqRange > m_confirmed_intervals

map< int, char > m_replacements

TInDels m_correction_indels

int g(Seg_Gsm *spe, Seq_Mtf *psm, Thd_Gsm *tdg)

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