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

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

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

set<pair<Int8,string>>

;

:m_hmm_params(hmm_params), m_gnomon(gnomon), m_edited_contig_map(edited_contig_map), m_limits(

), m_contig_acc(contig_acc), m_idnext(1), m_idinc(1)

->MakeChains(models);

m_align(0), m_cds_info(0), m_align_map(0), m_left_member(0), m_right_member(0), m_sink_for_contained(0),

m_copy(0), m_contained(0), m_identical_count(0),

m_left_num(0), m_right_num(0), m_num(0),

m_splice_weight(0), m_left_splice_num(0), m_right_splice_num(0), m_splice_num(0),

m_type(

), m_left_cds(0), m_right_cds(0), m_cds(0), m_included(

), m_postponed(

), m_internal(

),

m_marked_for_deletion(

), m_marked_for_retention(

), m_restricted_to_start(

),

m_gapped_connection(

), m_fully_connected_to_part(-1), m_not_for_chaining(

),

m_trusted_group(0), m_left_trusted_group(0), m_right_trusted_group(0), m_cds_from_trusted(

), m_excluded_readthrough(

) {}

MarkIncludedForChain();

MarkPostponed();

MarkPostponedForChain();

CollectCodingContainedForMemeber();

, m_left_cds, m_right_cds, m_cds;

tuple<TIDMap, TSignedSeqRange> PeaksAndLimits(

determinant,

min_blob_weight,

max_empty_dist,

min_splice_dist);

tuple<TIVec, TSignedSeqRange> MainPeaks(

& peak_weights,

secondary_peak,

tertiary_peak,

tertiary_peak_coverage,

right_end);

RestoreTrimmedEnds(

trim);

RemoveFshiftsFromUTRs();

SetOpenForPartialyAlignedProteins(map<

, pair<bool,bool> >& prot_complet);

pair<bool,bool> ValidPolyA(

pos,

& contig);

ClipToCap(

min_cap_blob,

max_dist,

min_flank_exon,

secondary_peak,

recalulate_support =

);

ClipToPolyA(

& contig,

min_polya_blob,

max_dist,

min_flank_exon,

secondary_peak,

tertiary_peak,

tertiary_peak_coverage,

recalulate_support =

);

CheckSecondaryCapPolyAEnds();

ClipLowCoverageUTR(

utr_clip_threshold,

recalulate_support =

);

CalculateDropLimits();

CalculateSupportAndWeightFromMembers(

keep_all_evidence =

);

SetConfirmedStartStopForCompleteProteins(map<

, pair<bool,bool> >& prot_complet,

& minscor);

SetConsistentCoverage();

HarborsNested(

& other_chain,

check_in_holes)

;

HarborsNested(

& other_gene,

check_in_holes)

;

HasTrustedEvidence()

;

list<CGeneModel>::iterator

;

list<CGeneModel>::const_iterator

;

IsAlternative(

&

)

;

IsAllowedAlternative(

ncbi::gnomon::CGeneModel&,

maxcomposite)

;

()

{

!m_nested_in_genes.empty(); }

LargeCdsOverlap(

&

)

;

HarborsNested(

& other_chain,

check_in_holes)

;

HarborsNested(

& other_gene,

check_in_holes)

;

set<CGene*> RemoveGeneFromOtherGenesSets();

(*i)->RemoveFromHarbored(

);

(*i)->RemoveFromNestedIn(

);

m_harbors_genes;

(RealCdsLimits().NotEmpty())

gene_lim_for_nested =

()->OpenCds() ?

()->MaxCdsLimits() : RealCdsLimits();

(!

(gene_lim_for_nested,range))

(RealCdsLimits().NotEmpty() && (*it)->ReadingFrame().Empty())

((*it)->ReadingFrame().NotEmpty())

model_lim_for_nested = (*it)->OpenCds() ? (*it)->MaxCdsLimits() : (*it)->RealCdsLimits();

HarborsRange(other_lim_for_nested, check_in_holes);

HarborsRange(other_lim_for_nested, check_in_holes);

common_cds += (ib->Limits()&

.RealCdsLimits()&ia->Limits()&

.RealCdsLimits()).

();

m_real_cds_limits +=

.RealCdsLimits();

m_maxscore =

(m_maxscore,

.Score());

