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

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

NCBI C++ ToolKit: src/algo/sequence/transform_align.cpp Source File

pair <ENa_strand, ENa_strand> GetSplicedStrands(

& spliced_seg)

(spliced_seg.

().front()->IsSetProduct_strand() ?

spliced_seg.

().front()->GetProduct_strand() :

(spliced_seg.

().front()->IsSetGenomic_strand()?

spliced_seg.

().front()->GetGenomic_strand():

make_pair(product_strand, genomic_strand);

pair <ENa_strand, ENa_strand> strands = GetSplicedStrands(spliced_seg);

exons.resize(spliced_seg.

().size());

& exon_struct = exons[

++];

cross_the_origin =

> 1 && (

(cross_the_origin && scope) {

GetExonStructure(spliced_seg, exons, m_scope);

pair <ENa_strand, ENa_strand> strands = GetSplicedStrands(spliced_seg);

product_max_pos = spliced_seg.

()-1;

product_max_pos = product_max_pos*3+2;

product_max_pos = exons.back().prod_to;

product_min_pos = product_min_pos*3-2;

product_min_pos = exons[0].prod_from;

CSpliced_seg::TExons::iterator it = spliced_seg.

().begin();

(++it; it != spliced_seg.

().end(); ++

, prev_exon = *it++) {

donor_set = prev_exon->IsSetDonor_after_exon() || (genomic_strand ==

&& prev_exon->GetGenomic_start()==0);

(donor_set && acceptor_set && exons[

-1].prod_to + 1 == exons[

].prod_from) {

( exons[

].prod_from > exons[

-1].prod_to );

prod_hole_len = exons[

].prod_from - exons[

-1].prod_to -1;

( exons[

].genomic_from > exons[

-1].genomic_to );

genomic_hole_len = exons[

].genomic_from - exons[

-1].genomic_to -1;

(((m_intron_stitch_threshold_flags &

) &&

prod_hole_len >= (

)m_min_intron) ||

((m_intron_stitch_threshold_flags &

) &&

genomic_hole_len >= (

)m_min_intron))

(!prev_exon->IsSetParts() || prev_exon->GetParts().empty()) {

part->SetMatch(exons[

-1].prod_to-exons[

-1].prod_from+1);

prev_exon->SetParts().push_back(part);

part->SetMatch(exons[

].prod_to-exons[

].prod_from+1);

max_hole_len =

(prod_hole_len, genomic_hole_len);

min_hole_len =

(prod_hole_len, genomic_hole_len);

left_mismatch_len = 0;

right_mismatch_len = min_hole_len;

(prod_hole_len != genomic_hole_len && mapper_to_cds) {

end_pos(*transcript_id, exons[

-1].prod_to);

end_pos_on_cds = mapper_to_cds->

(end_pos)

bases_needed_to_complete_codon = 2 - (end_pos_on_cds % 3);

(right_mismatch_len >= bases_needed_to_complete_codon) {

left_mismatch_len = bases_needed_to_complete_codon + ((right_mismatch_len-bases_needed_to_complete_codon)/2/3)*3;

right_mismatch_len -= left_mismatch_len;

no_acceptor_before =

> 1 && !prev_exon->IsSetAcceptor_before_exon();

cross_the_origin =

(cross_the_origin) {

genomic_size = m_scope->GetSequenceLength(spliced_seg.

());

prev_exon->SetPartial(product_min_pos < exons[

-1].prod_from &&

exon.

(exons[

].prod_to < product_max_pos &&

prev_exon->SetGenomic_end(genomic_size-1);

prev_exon->SetGenomic_start(0);

to_origin =

- exons[

-1].genomic_to -1;

(prod_hole_len == genomic_hole_len) {

left_mismatch_len = to_origin;

right_mismatch_len -= left_mismatch_len;

(left_mismatch_len > 0 && to_origin > 0) {

mismatch_len =

(left_mismatch_len, to_origin);

part->SetMismatch(mismatch_len);

prev_exon->SetParts().push_back(part);

prod_hole_len -= mismatch_len;

genomic_hole_len -= mismatch_len;

to_origin -= mismatch_len;

exons[

-1].genomic_to += mismatch_len;

exons[

-1].prod_to += mismatch_len;

left_mismatch_len -= mismatch_len;

(left_mismatch_len == 0);

(prod_hole_len != genomic_hole_len);

(prod_hole_len < genomic_hole_len) {

genomic_ins =

(genomic_hole_len-prod_hole_len, to_origin);

part->SetGenomic_ins(genomic_ins);

genomic_hole_len -= genomic_ins;

to_origin -= genomic_ins;

exons[

-1].genomic_to += genomic_ins;

part->SetProduct_ins(prod_hole_len-genomic_hole_len);

exons[

-1].prod_to += prod_hole_len-genomic_hole_len;

prod_hole_len = genomic_hole_len;

prev_exon->SetParts().push_back(part);

(prod_hole_len == genomic_hole_len);

(right_mismatch_len >= to_origin);

mismatch_len = to_origin;

part->SetMismatch(mismatch_len);

prev_exon->SetParts().push_back(part);

prod_hole_len -= mismatch_len;

genomic_hole_len -= mismatch_len;

exons[

-1].genomic_to += mismatch_len;

exons[

-1].prod_to += mismatch_len;

right_mismatch_len -= mismatch_len;

exons[

].prod_from = exons[

-1].prod_to+1;

exons[

].genomic_from = exons[

-1].genomic_to+1;

prev_exon->SetProduct_end().SetProtpos().SetAmin() = exons[

-1].prod_to/3;

prev_exon->SetProduct_end().SetProtpos().SetFrame() = (exons[

-1].prod_to %3) +1;

exon.

().SetProtpos().SetFrame() = (exons[

].prod_from %3) +1;

prev_exon->SetProduct_end().SetNucpos( exons[

-1].prod_to );

prev_exon->SetProduct_start().SetNucpos( -exons[

-1].prod_to );

list <CRef< CSpliced_exon_chunk > >::iterator insertion_point = exon.

().begin();

(left_mismatch_len > 0) {

part->SetMismatch(left_mismatch_len);

insertion_point = exon.

().insert(insertion_point, part);

(prod_hole_len != genomic_hole_len) {

(prod_hole_len < genomic_hole_len) {

part->SetGenomic_ins(genomic_hole_len - prod_hole_len);

part->SetProduct_ins(prod_hole_len - genomic_hole_len);

insertion_point = exon.

().insert(insertion_point, part);

(right_mismatch_len > 0) {

part->SetMismatch(right_mismatch_len);

exon.

().insert(insertion_point, part);

(left_mismatch_len > 0) {

part->SetMismatch(left_mismatch_len);

prev_exon->SetParts().push_back(part);

(prod_hole_len != genomic_hole_len) {

(prod_hole_len < genomic_hole_len) {

part->SetGenomic_ins(max_hole_len - min_hole_len);

part->SetProduct_ins(max_hole_len - min_hole_len);

prev_exon->SetParts().push_back(part);

(right_mismatch_len > 0) {

part->SetMismatch(right_mismatch_len);

prev_exon->SetParts().push_back(part);

prev_exon->SetParts().splice(prev_exon->SetParts().end(), exon.

());

prev_exon->ResetDonor_after_exon();

exons[

].prod_from = exons[

-1].prod_from;

exons[

].genomic_from = exons[

-1].genomic_from;

prev_exon->SetPartial(

(product_min_pos < exons[

-1].prod_from && no_acceptor_before) ||

(exons[

].prod_to < product_max_pos && no_donor_after));

prev_exon->SetExt().splice(prev_exon->SetExt().end(), exon.

());

CSpliced_seg::TExons::iterator save_it = it;

align.

().SetSpliced().SetExons())

(*exon_it)->ResetScores();

align.

().SetSpliced().SetExons())

RecalculateExonIdty(**exon_it);

score_builder.

(*m_scope, align, *score);

((*part_it)->Which()) {

matches += (*part_it)->GetMatch();

total += (*part_it)->GetMatch();

total += (*part_it)->GetMismatch();

total += (*part_it)->GetProduct_ins();

total += (*part_it)->GetGenomic_ins();

(idty >= 0 && (*score_it)->IsSetId() && (*score_it)->GetId().IsStr() &&

(*score_it)->GetId().GetStr() ==

) {

(*score_it)->SetValue().SetReal(idty / 10000000000.);

exon_scores.erase(score_it);

pair <ENa_strand, ENa_strand> strands = GetSplicedStrands(spliced_seg);

);

GetExonStructure(spliced_seg, exons, m_scope);

frame_offset = (exons.back().prod_to/3+1)*3+cds.

();

vector<SExon>::iterator right_exon_it = exons.begin();

CSpliced_seg::TExons::iterator right_spl_exon_it = spliced_seg.

().begin();

(;;++right_exon_it, ++right_spl_exon_it) {

vector<SExon>::reverse_iterator left_exon_it(right_exon_it);

CSpliced_seg::TExons::reverse_iterator left_spl_exon_it(right_spl_exon_it);

(right_exon_it != exons.begin() && right_exon_it != exons.end()) {

donor_set = left_spl_exon_it != spliced_seg.

().rend() && (*left_spl_exon_it)->IsSetDonor_after_exon();

acceptor_set = right_spl_exon_it != spliced_seg.

().end() && (*right_spl_exon_it)->IsSetAcceptor_before_exon();

(((donor_set && acceptor_set) || left_exon_it->genomic_to + 1 == right_exon_it->genomic_from) && left_exon_it->prod_to + 1 == right_exon_it->prod_from) {

(right_exon_it != exons.begin() && (right_exon_it != exons.end() || (m_flags &

))) {

(exons.rend() != left_exon_it &&

cds.

() < left_exon_it->prod_to && left_exon_it->prod_to < cds.

() &&

(left_exon_it->prod_to - cds.

() + 1) % 3 > 0

TrimLeftExon(

(left_exon_it->prod_to - left_exon_it->prod_from + 1,

(left_exon_it->prod_to - cds.

() + 1) % 3),

exons.rend(), left_exon_it, left_spl_exon_it,

product_strand, genomic_strand);

(right_exon_it != exons.end() && (right_exon_it != exons.begin() || (m_flags &

))) {

(right_exon_it != exons.end() &&

cds.

() < right_exon_it->prod_from && right_exon_it->prod_from < cds.

() &&

(frame_offset-right_exon_it->prod_from) % 3 > 0

TrimRightExon(

(right_exon_it->prod_to - right_exon_it->prod_from + 1,

(frame_offset-right_exon_it->prod_from) % 3),

right_exon_it, exons.end(), right_spl_exon_it,

product_strand, genomic_strand);

(left_exon_it.base() != right_exon_it) {

right_exon_it = exons.erase(left_exon_it.base(), right_exon_it);

right_spl_exon_it = spliced_seg.

().erase(left_spl_exon_it.base(), right_spl_exon_it);

(right_exon_it == exons.end())

(right_exon_it == exons.end() && right_spl_exon_it == spliced_seg.

().end());

is_protein_align =

CSpliced_seg::TExons::iterator prev_exon_it = spliced_seg.

().end();

has_parts =

;

(chunk.

()) {

(part_index == 0 && prev_exon_it != spliced_seg.

().end() &&

(*prev_exon_it)->IsSetParts()) {

(prev_len +

>= 3) {

prev_chunk.

(prev_len);

(is_protein_align) {

product_end = (*prev_exon_it)->GetProduct_end().AsSeqPos();

product_end += prev_len;

(*prev_exon_it)->SetProduct_end().SetProtpos().SetAmin (product_end / 3);

(*prev_exon_it)->SetProduct_end().SetProtpos().SetFrame((product_end % 3) + 1);

product_start += prev_len;

(*prev_exon_it)->SetProduct_end().SetNucpos() += prev_len;

(

> 3-prev_len) {

new_chunk->SetDiag(3-prev_len);

exon.

().insert(part_it, new_chunk);

new_chunk->SetDiag(

- (

% 3));

exon.

().insert(part_it, new_chunk);

prev_exon_it = exon_it;

(is_protein_align) {

->GetProduct_start().GetProtpos().GetFrame() - 1;

->GetProduct_start().GetNucpos() % 3;

(

& exon_it : spliced_seg.

()) {

(is_protein_align) {

exon_it->SetProduct_start().SetProtpos().SetAmin(product_pos / 3);

exon_it->SetProduct_start().SetProtpos().SetFrame(product_pos % 3 + 1);

exon_it->SetProduct_start().SetNucpos(product_pos);

(

& part : exon_it->GetParts()) {

(part->Which()) {

product_pos += part->GetMatch();

product_pos += part->GetMismatch();

product_pos += part->GetDiag();

product_pos += part->GetProduct_ins();

);

(is_protein_align) {

exon_it->SetProduct_end().SetProtpos().SetAmin ((product_pos - 1) / 3);

exon_it->SetProduct_end().SetProtpos().SetFrame((product_pos - 1) % 3 + 1);

exon_it->SetProduct_end().SetNucpos(product_pos - 1);

? (*prev_exon_it)->GetProduct_end().GetProtpos().GetAmin()+1

: (*prev_exon_it)->GetProduct_end().GetNucpos()+1;

->AdjustAlignment(align_in, range,

);

align->

(align_in);

vector<SExon> orig_exons = GetExons(*align);

pair <ENa_strand, ENa_strand> strands = GetSplicedStrands(spliced_seg);

);

spliced_seg.

().back()->GetGenomic_end());

spliced_seg.

().front()->GetGenomic_end());

cross_the_origin = range.

() > range.

();

( !cross_the_origin ) {

it = spliced_seg.

().begin();

((*it)->GetGenomic_end() > (*next)->GetGenomic_start()) {

cross_the_origin =

;

((*it)->GetGenomic_start() < (*next)->GetGenomic_end()) {

cross_the_origin =

;

(cross_the_origin) {

genomic_size = m_scope->GetSequenceLength(spliced_seg.

());

range.

(range.

() + genomic_size);

range.

(range.

() + genomic_size);

(spliced_seg.

().size() == 1) {

(

& it : spliced_seg.

()) {

it->SetGenomic_start(it->GetGenomic_start() + genomic_size);

it->SetGenomic_end(it->GetGenomic_end() + genomic_size);

align_range.

(align_range.

() + genomic_size);

it = spliced_seg.

().begin();

(s_CrossesOrigin(**it, **

, plus_strand)) {

adj_start =

;

adj_end = spliced_seg.

().end();

( !plus_strand ) {

adj_start = spliced_seg.

().begin();

( ; adj_start != adj_end; ++adj_start) {

(*adj_start)->SetGenomic_start

((*adj_start)->GetGenomic_start() + genomic_size);

(*adj_start)->SetGenomic_end

((*adj_start)->GetGenomic_end() + genomic_size);

(*adj_start)->GetGenomic_end()));

cerr <<

<< range << endl;

cerr <<

<< align_range << endl;

(

);

GetExonStructure(spliced_seg, exons, m_scope);

is_protein_align =

vector<SExon>::iterator right_exon_it = exons.begin();

CSpliced_seg::TExons::iterator right_spl_exon_it = spliced_seg.

().begin();

(;;++right_exon_it, ++right_spl_exon_it) {

vector<SExon>::reverse_iterator left_exon_it(right_exon_it);

CSpliced_seg::TExons::reverse_iterator left_spl_exon_it(right_spl_exon_it);

(right_exon_it == exons.end() &&

left_exon_it->genomic_to > range_right

exons.rend(), left_exon_it, left_spl_exon_it,

product_strand, genomic_strand);

(right_exon_it == exons.begin() &&

right_exon_it->genomic_from < range_left

right_exon_it, exons.end(), right_spl_exon_it,

product_strand, genomic_strand);

delete_me =

;

(left_exon_it.base() != right_exon_it) {

right_exon_it = exons.erase(left_exon_it.base(), right_exon_it);

right_spl_exon_it = spliced_seg.

().erase(left_spl_exon_it.base(), right_spl_exon_it);

(right_exon_it == exons.end())

first_exon_extension = 0;

last_exon_extension = 0;

first_exon_extension =

(first_exon_extension > 0) {

chunk->SetDiag(first_exon_extension);

last_exon_extension =

(last_exon_extension > 0) {

chunk->SetDiag(last_exon_extension);

last_exon.

().push_back(chunk);

last_exon_extension =

(last_exon_extension > 0) {

chunk->SetDiag(last_exon_extension);

last_exon.

().push_back(chunk);

first_exon_extension =

(first_exon_extension > 0) {

chunk->SetDiag(first_exon_extension);

exons.front().prod_from -= first_exon_extension;

exons.front().genomic_from -= first_exon_extension;

exons.back().prod_to += last_exon_extension;

exons.back().genomic_to += last_exon_extension;

(first_exon_extension > 0) {

exon->SetGenomic_start() = range.

();

exon->SetGenomic_end() = genomic_size-1;

spliced_seg.

().push_front(exon);

exon_struct.

= exons.front().prod_from - first_exon_extension;

exon_struct.

= exons.front().prod_from - 1;

exon_struct.

= exons.front().genomic_from - first_exon_extension;

exon_struct.

= exons.front().genomic_from - 1;

exons.insert(exons.begin(), exon_struct);

(last_exon_extension > 0) {

exon->SetGenomic_start() = 0;

exon->SetGenomic_end() = last_exon_extension - 1;

spliced_seg.

().push_back(exon);

exon_struct.

= exons.back().prod_to + 1;

exon_struct.

= exons.back().prod_to + last_exon_extension;

exon_struct.

= exons.back().genomic_to +1;

exon_struct.

= exons.back().genomic_to + last_exon_extension;

exons.push_back(exon_struct);

(last_exon_extension > 0) {

exon->SetGenomic_start() = range.

();

exon->SetGenomic_end() = genomic_size-1;

spliced_seg.

().push_back(exon);

exon_struct.

= exons.back().prod_to + 1;

exon_struct.

= exons.back().prod_to + last_exon_extension;

exon_struct.

= exons.back().genomic_to +1;

exon_struct.

= exons.back().genomic_to + last_exon_extension;

exons.push_back(exon_struct);

(first_exon_extension > 0) {

exon->SetGenomic_start() = 0;

exon->SetGenomic_end() = first_exon_extension - 1;

spliced_seg.

().push_front(exon);

exon_struct.

= exons.front().prod_from - first_exon_extension;

exon_struct.

= exons.front().prod_from - 1;

exon_struct.

= exons.front().genomic_from - first_exon_extension;

exon_struct.

= exons.front().genomic_from - 1;

exons.insert(exons.begin(), exon_struct);

(range_left != exons.front().genomic_from || range_right != exons.back().genomic_to) {

);

= is_protein_align ?

(exons.front().prod_from/3)*3 : exons.front().prod_from;

(

> exons.front().prod_from)

vector<SExon>::iterator exon_struct_it = exons.begin();

putative_prod_length = 0;

(is_protein_align) {

putative_prod_length = (exons.back().prod_to -

+ 3)/3;

putative_prod_length = exons.back().prod_to -

+ 1;

(cross_the_origin) {

& spliced_exons = spliced_seg.

();

(

exon_it = spliced_exons.begin(); exon_it != spliced_exons.end();) {

delete_me =

;

( (*exon_it)->IsSetParts() ) {

(

part_it: (*exon_it)->GetParts()) {

( part_it->Which()) {

exon_it = spliced_exons.erase(exon_it);

(GetExons(*align) != orig_exons) {

ClearScores(*align);

feat_iter; ++feat_iter)

(!feat_iter.GetSize() ||

(feat_iter->IsSetPseudo() && feat_iter->GetPseudo()))

cdregion_feat = *feat_iter;

cdregion_feat;

vector<SExon>::reverse_iterator left_edge,

vector<SExon>::reverse_iterator& exon_it,

CSpliced_seg::TExons::reverse_iterator& spl_exon_it,

( trim_amount < 3 || side!=eTrimProduct );

is_protein = (*spl_exon_it)->GetProduct_start().IsProtpos();

(trim_amount > 0) {

exon_len = side==eTrimProduct

? (exon_it->prod_to - exon_it->prod_from + 1)

: (exon_it->genomic_to - exon_it->genomic_from + 1);

(exon_len <= trim_amount) {

next_from = exon_it->genomic_from;

trim_amount -= exon_len;

( trim_amount==0 || side!=eTrimProduct );

(exon_it == left_edge)

(trim_amount > 0) {

trim_amount -= next_from - exon_it->genomic_to -1;

(*spl_exon_it)->SetPartial(

);

(*spl_exon_it)->ResetDonor_after_exon();

genomic_trim_amount = 0;

product_trim_amount = 0;

((*spl_exon_it)->CanGetParts() && !(*spl_exon_it)->GetParts().empty()) {

CSpliced_exon_Base::TParts::iterator chunk = parts.end();

(--chunk, (trim_amount>0 ||

? (*chunk)->IsGenomic_ins()

: (*chunk)->IsProduct_ins()))) {

product_chunk_len = 0;

genomic_chunk_len = 0;

((*chunk)->Which()) {

product_chunk_len = (*chunk)->GetMatch();

genomic_chunk_len = product_chunk_len;

(product_chunk_len > trim_amount) {

(*chunk)->SetMatch(product_chunk_len - trim_amount);

product_chunk_len = (*chunk)->GetMismatch();

genomic_chunk_len = product_chunk_len;

(product_chunk_len > trim_amount) {

(*chunk)->SetMismatch(product_chunk_len - trim_amount);

product_chunk_len = (*chunk)->GetDiag();

genomic_chunk_len = product_chunk_len;

(product_chunk_len > trim_amount) {

(*chunk)->SetDiag(product_chunk_len - trim_amount);

product_chunk_len = (*chunk)->GetProduct_ins();

(side==eTrimProduct && product_chunk_len > trim_amount) {

(*chunk)->SetProduct_ins(product_chunk_len - trim_amount);

genomic_chunk_len = (*chunk)->GetGenomic_ins();

(side==eTrimGenomic && genomic_chunk_len > trim_amount) {

(*chunk)->SetGenomic_ins(genomic_chunk_len - trim_amount);

(side==eTrimProduct && product_chunk_len <= trim_amount) {

genomic_trim_amount += genomic_chunk_len;

product_trim_amount += product_chunk_len;

trim_amount -= product_chunk_len;

}

(side==eTrimGenomic && genomic_chunk_len <= trim_amount) {

genomic_trim_amount += genomic_chunk_len;

product_trim_amount += product_chunk_len;

trim_amount -= genomic_chunk_len;

genomic_trim_amount +=

(trim_amount, genomic_chunk_len);

product_trim_amount +=

(trim_amount, product_chunk_len);

chunk = parts.erase(chunk);

genomic_trim_amount += trim_amount;

product_trim_amount += trim_amount;

exon_it->prod_to -= product_trim_amount;

exon_it->genomic_to -= genomic_trim_amount;

& prot_pos = (*spl_exon_it)->SetProduct_end();

SetProtpos(prot_pos, exon_it->prod_to);

(*spl_exon_it)->SetProduct_end().SetNucpos() -= product_trim_amount;

(*spl_exon_it)->SetProduct_start().SetNucpos() += product_trim_amount;

(*spl_exon_it)->SetGenomic_end() -= genomic_trim_amount;

(*spl_exon_it)->SetGenomic_start() += genomic_trim_amount;

vector<SExon>::iterator& exon_it,

vector<SExon>::iterator right_edge,

CSpliced_seg::TExons::iterator& spl_exon_it,

( trim_amount < 3 || side!=eTrimProduct );

is_protein = (*spl_exon_it)->GetProduct_start().IsProtpos();

(trim_amount > 0) {

exon_len = side==eTrimProduct

? (exon_it->prod_to - exon_it->prod_from + 1)

: (exon_it->genomic_to - exon_it->genomic_from + 1);

(exon_len <= trim_amount) {

prev_to = exon_it->genomic_to;

trim_amount -= exon_len;

( trim_amount==0 || side!=eTrimProduct );

(exon_it == right_edge)

(trim_amount > 0) {

trim_amount -= exon_it->genomic_from - prev_to -1;

(*spl_exon_it)->SetPartial(

);

(*spl_exon_it)->ResetAcceptor_before_exon();

genomic_trim_amount = 0;

product_trim_amount = 0;

((*spl_exon_it)->CanGetParts() && !(*spl_exon_it)->GetParts().empty()) {

CSpliced_exon_Base::TParts::iterator chunk = parts.begin();

(; trim_amount>0 ||

? (*chunk)->IsGenomic_ins()

: (*chunk)->IsProduct_ins());

product_chunk_len = 0;

genomic_chunk_len = 0;

((*chunk)->Which()) {

product_chunk_len = (*chunk)->GetMatch();

genomic_chunk_len = product_chunk_len;

(product_chunk_len > trim_amount) {

(*chunk)->SetMatch(product_chunk_len - trim_amount);

product_chunk_len = (*chunk)->GetMismatch();

genomic_chunk_len = product_chunk_len;

(product_chunk_len > trim_amount) {

(*chunk)->SetMismatch(product_chunk_len - trim_amount);

product_chunk_len = (*chunk)->GetDiag();

genomic_chunk_len = product_chunk_len;

(product_chunk_len > trim_amount) {

(*chunk)->SetDiag(product_chunk_len - trim_amount);

product_chunk_len = (*chunk)->GetProduct_ins();

(side==eTrimProduct && product_chunk_len > trim_amount) {

(*chunk)->SetProduct_ins(product_chunk_len - trim_amount);

genomic_chunk_len = (*chunk)->GetGenomic_ins();

(side==eTrimGenomic && genomic_chunk_len > trim_amount) {

(*chunk)->SetGenomic_ins(genomic_chunk_len - trim_amount);

(side==eTrimProduct && product_chunk_len <= trim_amount) {

genomic_trim_amount += genomic_chunk_len;

product_trim_amount += product_chunk_len;

trim_amount -= product_chunk_len;

}

(side==eTrimGenomic && genomic_chunk_len <= trim_amount) {

genomic_trim_amount += genomic_chunk_len;

product_trim_amount += product_chunk_len;

trim_amount -= genomic_chunk_len;

genomic_trim_amount +=

(trim_amount, genomic_chunk_len);

product_trim_amount +=

(trim_amount, product_chunk_len);

chunk = parts.erase(chunk);

genomic_trim_amount += trim_amount;

product_trim_amount += trim_amount;

exon_it->prod_from += product_trim_amount;

exon_it->genomic_from += genomic_trim_amount;

& prot_pos = (*spl_exon_it)->SetProduct_start();

SetProtpos(prot_pos, exon_it->prod_from);

(*spl_exon_it)->SetProduct_start().SetNucpos() += product_trim_amount;

(*spl_exon_it)->SetProduct_end().SetNucpos() -= product_trim_amount;

(*spl_exon_it)->SetGenomic_start() += genomic_trim_amount;

(*spl_exon_it)->SetGenomic_end() -= genomic_trim_amount;

(

!=

) {

gcode =

->GetGenCode(gcode);

@ eExtreme_Positional

numerical value

unique_ptr< SImplementation > m_impl

CConstRef< objects::CSeq_align > AdjustAlignment(const objects::CSeq_align &align, TSeqRange range, EProductPositionsMode mode=eForceProductFrom0)

EProductPositionsMode

Adjust alignment to the specified range (cross-the-origin range on circular chromosome is indicated b...

@ eTryToPreserveProductPositions

void AddSplignScores(const CSeq_align &align, CSeq_align::TScore &scores)

Compute the six splign scores.

void AddScore(CScope &scope, CSeq_align &align, CSeq_align::EScoreType score)

EScoreType

enum controlling known named scores

@ eScore_PercentIdentity_Gapped

@ eScore_PercentIdentity_Ungapped

@ eScore_HighQualityPercentCoverage

const CSeq_id & GetSeq_id(TDim row) const

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

bool GetNamedScore(const string &id, int &score) const

Get score.

void ResetNamedScore(const string &name)

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

unsigned int TSeqPos

Type for sequence locations and lengths.

#define ITERATE(Type, Var, Cont)

ITERATE macro to sequence through container elements.

#define ERASE_ITERATE(Type, Var, Cont)

Non-constant version with ability to erase current element, if container permits.

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)

#define ERR_POST(message)

Error posting with file, line number information but without error codes.

#define NCBI_USER_THROW(message)

Throw a quick-and-dirty runtime exception of type 'CException' with the given error message and error...

#define NCBI_THROW(exception_class, err_code, message)

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

void Warning(CExceptionArgs_Base &args)

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

Set object to copy of another one.

#define MSerial_AsnText

I/O stream manipulators –.

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

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

TRange GetTotalRange(void) const

TSeqPos GetStart(ESeqLocExtremes ext) const

Return start and stop positions of the seq-loc.

const CSeq_id * GetId(void) const

Get the id of the location return NULL if has multiple ids or no id at all.

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

Determines if two CSeq_ids represent the same CBioseq.

const CBioSource * GetBioSource(const CBioseq &bioseq)

Retrieve the BioSource object for a given bioseq handle.

CRef< CSeq_loc > Map(const CSeq_loc &src_loc)

Map seq-loc.

TSeqPos GetSequenceLength(const CSeq_id &id, TGetFlags flags=0)

Get sequence length Return kInvalidSeqPos if sequence is not found.

CBioseq_Handle GetBioseqHandle(const CSeq_id &id)

Get bioseq handle by seq-id.

@ eLocationToProduct

Map from the feature's location to product.

bool IsSetProduct(void) const

const CSeq_loc & GetLocation(void) const

CConstRef< CSeq_feat > GetSeq_feat(void) const

Get current seq-feat.

void Reset(void)

Reset reference object.

int64_t Int8

8-byte (64-bit) signed integer

bool IntersectingWith(const TThisType &r) const

CRange< TSeqPos > TSeqRange

typedefs for sequence ranges

CRange< TSignedSeqPos > TSignedSeqRange

#define END_NCBI_SCOPE

End previously defined NCBI scope.

#define BEGIN_NCBI_SCOPE

Define ncbi namespace.

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.

const TDonor_after_exon & GetDonor_after_exon(void) const

Get the Donor_after_exon member data.

void SetScores(TScores &value)

Assign a value to Scores data member.

TScore & SetScore(void)

Assign a value to Score data member.

const TGenomic_id & GetGenomic_id(void) const

Get the Genomic_id member data.

void SetProduct_start(TProduct_start &value)

Assign a value to Product_start data member.

void SetAmin(TAmin value)

Assign a value to Amin data member.

bool IsSetParts(void) const

basic seqments always are in biologic order Check if a value has been assigned to Parts data member.

list< CRef< CScore > > Tdata

TProduct_ins & SetProduct_ins(void)

Select the variant.

void SetProduct_end(TProduct_end &value)

Assign a value to Product_end data member.

bool IsSetProduct_strand(void) const

should be 'plus' or 'minus' Check if a value has been assigned to Product_strand data member.

const TProduct_id & GetProduct_id(void) const

Get the Product_id member data.

TGenomic_start GetGenomic_start(void) const

Get the Genomic_start member data.

bool CanGetExons(void) const

Check if it is safe to call GetExons method.

void SetSegs(TSegs &value)

Assign a value to Segs data member.

TDiag & SetDiag(void)

Select the variant.

bool IsSetAcceptor_before_exon(void) const

splice sites Check if a value has been assigned to Acceptor_before_exon data member.

TExons & SetExons(void)

Assign a value to Exons data member.

TProduct_length GetProduct_length(void) const

Get the Product_length member data.

bool IsSetPoly_a(void) const

start of poly(A) tail on the transcript For sense transcripts: aligned product positions < poly-a <= ...

void ResetScore(void)

Reset Score data member.

TExt & SetExt(void)

Assign a value to Ext data member.

void SetProduct_length(TProduct_length value)

Assign a value to Product_length data member.

TProduct_type GetProduct_type(void) const

Get the Product_type member data.

TGenomic_strand GetGenomic_strand(void) const

Get the Genomic_strand member data.

void SetGenomic_start(TGenomic_start value)

Assign a value to Genomic_start data member.

const TParts & GetParts(void) const

Get the Parts member data.

const TProduct_start & GetProduct_start(void) const

Get the Product_start member data.

const TProduct_end & GetProduct_end(void) const

Get the Product_end member data.

const TSpliced & GetSpliced(void) const

Get the variant data.

bool CanGetSegs(void) const

Check if it is safe to call GetSegs method.

bool IsSetExt(void) const

extra info Check if a value has been assigned to Ext data member.

TGenomic_ins GetGenomic_ins(void) const

Get the variant data.

bool IsSetGenomic_strand(void) const

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

void SetPartial(TPartial value)

Assign a value to Partial data member.

list< CRef< CSpliced_exon > > TExons

const TExons & GetExons(void) const

Get the Exons member data.

TProtpos & SetProtpos(void)

Select the variant.

TGenomic_ins & SetGenomic_ins(void)

Select the variant.

bool CanGetProduct_id(void) const

Check if it is safe to call GetProduct_id method.

bool IsSetExons(void) const

set of segments involved each segment corresponds to one exon exons are always in biological order Ch...

TParts & SetParts(void)

Assign a value to Parts data member.

void SetGenomic_end(TGenomic_end value)

Assign a value to Genomic_end data member.

list< CRef< CSpliced_exon_chunk > > TParts

bool IsSetProduct_length(void) const

length of the product, in bases/residues from this (or from poly-a if present), a 3' unaligned length...

bool IsSetScore(void) const

for whole alignment Check if a value has been assigned to Score data member.

TPoly_a GetPoly_a(void) const

Get the Poly_a member data.

TGenomic_end GetGenomic_end(void) const

Get the Genomic_end member data.

bool IsSpliced(void) const

Check if variant Spliced is selected.

TProduct_strand GetProduct_strand(void) const

Get the Product_strand member data.

void SetFrame(TFrame value)

Assign a value to Frame data member.

TProduct_ins GetProduct_ins(void) const

Get the variant data.

const TSegs & GetSegs(void) const

Get the Segs member data.

bool IsSetDonor_after_exon(void) const

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

bool IsSetScores(void) const

scores for this exon Check if a value has been assigned to Scores data member.

E_Choice Which(void) const

Which variant is currently selected.

@ e_Product_ins

insertion in product sequence (i.e. gap in the genomic sequence)

@ e_Diag

both sequences are represented, there is sufficient similarity between product and genomic sequences....

@ e_Genomic_ins

insertion in genomic sequence (i.e. gap in the product sequence)

@ e_Match

both sequences represented, product and genomic sequences match

@ e_Mismatch

both sequences represented, product and genomic sequences do not match

@ eProduct_type_transcript

ENa_strand

strand of nucleic acid

unsigned int

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

int GetGeneticCode(const CBioseq_Handle &bsh)

const GenericPointer< typename T::ValueType > T2 value

const CharType(& source)[N]

#define NCBI_CONST_INT8(v)

64-bit integers

static const GLdouble origin[]

TSignedSeqPos genomic_from

static void TrimLeftExon(int trim_amount, ETrimSide side, vector< SExon >::reverse_iterator left_edge, vector< SExon >::reverse_iterator &exon_it, objects::CSpliced_seg::TExons::reverse_iterator &spl_exon_it, objects::ENa_strand product_strand, objects::ENa_strand genomic_strand)

void MaximizeTranslation(objects::CSeq_align &align)

vector< SExon > GetExons(const CSeq_align &align)

void RecalculateScores(CSeq_align &align)

CConstRef< objects::CSeq_align > AdjustAlignment(const objects::CSeq_align &align, TSeqRange range, EProductPositionsMode mode)

void RecalculateExonIdty(CSpliced_exon &exon)

TSignedSeqRange GetCds(const objects::CSeq_id &seqid)

void GetExonStructure(const CSpliced_seg &spliced_seg, vector< SExon > &exons, CScope *scope)

void ClearScores(CSeq_align &align)

static void TrimRightExon(int trim_amount, ETrimSide side, vector< SExon >::iterator &exon_it, vector< SExon >::iterator right_edge, objects::CSpliced_seg::TExons::iterator &spl_exon_it, objects::ENa_strand product_strand, objects::ENa_strand genomic_strand)

void TrimHolesToCodons(objects::CSeq_align &align)

void StitchSmallHoles(objects::CSeq_align &align)

CSeq_align::EScoreType s_ScoresToRecalculate[]

CMappedFeat GetCdsOnMrna(const objects::CSeq_id &rna_id, CScope &scope)

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