(

.Support().empty()) {

(s->IsCore() && ++composite > maxcomposite)

;

(

.PStop(

) || !

.FrameShifts().empty())

vector<TSignedSeqRange> gene_gapfill_exons;

gene_gapfill_exons.push_back(e->

());

vector<TSignedSeqRange> a_gapfill_exons;

a_gapfill_exons.push_back(e->

());

(gene_gapfill_exons != a_gapfill_exons)

a_share_intron =

;

set<TSignedSeqRange> b_introns;

(

= 1;

< (

)

.Exons().size(); ++

) {

(

.Exons()[

-1].m_ssplice &&

.Exons()[

].m_fsplice) {

b_introns.insert(intron);

a_has_new_intron =

;

(

= 1;

< (

)

.Exons().size(); ++

) {

(

.Exons()[

-1].m_ssplice &&

.Exons()[

].m_fsplice &&

.Exons()[

-1].m_ssplice_sig !=

&&

.Exons()[

].m_fsplice_sig !=

) {

(b_introns.insert(intron).second)

a_has_new_intron =

;

a_share_intron =

;

(a_has_new_intron) {

}

(!gene_gapfill_exons.empty()) {

}

(

.RealCdsLimits().NotEmpty() &&

.RealCdsLimits().NotEmpty() && !

.RealCdsLimits().IntersectingWith(

.RealCdsLimits()) && (!

.TrustedmRNA().empty() || !

.TrustedProt().empty())) {

}

(

.RealCdsLen() <=

.RealCdsLen()){

(a_share_intron || gene_gapfill_exons.empty());

(

.Strand() !=

()->Strand())

gene_has_trusted =

;

((*it)->HasTrustedEvidence()) {

gene_has_trusted =

;

has_common_splice =

;

has_common_splice =

;

(has_common_splice && (!gene_has_trusted || !

.HasTrustedEvidence()))

(

.ReadingFrame().NotEmpty() && RealCdsLimits().NotEmpty()) {

amap(

.Exons(),

.FrameShifts(),

.Strand(),

.GetCdsInfo().Cds());

(

j = 0; j <

.Exons().

(); ++j) {

(

k =

(

.Exons()[j].GetFrom(),

.GetCdsInfo().Cds().GetFrom()); k <=

(

.Exons()[j].GetTo(),

.GetCdsInfo().Cds().GetTo()); ++k) {

(p < (

)acds_map.size());

has_common_cds =

;

(!

.GetCdsInfo().Cds().IntersectingWith((*it)->GetCdsInfo().Cds()))

gmap((*it)->Exons(), (*it)->FrameShifts(), (*it)->Strand(), (*it)->GetCdsInfo().Cds());

(

j = 0; j < (*it)->Exons().

(); ++j) {

(

k =

((*it)->Exons()[j].GetFrom(),(*it)->GetCdsInfo().Cds().GetFrom()); k <=

((*it)->Exons()[j].GetTo(),(*it)->GetCdsInfo().Cds().GetTo()); ++k) {

(p < (

)cds_map.size());

(

= 0;

< acds_map.size(); ) {

( ; j < cds_map.size() && (acds_map[

] != cds_map[j] ||

%3 != j%3); ++j);

(j == cds_map.size()) {

( ; j < cds_map.size() &&

< acds_map.size() && acds_map[

] == cds_map[j]; ++j, ++

, ++

);

has_common_cds =

;

has_common_cds;

has_common_splice;

(!

.Support().empty() &&

.Support().empty())

(

.Support().empty() && !

.Support().empty())

atrusted = !

.TrustedmRNA().empty() || !

.TrustedProt().empty();

btrusted = !

.TrustedmRNA().empty() || !

.TrustedProt().empty();

(atrusted && !btrusted) {

}

(btrusted && !atrusted) {

}

(

.ReadingFrame().NotEmpty() &&

.ReadingFrame().Empty()) {

}

(

.ReadingFrame().NotEmpty() &&

.ReadingFrame().Empty()) {

}

(

.ReadingFrame().NotEmpty()) {

ds = 0.05*

(

.Score());

as =

.Score();

ds = 0.05*

(

.Score());

bs =

.Score();

(

.m_splice_weight >

.m_splice_weight)

(

.m_splice_weight <

.m_splice_weight)

(

.Weight() >

.Weight())

(

.Weight() <

.Weight())

(

.Limits().GetLength() !=

.Limits().GetLength())

(

.Limits().GetLength() <

.Limits().GetLength());

.ID() <

.ID();

asize =

.m_splice_weight;

bsize =

.m_splice_weight;

ds = 0.025*(asize+bsize);

(bsize > asize)

(

.Limits().GetLength() !=

.Limits().GetLength())

(

.Limits().GetLength() <

.Limits().GetLength());

.ID() <

.ID();

gene_good_enough_to_be_annotation = allow_partialalts || gene.front()->GoodEnoughToBeAnnotation();

gene_cds = (gene.size() > 1 || gene.front()->CompleteCds() || algn_good_enough_to_be_annotation) ? gene.

() : gene.front()->MaxCdsLimits();

(!gene_good_enough_to_be_annotation && !algn_good_enough_to_be_annotation) {

(

= 1;

< (

)

.Exons().size(); ++

) {

(

.Exons()[

].m_ssplice_sig ==

&&

.Exons()[

].m_fsplice_sig ==

&&

.Exons()[

].Limits().IntersectingWith(gene_cds)) {

(

= 1;

< (

)algn.

().size(); ++

) {

(algn.

()[

].m_ssplice_sig ==

&& algn.

()[

].m_fsplice_sig ==

&& algn.

()[

].Limits().IntersectingWith(algn_cds)) {

}

(algn.

().

() || gene.front()->ReadingFrame().Empty()) {

eNotCompatible;

}

(algn.

() > altfrac/100*gene.front()->RealCdsLen() || algn.

() > altfrac/100*gene.front()->Score()) {

eNotCompatible;

set<TSignedSeqRange> gene_gapfill_introns;

set<TSignedSeqRange> align_gapfill_introns;

(

= 1;

< (

)

.Exons().size(); ++

) {

(

.Exons()[

-1].m_ssplice_sig ==

||

.Exons()[

].m_fsplice_sig ==

) {

gene_gapfill_introns.insert(intron);

(

= 1;

< (

)algn.

().size(); ++

) {

(algn.

()[

-1].m_ssplice_sig ==

|| algn.

()[

].m_fsplice_sig ==

) {

align_gapfill_introns.insert(intron);

(set<TSignedSeqRange>, ig, gene_gapfill_introns) {

(set<TSignedSeqRange>, ia, align_gapfill_introns) {

(ig->IntersectingWith(*ia))

eNotCompatible;

(algn.

(gene, gene_good_enough_to_be_annotation))

(gene.

(algn, algn_good_enough_to_be_annotation))

(!algn_cds.

() && !gene_cds.

()) {

eNotCompatible;

(gene_good_enough_to_be_annotation && algn_good_enough_to_be_annotation) {

(gene.front()->Strand() != algn.

() && allow_opposite_strand &&

eNotCompatible;

(TChainPointerList::iterator itloop = not_placed_yet.begin(); itloop != not_placed_yet.end(); ) {

TChainPointerList::iterator it = itloop++;

list<CGene*> possibly_nested;

good_model =

;

(list<CGene>::iterator itl = alts.begin(); good_model && itl != alts.end(); ++itl) {

possibly_nested.push_back(&(*itl));

alts.push_back(

());

alts.back().Insert(algn);

not_placed_yet.erase(it);

(list<CGene*>, itl, possibly_nested) {

(*itl)->AddToNestedIn(&alts.back());

alts.back().AddToHarbored(*itl);

(TChainPointerList::iterator itloop = not_placed_yet.begin(); itloop != not_placed_yet.end(); ) {

TChainPointerList::iterator it = itloop++;

list<list<CGene>::iterator> included_in;

list<CGene*> possibly_nested;

list<CGene*> nested_in;

good_model =

;

(list<CGene>::iterator itl = alts.begin(); good_model && itl != alts.end(); ++itl) {

nested_in.push_back(&(*itl));

possibly_nested.push_back(&(*itl));

included_in.push_back(itl);

eNotCompatibleNested:

(itl->IsAlternative(algn))

included_in.push_back(itl);

& gene = *included_in.front();

& model = *gene.front();

(algn_cds_len < 0.8*model_cds_len)

not_placed_yet.push_back(gene.front());

(list<CGene*>, itl, nested_in) {

(*itl)->AddToHarbored(&gene);

(list<CGene*>, itl, possibly_nested) {

(*itl)->AddToNestedIn(&gene);

not_placed_yet.erase(it);

(TChainPointerList::iterator itloop = not_placed_yet.begin(); itloop != not_placed_yet.end(); ) {

TChainPointerList::iterator it = itloop++;

list<list<CGene>::iterator> included_in;

list<CGene*> possibly_nested;

good_model =

;

(list<CGene>::iterator itl = alts.begin(); good_model && itl != alts.end(); ++itl) {

possibly_nested.push_back(&(*itl));

included_in.push_back(itl);

(good_model && !included_in.empty() && (allow_partialalts || included_in.front()->front()->GoodEnoughToBeAnnotation())) {

(included_in.size() == 1) {

& gene = *included_in.front();

not_placed_yet.erase(it);

(list<CGene*>, itl, possibly_nested) {

(*itl)->AddToNestedIn(&gene);

allow_connection =

;

cds_overlap =

;

cds_overlap =

;

(list<list<CGene>::iterator>, k, included_in) {

(!(*k)->IsAlternative(

)) {

cds_overlap =

;

algn.

(

);

allow_connection =

;

(allow_connection) {

& gene = *included_in.front();

(list<list<CGene>::iterator>, k, included_in) {

(k != included_in.begin()) {

(CheckCompatibility(*included_in.front(), **

) == eAlternative) {

(*l)->AddComment(

);

included_in.front()->Insert(**

);

not_placed_yet.push_back(*

);

TChainPointerList::iterator idest = itloop;

not_placed_yet.insert(idest, *

);

set<CGene*> nested_genes = (*k)->RemoveGeneFromOtherGenesSets();

(set<CGene*>,

, nested_genes)

possibly_nested.push_back(*

);

not_placed_yet.erase(it);

(list<CGene*>, itl, possibly_nested) {

(*itl)->AddToNestedIn(&gene);

list<CGene>::iterator included_in(alts.end());

list<CGene*> possibly_nested;

list<CGene*> nested_in;

good_model =

;

(list<CGene>::iterator itl = alts.begin(); good_model && itl != alts.end(); ++itl) {

= CheckCompatibility(*itl, algn);

eNotCompatibleNested:

eNotCompatible:

rejected.push_back(&algn);

ost <<

<< itl->front()->ID();

(

== eNotCompatibleNested)

good_model =

;

(!allow_partialalts && !itl->front()->GoodEnoughToBeAnnotation()) {

rejected.push_back(&algn);

ost <<

<< itl->front()->ID();

good_model =

;

}

(included_in == alts.end()) {

good_model =

;

rejected.push_back(&algn);

ost <<

<< itl->front()->ID() <<

<< included_in->front()->ID();

nested_in.push_back(&(*itl));

possibly_nested.push_back(&(*itl));

(included_in != alts.end()) {

included_in->Insert(algn);

genep = &(*included_in);

alts.push_back(

());

genep = &alts.back();

alts.back().Insert(algn);

(list<CGene*>, itl, nested_in) {

((*itl)->HarborsNested(*genep,

)) {

(*itl)->AddToHarbored(genep);

(list<CGene*>, itl, possibly_nested) {

(*itl)->AddToNestedIn(genep);

TChainPointerList::iterator jt_loop = it;

(++jt_loop; jt_loop != not_placed_yet.end();) {

TChainPointerList::iterator jt = jt_loop++;

ost <<

<< ai.

();

rejected.push_back(&aj);

not_placed_yet.erase(jt);

(TChainPointerList::iterator it_loop = not_placed_yet.begin(); it_loop != not_placed_yet.end();) {

TChainPointerList::iterator it = it_loop++;

vector<const CChain*> candidates;

candidates.push_back(&aj);

(

= 0; alive &&

< candidates.size(); ++

) {

(

j =

+1; alive && j < candidates.size(); ++j) {

(!candidates[

]->Limits().IntersectingWith(candidates[j]->Limits())) {

ost <<

<< candidates[

]->ID() - ai.

() <<

<< candidates[j]->ID() - ai.

();

rejected.push_back(*it);

not_placed_yet.erase(it);

it->SetGeneID(it->ID());

it->SetRankInGene(0);

not_placed_yet.push_back(&(*it));

FilterOutSimilarsWithLowerScore(not_placed_yet, bad_aligns);

FilterOutTandemOverlap(not_placed_yet, bad_aligns, 80);

FindGeneSeeds(alts, not_placed_yet);

ReplacePseudoGeneSeeds(alts, not_placed_yet);

FindAltsForGeneSeeds(alts, not_placed_yet);

PlaceAllYouCan(alts, not_placed_yet, bad_aligns);

(*l)->SetGeneID(k->front()->ID());

(*l)->SetRankInGene(++rank);

(*l)->AddComment(

);

(alimits == blimits)

(alimits.

() > blimits.

());

tuple<Int8, TSignedSeqRange>

;

gmembers.insert(&m);

(members_genes.empty())

map<CGene*,list<SChainMember*> > TGeneToMembers;

map<TIdLim, TGeneToMembers> TMembersInDiffGenes;

TMembersInDiffGenes members_in_different_genes;

* genep = members_genes.front().second;

members_in_different_genes[idlim][genep].push_back(mp);

(

= 1;

< (

)members_genes.size(); ++

) {

* genep = members_genes[

].second;

(idlim_prev != idlim) {

TMembersInDiffGenes::iterator it = members_in_different_genes.find(idlim_prev);

(it->second.size() < 2)

members_in_different_genes.erase(it);

members_in_different_genes[idlim][genep].push_back(mp);

TMembersInDiffGenes::iterator it = members_in_different_genes.find(idlim);

(it->second.size() < 2)

members_in_different_genes.erase(it);

(TMembersInDiffGenes, imdg, members_in_different_genes) {

(TGeneToMembers, ig1, imdg->second) {

& gene1 = *ig1->first;

map<CChain*,TMemberPtrSet> TConflictMemebersInChains;

TConflictMemebersInChains conflict_members_in_chains;

(TMembersInDiffGenes, imdg, members_in_different_genes) {

(TGeneToMembers, ig1, imdg->second) {

& gene1 = *ig1->first;

* chain1p_orig = *ic1;

(list<SChainMember*>::const_iterator im = ig1->second.begin(); im != ig1->second.end() && mbr1p_orig == 0; ++im) {

(binary_search(chain1p_orig->

.begin(),chain1p_orig->

.end(),*im, std::less<SChainMember*>()))

(TGeneToMembers::const_iterator ig2 = imdg->second.begin(); mbr1p_orig != 0 && ig2 != ig1; ++ig2) {

& gene2 = *ig2->first;

* chain1p = chain1p_orig;

(list<SChainMember*>::const_iterator im = ig2->second.begin(); im != ig2->second.end() && mbr2p == 0; ++im) {

(binary_search(chain2p->

.begin(),chain2p->

.end(),*im, std::less<SChainMember*>()))

(chain1p->

().size() > 1)

(chain2p->

().size() > 1)

(chain1p,chain2p);

& chain1 = *chain1p;

& chain2 = *chain2p;

conflict_members_in_chains[&chain2].insert(mbr2p);

conflict_members_in_chains[&chain1].insert(mbr1p);

}

(

(core1,core2)) {

(

(align_lim,core1))

conflict_members_in_chains[&chain2].insert(mbr2p);

(

(core2,align_lim))

conflict_members_in_chains[&chain1].insert(mbr1p);

conflict_members_in_chains[&chain1].insert(mbr1p);

conflict_members_in_chains[&chain2].insert(mbr2p);

conflict_members_in_chains[&chain1].insert(mbr1p);

conflict_members_in_chains[&chain2].insert(mbr2p);

conflict_members_in_chains[&chain2].insert(mbr2p);

conflict_members_in_chains[&chain1].insert(mbr1p);

conflict_members_in_chains[&chain1].insert(mbr1p);

conflict_members_in_chains[&chain2].insert(mbr2p);

conflict_members_in_chains[&chain1].insert(mbr1p);

conflict_members_in_chains[&chain2].insert(mbr2p);

(

& gene : genes) {

(

* chainp : gene)

(TConflictMemebersInChains, it, conflict_members_in_chains) {

& chain = *it->first;

hard_limits = (hard_limits & chain.

());

}

(alim.

() > noclip_limits.

()) {

left_splice = -1;

right_splice = -1;

(

e = 1; e < (

)chain.

().size(); ++e) {

(left_splice < 0 && chain.

()[e-1].m_ssplice &&

(new_limits,chain.

()[e-1].GetTo()))

left_splice = chain.

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

(chain.

()[e].m_fsplice &&

(new_limits,chain.

()[e].GetFrom()))

right_splice = chain.

()[e].GetFrom();

left_weights_total = 0.;

right_weights_total = 0.;

(

e = 1; e < (

)

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

(

.Exons()[e-1].m_ssplice &&

.Exons()[e-1].GetTo() == left_splice) {

left_weights[alim.

()] +=

.Weight();

left_weights_total +=

.Weight();

(

.Exons()[e].m_fsplice &&

.Exons()[e].GetFrom() == right_splice) {

right_weights[alim.

()] +=

.Weight();

right_weights_total +=

.Weight();

(left_weights_total > 0.) {

(map<int,double>::reverse_iterator it = left_weights.rbegin(); it != left_weights.rend(); ++it) {

(

< 0.9*left_weights_total)

(left < new_limits.

())

(right_weights_total > 0.) {

(

< 0.9*right_weights_total)

(right > new_limits.

())

new_limits.

(right);

(new_limits != chain.

()) {

note +=

;

wasopen = chain.

();

->GetScore(chain, !no5pextension);

(wasopen != chain.

() && (wasopen ==

|| cds.

())) {

(m_type !=

)

deque<const SChainMember*> not_visited(1,

);

(!not_visited.empty()) {

not_visited.pop_back();

(c < mbr->m_identical_count) {

(included_in_list.insert(mi).second) {

contained.push_back(mi);

included_in_list.insert(mi->

->begin(),mi->

->end());

}

(included_in_list.find(mi) == included_in_list.end()) {

not_visited.push_back(mi);

AddCodingToContained(contained, included_in_list);

AddCodingToContained(contained, included_in_list);

left->AddCodingToContained(contained, included_in_list);

right->AddCodingToContained(contained, included_in_list);

deque<const SChainMember*> not_visited(1,

);

(!not_visited.empty()) {

not_visited.pop_back();

(c < mbr->m_identical_count) {

(included_in_list.insert(mi).second) {

contained.push_back(mi);

included_in_list.insert(mi->

->begin(),mi->

->end());

}

(included_in_list.find(mi) == included_in_list.end()) {

not_visited.push_back(mi);

AddToContained(contained, included_in_list);

AddToContained(contained, included_in_list);

left->AddToContained(contained, included_in_list);

right->AddToContained(contained, included_in_list);

contained = CollectContainedForChain();

m_postponed =

;

contained = CollectContainedForChain();

contained = CollectContainedForChain();

(alimits.

() < blimits.

());

(alimits == blimits)

(alimits.

() == blimits.

())

(alimits.

() < blimits.

());

(alimits.

() < blimits.

());

(alimits == blimits)

(alimits.

() < blimits.

());

(container.begin(),container.end());

container.erase( unique(container.begin(),container.end()), container.end() );

InsertMemberCopyWithoutCds(

* copy_ofp);

m_members.splice(m_members.end(),other.

);

m_copylist.splice(m_copylist.end(),other.

);

m_align_maps.splice(m_align_maps.end(),other.

);

m_containedlist.splice(m_containedlist.end(),other.

);

m_extra_cds.splice(m_extra_cds.end(),other.

);

insert(end(),other.begin(),other.end());

InsertMember(mbr, copy_ofp);

m_extra_cds.push_back(cds);

InsertMemberCopyWithCds(m_extra_cds.back(), copy_ofp);

InsertMember(mbr, copy_ofp);

InsertMember(mbr, copy_ofp);

m_members.push_back(m);

push_back(&m_members.back());

m_members.back().m_contained = &m_containedlist.back();

m_members.back().m_align_map = &m_align_maps.back();

m_members.back().m_align_map = copy_ofp->

;

(copy_ofp != 0) {

(copy_ofp->

== 0) {

m_copylist.push_back(

(1,copy_ofp));

copy_ofp->

= &m_copylist.back();

m_members.back().m_copy = copy_ofp->

;

copy_ofp->

->push_back(&m_members.back());

InsertMember(new_mbr, copy_ofp);

m_extra_cds.push_back(

());

InsertMember(*itcl);

m_members.back().m_orig_align = orig_aligns[itcl->ID()];

(unmodified_aligns.count(itcl->ID()))

m_members.back().m_unmd_align = &unmodified_aligns[itcl->ID()];

small_flex =

;

(big_limits == small_limits) {

->CutParts(models);

(!parts.empty()) {

models.splice(models.begin(),parts);

initial_size = pointers.size();

(

= 0;

< initial_size; ++

) {

clust.push_back(new_algn);

initial_size = pointers.size();

(

= 0;

< initial_size; ++

) {

map<int, set<int> > oriented_splices;

(set<TSignedSeqRange>,

, oriented_introns_plus) {

oriented_splices[

].insert(

->GetFrom());

oriented_splices[

].insert(

->GetTo());

(set<TSignedSeqRange>,

, oriented_introns_minus) {

oriented_splices[

].insert(

->GetFrom());

oriented_splices[

].insert(

->GetTo());

vector<pair<CCDSInfo::SPStop,TSignedSeqRange> > TPstopIntron;

TPstopIntron pstops_with_intron_plus;

TPstopIntron pstops_with_intron_minus;

TPstopIntron& pstops_with_intron = (algn.

() ==

) ? pstops_with_intron_plus : pstops_with_intron_minus;

left =

(left,s->GetFrom());

right =

(right,s->GetTo());

(s->GetLength() == 3) {

(

= 1;

< (

)algn.

().size(); ++

) {

pstops_with_intron.push_back(make_pair(*s,intron));

(pstops_with_intron_plus);

(pstops_with_intron_minus);

TPstopIntron& pstops_with_intron = (algn.

() ==

) ? pstops_with_intron_plus : pstops_with_intron_minus;

(pstops_with_intron.empty())

(TPstopIntron,

, pstops_with_intron) {

(

->second.GetLength() == 1) {

(

->first == *s)

(

= 1;

< (

)algn.

().size(); ++

) {

(

->second == intron &&

->first == *s)

(TPstopIntron,

, pstops_with_intron) {

(

= 0;

< (

)exons.size(); ++

) {

(

(exons[

].Limits(),

->first.GetFrom())) {

(

->second.GetLength() == 1) {

(

->first.GetTo() <= exons[

].GetTo())

(

< (

)exons.size()-1) {

(intron ==

->second &&

->first.GetTo() <= exons[

+1].GetTo())

= GoodCDNAScore(algn);

RemovePoorCds(algn,

);

strand = align.

();

(!tgr_info.count(strand))

second = upper_bound(tinfo.begin(), tinfo.end(), align.

().

(),

(

== second)

(

& e : align.

()) {

overlap = (e.

()&acds);

(

k = overlap.GetFrom(); k <= overlap.GetTo(); ++k) {

(p >= 0 && p%3 == 0) {

(p/3 < (

)acds_map.size());

paralogs =

;

(

it =

; it != second; ++it) {

tgr = it-tinfo.begin()+1;

(

& tcds_map : it->m_cds_maps) {

long_enough = 10;

(mci >= long_enough) {

num = prev_accessions.

();

(

&

: it->m_ids)

prev_accessions.

(

.second);

(num+it->m_ids.size() != prev_accessions.

())

cerr <<

<< align.

() <<

<< (paralogs ?

:

) <<

<< flag << endl;

(mbr.

!=

) {

(

p : *mbr.

)

p->m_marked_for_deletion =

;

initial_size = pointers.size();

(

= 0;

< initial_size; ++

) {

initial_size = pointers.size();

(

= 0;

< initial_size; ++

) {

(mbr.

->front()->m_align->Strand() == algn.

()) {

}

((*mbr.

)[1]->m_cds_info->ReadingFrame() == cdsinfo.

()) {

(indl->InDelEnd() > lim.

() && indl->Loc() <= lim.

())

fs.push_back(*indl);

jflex =

;

(!jflex && jlimits.

()-ai_max_cds.

() >= 5)

(!jflex && ai_max_cds.

()-jlimits.

() >= 5)

(

(j_from-i_from)%3 != 0)

iex = (

)ai.

().size();

jex = (

)aj.

().size();

left_exon_ends, right_exon_ends;

(

= 1;

< (

)algn.

().size(); ++

) {

(algn.

()[

-1].m_ssplice && algn.

()[

].m_fsplice) {

left_exon_ends.

(algn.

()[

].GetFrom());

right_exon_ends.

(algn.

()[

-1].GetTo());

(ri != right_exon_ends.

())

(li != left_exon_ends.

())

(

= 0;

< (

)pointers.size(); ++

) {

ssplice = ai.

()[

-1].m_ssplice_sig;

fsplice = ai.

()[

].m_fsplice_sig;

(ssplice ==

|| fsplice ==

)

(ai.

() ==

&& ((ssplice !=

&& ssplice !=

) || fsplice !=

))

(ai.

() ==

&& (ssplice !=

|| (fsplice !=

&& fsplice !=

)))

(indl->IntersectingWith(e->

(), e->

()))

(pointers[jfirst]->m_align->Limits() != ai.

())

(

j = jfirst; j < (

)pointers.size() && pointers[j]->m_align->Limits().GetFrom() <= ai.

().

(); ++j) {

IncludeInContained(mi, mi);

(CanIncludeJinI(mi, mj))

IncludeInContained(mi, mj);

(mj.

==

&& (!ai_left_complete || (!j_rflexible && (aj.

()&ai_rf).GetLength() > 5)))

(mj.

==

&& (!aj_right_complete || (!i_lflexible && (ai.

()&aj_rf).GetLength() > 5)))

(j_rflexible || i_lflexible)

((ai.

() & aj.

()).GetLength() < intersect_limit)

cds_overlap = 0;

(genome_overlap < 0)

(cds_overlap%3 != 0)

(

= 1;

< (

)ai.

().size(); ++

) {

(ai.

()[

-1].m_ssplice && ai.

()[

].m_fsplice) {

(

(ai_rf,intron) &&

(aj_rf,intron) && mrna_count[intron]+est_count[intron]+rnaseq_count[intron] == 0) {

delta_cds = mi.

-cds_overlap;

delta_splice_num = 0;

(delta_cds >= 0) {

(!j_rflexible && !i_lflexible)

= upper_bound(contained.begin(), contained.end(), &mj,

())-contained.begin();

not_sorted =

;

contained.back()->m_accumulated_num = contained.back()->m_align->Weight();

contained.back()->m_accumulated_splice_num = contained.back()->m_splice_weight;

(

= (

)contained.size()-2;

>=

; --

) {

contained[

]->m_accumulated_num = contained[

]->m_align->Weight()+contained[

+1]->m_accumulated_num;

contained[

]->m_accumulated_splice_num = contained[

]->m_splice_weight+contained[

+1]->m_accumulated_splice_num;

delta_num = contained[

]->m_accumulated_num;

delta_splice_num = contained[

]->m_accumulated_splice_num;

(

p : micontained) {

(

= 1;

< (

)ai.

().size(); ++

) {

(ai.

()[

-1].m_ssplice && ai.

()[

].m_fsplice) {

(

(ai_rf,intron) && mrna_count[intron]+est_count[intron]+rnaseq_count[intron] == 0) {

}

(align.TrustedGroup() != 0) {

tgr = align.TrustedGroup();

(tgr == 0 || (tgr > 0 && align.Strand() ==

) || (tgr < 0 && align.Strand() ==

));

right_ends(pointers.size());

(

k = 0; k < (

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

& kalign = *pointers[k]->m_align;

rend = kalign.Limits().GetTo();

rend = kalign.Limits().GetFrom();

right_ends[k] = rend;

LRIinit(mi, micontained);

not_sorted =

;

TIVec::iterator

= lower_bound(right_ends.begin(),right_ends.end(),ai.

().

()-2*flex_len);

TContained::iterator jfirst = pointers.begin();

(

!= right_ends.end())

jfirst = pointers.begin()+(

-right_ends.begin());

(TContained::iterator j = jfirst; j <

; ++j) {

(aj.

().back().m_fsplice_sig ==

|| ai.

().front().m_ssplice_sig ==

)

delta_splice_num;

(LRCanChainItoJ(delta_cds, delta_num, delta_splice_num, mi, mj, micontained, not_sorted)) {

trust_compatible =

;

trust_compatible =

;

trust_compatible =

;

better_connection =

;

better_connection = (newcds > mi.

);

better_connection =

;

(better_connection) {

(trust_compatible) {

strand = ai.

();

(tgr == 0 || (tgr > 0 && strand ==

) || (tgr < 0 && strand ==

));

left_ends(pointers.size());

(

k = 0; k < (

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

& kalign = *pointers[k]->m_align;

lend = kalign.Limits().GetFrom();

lend = kalign.Limits().GetTo();

left_ends[k] = lend;

not_sorted =

;

TIVec::iterator

= lower_bound(left_ends.begin(),left_ends.end(),ai.

().

()+2*flex_len,greater<int>());

TContained::iterator jfirst = pointers.begin();

(

!= left_ends.end())

jfirst = pointers.begin()+(

-left_ends.begin());

(TContained::iterator j = jfirst; j <

; ++j) {

(aj.

().front().m_ssplice_sig ==

|| ai.

().back().m_fsplice_sig ==

)

(mj.

==

&& (!ai_right_complete || (!j_lflexible && (aj.

()&ai_rf).GetLength() > 5)))

(mj.

==

&& (!aj_left_complete || (!i_rflexible && (ai.

()&aj_rf).GetLength() > 5)))

(j_lflexible || i_rflexible)

(intersect < intersect_limit)

;

cds_overlap = 0;

(genome_overlap < 0)

(cds_overlap%3 != 0)

(

= 1;

< (

)ai.

().size(); ++

) {

(ai.

()[

-1].m_ssplice && ai.

()[

].m_fsplice) {

(

(ai_rf,intron) &&

(aj_rf,intron) && mrna_count[intron]+est_count[intron]+rnaseq_count[intron] == 0) {

delta_cds = mi.

-cds_overlap;

(!j_lflexible && !i_rflexible)

= upper_bound(micontained.begin(),micontained.end(),&mj,

())-micontained.begin();

not_sorted =

;

micontained.back()->m_accumulated_num = micontained.back()->m_align->Weight();

micontained.back()->m_accumulated_splice_num = micontained.back()->m_splice_weight;

(

= (

)micontained.size()-2;

>=

; --

) {

micontained[

]->m_accumulated_num = micontained[

]->m_align->Weight()+micontained[

+1]->m_accumulated_num;

micontained[

]->m_accumulated_splice_num = micontained[

]->m_splice_weight+micontained[

+1]->m_accumulated_splice_num;

delta_num = micontained[

]->m_accumulated_num;

delta_splice_num = micontained[

]->m_accumulated_splice_num;

trust_compatible =

;

trust_compatible =

;

trust_compatible =

;

better_connection =

;

better_connection =

;

(better_connection) {

(trust_compatible) {

strand = ai.

();

(tgr == 0 || (tgr > 0 && strand ==

) || (tgr < 0 && strand ==

));

vector<const SChainMember*> mal;

mal.push_back(left);

mal.push_back(right);

note = to_string(mi.

->

());

(vector<const SChainMember*>, imal, mal) {

((*imal)->m_excluded_readthrough)

note = note+

+star+to_string((*imal)->m_align->ID());

map<TSignedSeqRange,int>& mrna_count, map<TSignedSeqRange,int>& est_count, map<TSignedSeqRange,int>& rnaseq_count) {

(

= 1;

< (

)chain.

().size() && good; ++

) {

(chain.

()[

-1].m_ssplice && chain.

()[

].m_fsplice) {

map<TSignedSeqRange,int>& mrna_count, map<TSignedSeqRange,int>& est_count, map<TSignedSeqRange,int>& rnaseq_count) {

(*i)->m_marked_for_deletion = !

(*(*i)->m_align, minscor, mrna_count, est_count, rnaseq_count);

(

.Limits() !=

.Limits())

.Limits() <

.Limits();

aflex < bflex;

*orig_aligns[

.ID()]->GetTargetId() < *orig_aligns[

.ID()]->GetTargetId();

map<tuple<int, int>, TGeneModelList::iterator> special_aligns;

(TGeneModelList::iterator it = clust.begin(); it != clust.end(); ++it) {

special_aligns.emplace(make_tuple(status, it->Limits().GetTo()), it);

special_aligns.emplace(make_tuple(status, it->Limits().GetFrom()), it);

(TGeneModelList::iterator it = clust.begin(); it != clust.end(); ++it) {

(it->Strand() ==

) {

pos = it->Limits().GetFrom();

pos = it->Limits().GetTo();

galign.

() |= status;

clust.push_front(galign);

rslt = special_aligns.emplace(make_tuple(status, pos), clust.begin());

ialign = rslt.first->second;

ialign->SetWeight(ialign->Weight()+galign.

());

(it->Strand() ==

) {

pos = it->Limits().GetFrom();

pos = it->Limits().GetTo();

galign.

() |= status;

clust.push_front(galign);

rslt = special_aligns.emplace(make_tuple(status, pos), clust.begin());

ialign = rslt.first->second;

ialign->SetWeight(ialign->Weight()+galign.

());

(

& sa : special_aligns) {

ialign = sa.second;

min_pos_weight = ((ialign->Status()&

) ? min_cap_weight : min_polya_weight);

(ialign->Limits().GetFrom() < 0 || ialign->Limits().GetTo() >= contig_len || ialign->Weight() < min_pos_weight)

clust.erase(ialign);

confirmed_ends.clear();

all_frameshifts.clear();

(use_confirmed_ends) {

rslt = confirmed_ends.emplace(align.

().front().GetTo(), align.

().front().GetFrom());

rslt.first->second =

(rslt.first->second, align.

().front().GetFrom());

rslt = confirmed_ends.emplace(align.

().back().GetFrom(), align.

().back().GetTo());

rslt.first->second =

(rslt.first->second, align.

().back().GetTo());

all_frameshifts.insert(all_frameshifts.end(), align.

().begin(), align.

().end());

(

= 1;

< (

)align.

().size(); ++

) {

(align.

()[

-1].m_ssplice && align.

()[

].m_fsplice) {

oriented_introns_plus.insert(intron);

oriented_introns_minus.insert(intron);

mrna_count[intron] += align.

();

est_count[intron] += align.

();

rnaseq_count[intron] += align.

();

has_rnaseq = !rnaseq_count.empty();

(all_frameshifts.begin(),all_frameshifts.end());

(!all_frameshifts.empty())

(all_frameshifts);

(

= 1;

< (

)align.

().size(); ++

) {

(align.

()[

-1].m_ssplice && align.

()[

].m_fsplice) {

(oriented_introns_plus.find(intron) != oriented_introns_plus.end())

(oriented_introns_minus.find(intron) != oriented_introns_minus.end())

(pluses > 0 && minuses == 0) {

}

(minuses > 0 && pluses == 0) {

CreateFlexibleAligns(clust);

align.SetTrustedCds(align.TrustedCds()&align.Limits());

allpointers(clust, orig_aligns, unmodified_aligns);

DuplicateNotOriented(allpointers, clust);

ReplicatePStops(allpointers);

ScoreCdnas(allpointers);

Duplicate5pendsAndShortCDSes(allpointers);

DuplicateUTRs(allpointers);

CalculateSpliceWeights(allpointers);

FindOverlappingWithTrusted(allpointers);

FindContainedAlignments(allpointers);

((*ip)->m_orig_align);

(!(*ip)->m_not_for_chaining)

pointers.push_back(*

);

coding_pointers.push_back(*

);

LeftRight(coding_pointers);

RightLeft(coding_pointers);

array<map<TSignedSeqPos,TSignedSeqRange>, 2> coding_right_splices;

array<map<TSignedSeqPos,TSignedSeqRange>, 2> coding_left_splices;

array<set<TSignedSeqRange>, 2> coding_introns;

chain(mi,

);

->GetScore(chain,

,

,

);

(cdslen < minscor.m_minlen || (chain.

() < 2*minscor.m_min && cdslen < 2*minscor.m_cds_len)))

(

= 1;

< (

)chain.

().size(); ++

) {

coding_donor =

(real_cds, donor);

coding_acceptor =

(real_cds, acceptor);

coding_right_splices[chain.

()][donor].CombineWith(real_cds);

(coding_acceptor)

coding_left_splices[chain.

()][acceptor].CombineWith(real_cds);

(coding_donor && coding_acceptor)

coding_introns[chain.

()].emplace(donor, acceptor);

(

: pointers) {

strand =

->m_align->Strand();

& crs = coding_right_splices[strand];

& cls = coding_left_splices[strand];

(

= 1;

< (

)

->m_align->Exons().size(); ++

) {

rslt = crs.find(rsplice);

->m_marked_for_deletion =

;

rslt = cls.find(lsplice);

->m_marked_for_deletion =

;

(!

->m_marked_for_deletion) {

& cdi = coding_introns[strand];

(

& exon :

->m_align->Exons()) {

(

(cds, exon.Limits()))

(

intronp = cdi.upper_bound(exon.Limits()); intronp != cdi.end() && intronp->GetFrom() < exon.GetTo(); ++intronp) {

(

(exon.Limits(), *intronp) && !

(cds, *intronp)) {

->m_marked_for_deletion =

;

(

->m_marked_for_deletion)

set<TSignedSeqRange> introns;

set<TSignedSeqRange> est_introns;

(

p : pointers) {

(

= 1;

< exons.size(); ++

) {

(!exons[

-1].m_ssplice || !exons[

].m_fsplice)

introns.emplace(exons[

-1].GetTo(), exons[

].GetFrom());

est_introns.emplace(exons[

-1].GetTo(), exons[

].GetFrom());

enough_est = !introns.empty() && est_introns.size() > longreadsthreshold/100*introns.size();

cerr <<

<< introns.size() <<

<< est_introns.size() <<

<< enough_est << endl;

old_oep = intersect_limit;

intersect_limit = 10000;

if(p->m_align->Status()&(CGeneModel::eLeftFlexible|CGeneModel::eRightFlexible))

if(p->m_align->Exons().size() != 1 || p->m_type == eCDS)

if(p->m_copy != nullptr) {

for(SChainMember* cp : *p->m_copy) {

if(cp->m_cds_info->MaxCdsLimits() == TSignedSeqRange::GetWhole())

; }), pointers.end());

LeftRight(pointers);

RightLeft(pointers);

chain(mi,

);

RemovePoorCds(chain, GoodCDNAScore(chain,

));

chain.

(min_cap_blob, max_dist, min_flank_exon, secondary_peak,

);

chain.

(contig, min_polya_blob, max_dist, min_flank_exon, secondary_peak, tertiary_peak, tertiary_peak_coverage,

);

->GetScore(chain, !no5pextension);

RemovePoorCds(chain, GoodCDNAScore(chain));

tmp_chains.push_back(chain);

CreateChainsForPartialProteins(tmp_chains, pointers, unma_aligns, unma_members);

(

: allpointers) {

(mi.

!=

) {

(

j : *mi.

) {

(

jc : *j->m_contained) {

pointers.erase(

(pointers.begin(),pointers.end(),[](

* p){ return p->m_type == eRightUTR; }), pointers.end());

return p->m_align->Exons().size() == 1 && !(p->m_align->Status()&(CGeneModel::eLeftFlexible|CGeneModel::eRightFlexible)); }), pointers.end());

array<set<TSignedSeqRange>, 2> non_coding_introns;

(

p : pointers) {

(

= 1;

< exons.size(); ++

) {

non_coding_introns[p->

->

()].insert(intron);

(

p : pointers) {

& ncdi = non_coding_introns[strand];

(

intronp = ncdi.upper_bound(exon.Limits()); intronp != ncdi.end() && intronp->GetFrom() < exon.GetTo(); ++intronp) {

(

(exon.Limits(), *intronp)) {

LeftRight(pointers);

RightLeft(pointers);

chain(mi,

);

chain.

(min_cap_blob, max_dist, min_flank_exon, secondary_peak,

);

chain.

(contig, min_polya_blob, max_dist, min_flank_exon, secondary_peak, tertiary_peak, tertiary_peak_coverage,

);

tmp_chains.push_back(chain);

chain.

(m_idnext);

m_idnext += m_idinc;

CombineCompatibleChains(tmp_chains);

SetFlagsForChains(tmp_chains);

intersect_limit = old_oep;

list<CGene> genes = FindGenes(tmp_chains);

(genes.size() > 1) {

TrimAlignmentsIncludedInDifferentGenes(genes);

CombineCompatibleChains(tmp_chains);

SetFlagsForChains(tmp_chains);

(genes.size() > 1)

FindGenes(tmp_chains);

it->RestoreTrimmedEnds(trim);

chains.push_back(*it);

{ eFirstPeak = 1, eSecondPeak = 2, eThirdPeak = 4, eAs = 8};

map<tuple<int, int, int>,

> cap_polya_info;

(

& chain : tmp_chains) {

(

&

: cap_polya_info) {

strand = get<1>(

.first) ==

?

:

;

cerr <<

<<

<< determinant <<

<< strand <<

<< pos <<

;

(

.second&eFirstPeak)

cerr <<

;

(

.second&eSecondPeak)

cerr <<

;

(

.second&eThirdPeak)

cerr <<

;

(

.second&eAs)

ap->

() < bp->

();

right_ends(pointers.size());

vector<SChainMember> no_gap_members(pointers.size());

(

k = 0; k < (

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

no_gap_members[k] = mi;

first_member = (

)pointers.size()-1;

(

= (

)pointers.size()-1;

>= 0; --

) {

(limi.

() >= leftpos) {

last_member = 0;

(

= 0;

< (

)pointers.size(); ++

) {

(

(limi,rightpos)) {

rightpos =

(rightpos,limi.

());

fully_connected_right = 0;

(

= first_member;

<= last_member; ++

) {

LRIinit(mi, micontained);

part_to_connect = (

)parts.size()-1;

(part_to_connect >= 0 && ai.

().

() <= parts[part_to_connect]->Limits().GetFrom())

(fully_connected_right > 0 && ai.

().

() > fully_connected_right)

not_sorted =

;

compatible_with_included_parts =

;

last_included_part = -1;

includes_first_part =

;

(

p = part_to_connect+1; p < (

)parts.size(); ++p) {

samestop = (parts[p]->GetCdsInfo().HasStop() == mi.

->

() && (!parts[p]->GetCdsInfo().HasStop() || parts[p]->GetCdsInfo().Stop() == mi.

->

()));

(compatible && samestop && samefshifts) {

last_included_part = p;

includes_first_part =

;

compatible_with_included_parts =

;

compatible_with_included_parts =

;

(!compatible_with_included_parts)

(part_to_connect < 0 || part_to_connect == (

)parts.size()-1 || mi.

==

);

(includes_first_part) {

TIVec::iterator

= lower_bound(right_ends.begin(),right_ends.end(),(part_to_connect >= 0 ? parts[part_to_connect]->Limits().GetTo() : ai.

().

()));

(

!= right_ends.end())

jfirst = (

)(

-right_ends.begin());

(

j = jfirst; j <

; ++j) {

(better_connection) {

(trust_compatible) {

delta_splice_num;

(LRCanChainItoJ(delta_cds, delta_num, delta_splice_num, mi, mj, micontained, not_sorted)) {

trust_compatible =

;

trust_compatible =

;

trust_compatible =

;

better_connection =

;

better_connection =

;

better_connection = (newcds > mi.

);

better_connection =

;

(better_connection) {

(trust_compatible) {

better_connection =

;

better_connection =

;

}

(newcds != mi_no_gap.

) {

better_connection = (newcds > mi_no_gap.

);

}

(newnum > mi_no_gap.

) {

better_connection =

;

(better_connection) {

(trust_compatible) {

(best_right ==

)

(std::less<SChainMember*>()(best_right, &no_gap_members.front()) || std::less<SChainMember*>()(&no_gap_members.back(), best_right));

(!std::less<SChainMember*>()(mp->m_left_member, &no_gap_members.front()) && !std::less<SChainMember*>()(&no_gap_members.back(), mp->m_left_member)) {

* p = pointers[mp->m_left_member-&no_gap_members.front()];

(

vector<CGeneModel*>* ap,

vector<CGeneModel*>* bp)

vector<CGeneModel*>& partsa = *ap;

vector<CGeneModel*>& partsb = *bp;

(vector<CGeneModel*>, k, partsa)

align_lena += (*k)->AlignLen();

(vector<CGeneModel*>, k, partsb)

align_lenb += (*k)->AlignLen();

(align_lena != align_lenb) {

align_lena > align_lenb;

*orig_aligns[partsa.front()->ID()]->GetTargetId() < *orig_aligns[partsb.front()->ID()]->GetTargetId();

map<Int8, vector<CGeneModel*> > TIdChainMembermap;

TIdChainMembermap protein_parts;

(

k = 0; k < (

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

vector<vector<CGeneModel*>*> gapped_sorted_protein_parts;

vector<CGeneModel*>& parts =

->second;

(parts.size() > 1) {

gapped_sorted_protein_parts.push_back(&parts);

(gapped_sorted_protein_parts.begin(),gapped_sorted_protein_parts.end(),

(orig_aligns));

vector<CGeneModel*>& parts = **

;

= parts.front()->ID();

(vector<CGeneModel*>, k, parts) {

connected =

;

(k->Continuous() && palign.

() == k->Strand() && palign.

(*k)) {

k->AddComment(

+orig_aligns[palign.

()]->TargetAccession());

(

k = 0; k < (

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

compatible =

;

((mip->

->

() !=

&&

(partp->Limits(),

)) || (partp->Limits().IntersectingWith(

) && !partp->HasCompatibleOverlap(*mip->

))) {

compatible =

;

pointers.push_back(mip);

* best_right = FindOptimalChainForProtein(pointers, parts, palign);

(best_right ==

)

chain(*best_right,

);

(unmodified_aligns.count(

)) {

vector<TSignedSeqRange> new_holes;

vector<TSignedSeqRange> remaining_holes;

(

k = 1; k < (

)chain.

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

remaining_holes.push_back(h);

(

piece_begin = 0; piece_begin < (

)unma.

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

piece_end = piece_begin;

( ; piece_end < (

)unma.

().size() && unma.

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

(unma.

()[piece_begin].GetFrom() < h.

() && unma.

()[piece_end].GetTo() > h.

()) {

new_holes.push_back(h);

piece_begin = piece_end;

(!new_holes.empty()) {

vector<TSignedSeqRange> existed_holes;

(

k = 1; k < (

)unma.

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

(

k = 1; k < (

)palign.

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

connected =

;

(vector<TSignedSeqRange>, h, remaining_holes) {

existed =

;

(vector<TSignedSeqRange>, h, existed_holes) {

(connected || existed) {

unmacl.push_back(unma);

vector<CGeneModel*> unmaparts;

unmaparts.push_back(&(*im));

unmapointers(unmacl, orig_aligns, unmodified_aligns);

Duplicate5pendsAndShortCDSes(unmapointers);

IncludeInContained(mi, mi);

(CanIncludeJinI(mi, mj))

IncludeInContained(mi, mj);

((*ip)->m_orig_align);

(*ip)->m_mem_id = -(*ip)->m_mem_id;

pointers.push_back(*

);

best_right = FindOptimalChainForProtein(pointers, unmaparts, unma);

present =

;

present =

== &mj;

(CanIncludeJinI(mi, mj)) {

IncludeInContained(mi, mj);

chain =

(*best_right,

);

unma_aligns.splice(unma_aligns.end(), unmacl);

chain.

(min_cap_blob, max_dist, min_flank_exon, secondary_peak,

);

chain.

(contig, min_polya_blob, max_dist, min_flank_exon, secondary_peak, tertiary_peak, tertiary_peak_coverage,

);

->GetScore(chain, !no5pextension);

chain.

(

+orig_aligns[palign.

()]->TargetAccession());

chains.push_back(chain);

= right-left+1;

vector<int> prot_cov[2][3];

prot_cov[0][0].resize(

,0);

prot_cov[0][1].resize(

,0);

prot_cov[0][2].resize(

,0);

prot_cov[1][0].resize(

,0);

prot_cov[1][1].resize(

,0);

prot_cov[1][2].resize(

,0);

(

= 0;

< (

)align.

().size(); ++

) {

(

j = rf.

(); j <= rf.

(); ++j) {

++prot_cov[align.

()][

(cdstr-jtr)%3][j-left];

allcdnaintrons =

;

(

= 1;

< (

)chain.

().size() && allcdnaintrons; ++

) {

(chain.

()[

-1].m_ssplice_sig !=

&& chain.

()[

].m_fsplice_sig !=

) {

allcdnaintrons = (mrna_count[intron]+est_count[intron]+rnaseq_count[intron] > 0);

(allcdnaintrons && num >0)

rrf_from_proteins = 0;

(

= 0;

< (

)chain.

().size(); ++

) {

(

j = rf.

(); j <= rf.

(); ++j) {

(j < left || j > right)

frame =

(cdstr-jtr)%3;

(jtr >= 0 && prot_cov[chain.

()][frame][j-left] > 0) {

lrf_from_proteins =

(lrf_from_proteins,j);

rrf_from_proteins =

(rrf_from_proteins,j);

(TChainList::iterator itt = chains.begin(); itt != chains.end(); ++itt) {

(TChainList::iterator jt = chains.begin(); jt != chains.end();) {

TChainList::iterator jtt = jt++;

(itt != jtt && itt->Strand() == jtt->Strand() && jtt->IsSubAlignOf(*itt) && itt->ReadingFrame().Empty() == jtt->ReadingFrame().Empty()) {

(itt->ReadingFrame().NotEmpty()) {

same_frame = (itt->FShiftedLen(

,

,

)-1)%3 == 0;

(!

(jtt->MaxCdsLimits(), itt->MaxCdsLimits()))

same_stops =

;

(

(jtt->Limits(),*istp) && find(jstops.begin(), jstops.end(), *istp) == jstops.end()) {

same_stops =

;

support.insert(*

);

((*i)->m_copy != 0)

support.insert((*i)->m_copy->begin(),(*i)->m_copy->end());

(support.insert(*i).second && (

(jlimits, il) || itt->HasCompatibleOverlap(*(*i)->m_align, 1))) {

itt->m_was_combined =

;

itt->m_members.push_back(*

);

((*i)->m_copy != 0)

support.insert((*i)->m_copy->begin(),(*i)->m_copy->end());

(itt->m_was_combined) {

itt->CalculateSupportAndWeightFromMembers();

jtt->AddComment(

+to_string(itt->ID()));

minscor.m_min;

(algn.

() < minscor)

vector<double> coverage_raw(mrna_len+

);

m_coverage.resize(mrna_len);

(

= 0;

< mrna_len; ++

) {

m_coverage[

] = cov;

(

& mbr,

full_support) : m_coverage_drop_left(-1), m_coverage_drop_right(-1), m_coverage_bump_left(-1), m_coverage_bump_right(-1), m_core_coverage(0), m_splice_weight(0), m_cap_peaks(3, -1), m_polya_peaks(3, -1), m_was_combined(

) {

num = other_exons.size();

= other_exons.front().GetTo() >= exons.back().GetTo() ? 0 : 1;

= std::lower_bound(other_exons.begin(), other_exons.end(), exons.back().GetTo(), [](

& e,

) { return e.GetTo() < a; })-other_exons.begin();

exons.back().Extend(other_exons[

]);

exons.insert(exons.end(), other_exons.begin()+

+1, other_exons.end());

num = other_exons.size();

(other_exons.back().GetTo() < exons.front().GetFrom()) {

exons.insert(exons.begin(), other_exons.begin(), other_exons.end());

exons[num].m_fsplice =

;

exons[num].m_fsplice_sig.clear();

exons[num-1].m_ssplice =

;

exons[num-1].m_ssplice_sig.clear();

(cds.

() > exons[num].GetFrom())

exons[num].Limits().SetFrom(cds.

());

(other_cds.

() < exons[num-1].GetTo())

exons[num-1].Limits().SetTo(other_cds.

());

= other_exons.back().GetFrom() <= exons.front().GetFrom() ? 1 : 0;

= std::lower_bound(other_exons.begin(), other_exons.end(), exons.front().GetFrom(), [](

& e,

) { return e.GetTo() < a; })-other_exons.begin();

exons.front().Limits().SetFrom(other_exons[

].GetFrom());

(other_exons[

].m_fsplice) {

exons.front().m_fsplice =

;

exons.front().m_fsplice_sig = other_exons[

].m_fsplice_sig;

exons.insert(exons.begin(), other_exons.begin(), other_exons.begin()+

);

.assign(exons.begin(), exons.end());

.front().m_fsplice =

;

.front().m_fsplice_sig.clear();

.back().m_ssplice =

;

.back().m_ssplice_sig.clear();

(

& mbr,

* gapped_helper,

keep_all_evidence,

addallsupport) : m_coverage_drop_left(-1), m_coverage_drop_right(-1), m_coverage_bump_left(-1), m_coverage_bump_right(-1), m_core_coverage(0), m_splice_weight(0), m_cap_peaks(3, -1), m_polya_peaks(3, -1), m_was_combined(

)

list<CGeneModel> extened_parts;

vector<CGeneModel*> extened_parts_and_gapped;

(gapped_helper != 0) {

extened_parts_and_gapped.push_back(gapped_helper);

extened_parts.push_back(align);

(extened_parts.back().Continuous());

extened_parts_and_gapped.push_back(&extened_parts.back());

extened_parts.back().Extend(align,

);

(extened_parts.back().Continuous());

(left < extened_parts.front().Limits().GetFrom())

extened_parts.front().ExtendLeft(extened_parts.front().Limits().GetFrom()-left);

(right > extened_parts.back().Limits().GetTo())

extened_parts.back().ExtendRight(right-extened_parts.back().Limits().GetTo());

strand = extened_parts_and_gapped.front()->Strand();

(extened_parts_and_gapped.begin(),extened_parts_and_gapped.end(),

());

(vector<CGeneModel*>, it, extened_parts_and_gapped) {

vector<double> coverage_raw(mrna_len+

);

(

= 0;

< mrna_len; ++

) {

(!align->

().empty() || (!align->

().empty() && (*i)->m_cds_info->ProtReadingFrame().NotEmpty())) {

(align->

() > 0.5*(*i)->m_orig_align->TargetLen())

map<Int8,int> exonnum;

exonnum[align.

()] += align.

().size();

(it->second >= (

)orig_aligns[it->first]->Exons().size()) {

(

new_count,

new_not_wanted_count,

new_matches_count,

new_mem_id)

{

new_mem_id < mem_id;

amem_id =

.m_member !=

?

.m_member->m_mem_id : 0;

amem_id < mem_id;

(ai->

() > 0.)

matches = ai->

()*matches+0.5;

not_wanted =

;

alimits.

(

(alimits.

(), exonp->Limits().GetTo()));

linkers.push_back(sl);

set<TSignedSeqRange> chain_introns;

(

= 1;

< (

)

().size(); ++

) {

(

()[

-1].m_ssplice &&

()[

].m_fsplice)

(

& sl : linkers) {

all_introns_included =

;

(

= 1; all_introns_included &&

< (

)unma.

().size(); ++

) {

(unma.

()[

-1].m_ssplice && unma.

()[

].m_fsplice)

(!all_introns_included) {

sl.m_not_wanted =

;

sl.m_not_wanted =

;

all_introns_included =

;

(

= 1; all_introns_included &&

< (

)orig_align.

().size(); ++

) {

(orig_align.

()[

-1].m_ssplice && orig_align.

()[

].m_fsplice)

all_introns_included = chain_introns.count(

(orig_align.

()[

-1].GetTo(),orig_align.

()[

].GetFrom()));

(!all_introns_included) {

sl.m_not_wanted =

;

linkers.push_back(sl);

(

= 1;

< (

)

().size(); ++

) {

(!

()[

-1].m_ssplice || !

()[

].m_fsplice) {

linkers.push_back(sl);

multimap<TSignedSeqPos, SLinker*> right_ends;

(

& linker : linkers)

right_ends.emplace(linker.m_range.GetTo(), &linker);

(

it = right_ends.begin(); it != right_ends.end(); ++it) {

}

(it != right_ends.begin()) {

divided_pstop =

;

new_not_wanted_count += sli.

;

(!sli.

|| sli.

(new_count, new_not_wanted_count, new_matches_count, new_mem_id)) {

(jt == right_ends.begin())

(

= 0;

< (

)linkers.size(); ++

) {

(

*

= best_right;

!= 0;

=

->m_left) {

sp_core.

(

->m_member->m_align->ID());

(!keep_all_evidence) {

(

= 0;

< (

)linkers.size(); ++

) {

(!sp_not_wanted.count(

)) {

(sp.

(

).second) {

protreadingframe &= readingframe;

(

ia = 0; ia < (

)

.size(); ++ia) {

.Exons().size() > 1 &&

().front().Limits().GetFrom() ==

.Limits().GetFrom()) {

(

ia = 0; ia < (

)

.size(); ++ia) {

.Exons().size() > 1 &&

().back().Limits().GetTo() ==

.Limits().GetTo()) {

found_length_match =

;

map<string, pair<bool,bool> >::iterator iter = prot_complet.find(accession);

(iter != prot_complet.end());

(iter == prot_complet.end() || !iter->second.first || !iter->second.second)

found_length_match =

;

(!found_length_match) {

trusted =

;

(

< 0 ||

< 0 ||

(

-

) != 2)

list<TSignedSeqRange> align_introns;

(

= 1;

< (

)align.

().size(); ++

) {

align_introns.push_back(intron);

list<TSignedSeqRange> introns;

(

= 1;

< (

)

().size(); ++

) {

(

(start,intron)) {

introns.push_back(intron);

(!

()[

-1].m_ssplice || !

()[

].m_fsplice)

(

!=3 || hole || align_introns != introns)

found =

;

(

= 0;

< (

)

().size() && !found; ++

) {

(

()[

].Limits().GetTo() > start.

()) {

rf = start.

()+1;

}

(

!= (

)

().size()-1) {

rf =

()[

+1].Limits().GetFrom();

found =

;

(

= 0;

< (

)

().size() && !found; ++

) {

(

()[

].Limits().GetFrom() < start.

()) {

}

(

!= 0) {

rf =

()[

-1].Limits().GetTo();

(conf_start.

()) {

reading_frame.

(rf);

cds.

(stop,confirmed_stop);

(

(reading_frame, *s))

(

= 1;

< (

)

().size(); ++

) {

(!

()[

-1].m_ssplice || !

()[

].m_fsplice) {

(

(hole,reading_frame)) {

}

(

(reading_frame,hole)) {

(new_lim !=

())

gnomon.

(*

,

, trusted);

ai = (*it)->m_align;

(

.IntersectingWith(alimits))

new_members.push_back(*it);

(limits_on_mrna.

() > 0)

changed =

;

(cds.

()) {

(

& pstop : cds.

()) {

pstops.push_back(pstop);

(pstops.size() != cds.

().size()) {

(

& pstop : pstops)

(recalulate_support)

old_limits =

();

new_limits = old_limits;

left_confirmed =

;

right_confirmed =

;

(rslt != confirmed_ends.

() && rslt->second <

().

().GetTo()) {

left_confirmed =

;

new_limits.SetFrom(rslt->second);

rslt = confirmed_ends.

(

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

(rslt != confirmed_ends.

() && rslt->second >

().back().GetFrom()) {

right_confirmed =

;

new_limits.SetTo(rslt->second);

(!left_confirmed && !right_confirmed)

(new_limits.GetFrom() < old_limits.GetFrom()) {

= old_limits.GetFrom()-new_limits.GetFrom();

(new_limits.GetTo() > old_limits.GetTo()) {

= new_limits.GetTo()-old_limits.GetTo();

(

->Loc() > new_limits.GetFrom() &&

->InDelEnd() < new_limits.GetTo())

(

() != new_limits)

(left_confirmed) {

(new_limits.GetFrom() < old_limits.GetFrom())

(new_limits.GetFrom() > old_limits.GetFrom())

(right_confirmed) {

(new_limits.GetTo() > old_limits.GetTo())

(

);

(new_limits.GetTo() < old_limits.GetTo())

(!

(new_limits, cds_info.

()) || (left_confirmed && !left_complete) || (right_confirmed && !right_complete)) {

(

= cds_limits_t.GetFrom();

<= cds_limits_t.GetTo(); ++

) {

(

= cds_limits_t.GetTo();

>= cds_limits_t.GetFrom(); --

) {

cds_limits_t.SetTo(

);

(cds_limits_t.Empty())

cds_info_t.Clip(cds_limits_t);

fivep_confirmed = (

() ==

) ? left_confirmed : right_confirmed;

threep_confirmed = (

() ==

) ? right_confirmed : left_confirmed;

has_start = cds_info_t.HasStart();

has_stop = cds_info_t.HasStop();

prot_rf = cds_info_t.ProtReadingFrame();

(prot_rf.NotEmpty() && ((fivep_confirmed && !has_start) || (threep_confirmed && !has_stop))) {

IndelInCodon = [

](

,

& map) {

= map.MapEditedToOrig(

);

= map.MapEditedToOrig(

+2);

(

< 0 ||

< 0 || map.MapEditedToOrig(

+1) < 0 || !

(

,

,

).empty());

(fivep_confirmed && !has_start) {

(

= prot_rf.GetFrom(); !has_start &&

>= cds_limits_t.GetFrom() && !

(&mrna[

]);

-= 3) {

has_start =

(&mrna[

]) && !IndelInCodon(

, amap);

(

= prot_rf.GetFrom(); !has_start &&

< cds_limits_t.GetTo();

+= 3) {

has_start =

(&mrna[

]) && !IndelInCodon(

, amap);

cds_limits_t.SetFrom(

);

(threep_confirmed && !has_stop) {

(

= prot_rf.GetTo()+1; !has_stop &&

< cds_limits_t.GetTo();

+= 3)

has_stop =

(&mrna[

]) && !IndelInCodon(

, amap);

(!has_stop && cds_info_t.PStop(

)) {

(pstops.begin(), pstops.end());

(

& stp : pstops) {

cds_limits_t.SetTo(stp.GetFrom()-1);

(cds_limits_t.Empty())

cds_info_t.Clip(cds_limits_t);

cds = cds_info.

();

motif1 =

;

motif2 =

;

motif3 =

;

block_of_As_len = 6;

block_of_As.assign(block_of_As_len,

);

block_of_As.assign(block_of_As_len,

);

=

(0, pos-block_of_As_len);

=

((

)contig.size()-1, pos+block_of_As_len);

(

-

+1 < block_of_As_len)

make_pair(

,

);

(search(contig.begin()+

, contig.begin()+

+1, block_of_As.begin(), block_of_As.end()) != contig.begin()+

+1) {

(left < 0 || right >= (

)contig.size())

make_pair(

,

);

segment(contig.begin()+left, contig.begin()+right+1);

(segment.find(motif1) != string::npos || segment.find(motif2) != string::npos || segment.find(motif3) != string::npos)

make_pair(

,

);

make_pair(

,

);

make_pair(

,

);

(align.

()&determinant) {

belong_to_exon =

;

(

& exon :

()) {

(pos >= exon.Limits().GetFrom()+min_splice_dist && pos <= exon.Limits().GetTo()) {

belong_to_exon =

;

(rlimit < pos && belong_to_exon)

belong_to_exon =

;

(

& exon :

()) {

(pos >= exon.Limits().GetFrom() && pos <= exon.Limits().GetTo()-min_splice_dist) {

belong_to_exon =

;

(llimit > pos && belong_to_exon)

(raw_weights.

())

make_tuple(peak_weights,real_limits);

last_allowed = right_end ? real_limits.

()+flex_len : -(real_limits.

()-flex_len);

ipeak = raw_weights.

();

w = ipeak->second;

(

it =

(raw_weights.

()); it != raw_weights.

(); ++it) {

(it->first >

(it)->first+1+max_empty_dist) {

(ipeak->first > last_allowed)

(w >= min_blob_weight) {

still_good = ipeak;

(

= ipeak;

!= it &&

->first <= last_allowed; ++

) {

(

->second >= 0.5*ipeak->second)

peak_weights.emplace(still_good->first, w);

(it->second > ipeak->second)

(ipeak->first <= last_allowed && w >= min_blob_weight) {

still_good = ipeak;

(

= ipeak;

!= raw_weights.

() &&

->first <= last_allowed; ++

) {

(

->second >= 0.5*ipeak->second)

peak_weights.emplace(still_good->first, w);

make_tuple(peak_weights,real_limits);

tuple<TIVec, TSignedSeqRange>

(

& peak_weights,

secondary_peak,

tertiary_peak,

tertiary_peak_coverage,

right_end) {

peaks[0] =

(ifirst_peak->first);

first_peak = ifirst_peak->first;

.SetTo(first_peak);

first_peak = -ifirst_peak->first;

.SetFrom(first_peak);

isecond_peak =

(peak_weights.

());

( ; isecond_peak != ifirst_peak && isecond_peak->second < secondary_peak*ifirst_peak->second; --isecond_peak);

(isecond_peak != ifirst_peak)

peaks[1] =

(isecond_peak->first);

(tertiary_peak > 0) {

(genome_core_lim.

()) {

genome_core_lim =

();

core_coverage = 0;

core_coverage /= core_lim.

();

(

& exon :

()) {

(

(exon.Limits(),

(ifirst_peak->first))) {

fpeak_exon = exon.Limits();

ithird_peak =

(peak_weights.

());

( ; ithird_peak != isecond_peak; --ithird_peak) {

(

(fpeak_exon,

(ithird_peak->first))) {

(ithird_peak->second >= tertiary_peak*ifirst_peak->second &&

[p] > tertiary_peak_coverage*core_coverage)

(ithird_peak != isecond_peak)

peaks[2] =

(ithird_peak->first);

isecond_peak = ithird_peak;

(isecond_peak != ifirst_peak) {

second_peak = isecond_peak->first;

.SetTo(second_peak);

second_peak = -isecond_peak->first;

.SetFrom(second_peak);

make_tuple(peaks,

);

(

min_cap_blob,

max_dist,

min_flank_exon,

secondary_peak,

recalulate_support) {

& peak_weights(get<0>(rslt));

(peak_weights.

()) {

(right_end && real_limits.

() <

().GetTo())

(!right_end && real_limits.

() >

().GetFrom())

rslt1 =

(peak_weights, secondary_peak, 0., 0., right_end);

(

& contig,

min_polya_blob,

max_dist,

min_flank_exon,

secondary_peak,

tertiary_peak,

tertiary_peak_coverage,

recalulate_support) {

& peak_weights(get<0>(rslt));

(

ip_loop = peak_weights.

(); ip_loop != peak_weights.

(); ) {

= ip_loop++;

(peak_weights.

()) {

(right_end && real_limits.

() <

().GetTo())

(!right_end && real_limits.

() >

().GetFrom())

rslt1 =

(peak_weights, secondary_peak, tertiary_peak, tertiary_peak_coverage, right_end);

genome_core_lim =

();

((

)coverage.size() == mrna_len && core_lim.

() >= 0 && core_lim.

() < mrna_len);

core_coverage = 0;

core_coverage += coverage[

];

core_coverage /= core_lim.

();

(core_lim.

() <= 0 && core_lim.

() >= mrna_len-1)

vector<double> longseq_coverage(mrna_len);

(overlap.

())

(

= 1;

< (

)align.

().size(); ++

) {

(align.

()[

-1].m_ssplice && align.

()[

].m_fsplice && align.

()[

-1].m_ssplice_sig !=

&& align.

()[

].m_fsplice_sig !=

) {

valid_intron =

;

(

j = 1; j < (

)

().size() && !valid_intron; ++j) {

(

()[j-1].m_ssplice &&

()[j].m_fsplice) {

valid_intron = (intr == jntr);

(

= overlap_on_mrna.

();

<= overlap_on_mrna.

(); ++

)

longseq_coverage[

] += align.

();

longseq_coverage[

] = 0;

longseq_coverage[

] = 0;

core_inron_coverage = 0;

core_introns = 0;