RetroSearch Browse

.empty() ) {

100 size_t

rows =

.size();

102 for

(

size_t i

= 1;

< rows; ++

) {

105 "Rows have different lengths"

);

108 for

(

size_t a

= 0;

size

; ++

) {

109 bool

is_mismatch =

false

;

110 char

c =

[0][

];

111 for

(

size_t b

= 1;

< rows; ++

) {

112 if

(

[

][

] != c) {

144 if

( !prod_bsh || !genomic_bsh ) {

147 "Can't get sequence data for "

+ failed_id.

AsFastaString

() +

148 " in order to count identities/mismatches"

);

164 gen

.GetSeqData(

.GetFrom(),

.GetTo() + 1, gen_data);

174 TSeqPos

start_offset = range_it->GetFrom() -

.GetFrom(),

175

end_offset = range_it->GetToOpen() -

.GetFrom();

176

string::const_iterator pit = prod_data.begin()

178

string::const_iterator pit_end = prod_data.begin()

180

string::const_iterator git = gen_data.begin()

182

string::const_iterator git_end = gen_data.begin()

185 for

( ; pit != pit_end && git != git_end; ++pit, ++git)

187 bool match

= (*pit == *git);

188

*identities +=

match

;

189

*mismatches += !

match

;

208

codon[0] = codon[1] = codon[2] =

'N'

;

216 if

(last_r1.

GetTo

() + 1 !=

.GetFrom()) {

217 size_t i

= last_r1.

GetTo

() + 1;

220

codon[

% 3 ] =

'N'

;

227 gen

.GetSeqData(

.GetFrom(),

.GetTo() + 1, gen_data);

241 for

(

size_t i

= 0;

< gen_data.size(); ++

, ++prod_pos) {

242

codon[ prod_pos % 3 ] = gen_data[

];

245 if

(prod_pos % 3 == 2) {

247 char

residue = (prod_pos == 2

254 if

(residue == prod[prod_pos / 3] &&

255

residue !=

'X'

&& residue !=

'-'

) {

286 int

* identities,

int

* mismatches,

290 _ASSERT

(identities && mismatches);

291 if

(ranges.empty()) {

300 if

(ranges.begin()->IsWhole() &&

304

*identities += num_ident;

305

*mismatches += (

- num_ident);

314

vector<string>

;

317 for

(

int

seg = 0; seg < vec.

GetNumSegs

(); ++seg) {

318 bool

has_gap =

false

;

319 for

(

int i

= 0; !has_gap &&

< vec.

GetNumRows

(); ++

) {

331

seg_stop = vec.

GetStop

(0, seg);

339

range_it->GetFrom()+

offset

340

range_it->GetTo()+

offset

);

341 data

[

] += seq_string;

354

identities, mismatches, ranges);

361 "identity + mismatch function not implemented for std-seg"

);

366 int

aln_identities = 0;

367 int

aln_mismatches = 0;

368 bool

has_non_standard =

false

;

380 switch

(chunk.

Which

()) {

385

part_start+part_len-1));

392

part_start+part_len-1));

399

part_start+part_len-1)))

401

has_non_standard =

true

;

412

part_start += part_len;

415

has_non_standard =

true

;

419 if

( !has_non_standard ) {

420

*identities += aln_identities;

421

*mismatches += aln_mismatches;

431

identities, mismatches);

434 "Can't calculate identities/mismatches for " 435 "alignment with genomic sequence "

437 "; Loader can't load all required " 438 "components of sequence"

);

456 double

* pct_identity,

461 size_t

count_aligned = 0;

479

*pct_identity = 100.0f * double(*identities) / count_aligned;

497 "failed to retrieve sequence: "

id

.AsFastaString());

539 double

* pct_coverage,

unsigned query

= 0)

541 if

(!ranges.

() && ranges.

()->IsWhole() &&

550 if

(ranges.

() || !ranges.

()->IsWhole()){

559 const

objects::CBioseq_Handle& bsh_seq = scope.

GetBioseqHandle

(query_id);

563 "Can't get sequence data for "

+ query_id.AsFastaString() +

564 " in order to calculate coverage"

);

566

seq_len = bsh_seq.GetBioseqLength();

584 if

(is_protein_to_genomic) {

598

*pct_coverage = 100.0f * double(covered_bases) / double(seq_len);

607 int

* positives,

int

* negatives)

614 "num_positives and num_negatives scores only defined " 615 "for protein alignment"

);

619 const string

& dna = pro_text.

GetDNA

();

621 for

(string::size_type

=0;

match

.size(); ++

) {

627

*positives += increment;

632

*negatives += increment;

653 double

pct_identity = 0;

655

&identities, &mismatches, &pct_identity,

type

);

667 double

pct_identity = 0;

669

&identities, &mismatches, &pct_identity,

type

682 double

pct_identity = 0;

684

&identities, &mismatches, &pct_identity,

type

, ranges);

693 double

pct_coverage = 0;

706 double

pct_coverage = 0;

716 double

pct_coverage = 0;

740 int

& identities,

int

& mismatches)

772 int

& identities,

int

& mismatches)

803 int

& identities,

int

& mismatches)

830 int

& positives,

int

& negatives)

925 double

pct_identity = 0;

939 double

score_value =

ComputeScore

(scope, align, score);

954 switch

(e.GetErrCode()) {

967

"CScoreBuilderBase::AddScore(): error computing score: " 975 string GetDonor

(

const

objects::CSpliced_exon& exon) {

976 if

( exon.CanGetDonor_after_exon() && exon.GetDonor_after_exon().CanGetBases() ) {

977 return

exon.GetDonor_after_exon().GetBases();

983 if

( exon.CanGetAcceptor_before_exon() && exon.GetAcceptor_before_exon().CanGetBases() ) {

984 return

exon.GetAcceptor_before_exon().GetBases();

991 if

(donor.length()<2 || acc.length()<2)

return false

;

992 if

(

toupper

(

Uchar

(acc.c_str()[0])) !=

'A'

)

return false

;

1001 if

(don2 ==

'T'

|| don2 ==

'C'

)

return true

;

1020 "CScoreBuilderBase::AddSplignScores(): Unsupported product type"

);

1025 typedef

TSpliced::TExons TExons;

1026 const

TExons & exons (spliced.GetExons());

1029

aligned_query_bases (0),

1030

aln_length_exons (0),

1031

aln_length_gaps (0),

1033

splices_consensus (0);

1035 const TSeqPos

qlen (spliced.GetProduct_length());

1036 const TSeqPos

polya (spliced.CanGetPoly_a()?

1037

spliced.GetPoly_a(): (qstrand? qlen:

TSeqPos

(-1)));

1038 const TSeqPos

prod_length_no_polya (qstrand? polya: qlen - 1 - polya);

1043 ITERATE

(TExons, ii2, exons) {

1045 const

TExon & exon (**ii2);

1046 const TSeqPos

qmin (exon.GetProduct_start().GetNucpos()),

1047

qmax (exon.GetProduct_end().GetNucpos());

1049 const TSeqPos

qgap (qstrand? qmin - qprev - 1: qprev - qmax - 1);

1052

aln_length_gaps += qgap;

1055 else if

(ii2 != exons.begin()) {

1060 typedef

TExon::TParts TParts;

1061 const

TParts & parts (exon.GetParts());

1063 ITERATE

(TParts, ii3, parts) {

1071

aligned_query_bases +=

;

1075

aligned_query_bases +=

;

1079

aligned_query_bases +=

;

1085

errmsg =

"Unexpected spliced exon chunk part: " 1089

aln_length_exons +=

;

1093

qprev = qstrand? qmax: qmin;

1096 const TSeqPos

qgap (qstrand? polya - qprev - 1: qprev - polya - 1);

1097

aln_length_gaps += qgap;

1099 for

(CSeq_align::TScore::iterator it = scores.begin(); it != scores.end(); )

1102 if

((*it)->GetId().IsStr()) {

1105

. find((*it)->GetId().GetStr());

1107

score_type = score->second;

1113

it = scores.erase(it);

1121

score_matches->SetId().SetStr(

1123

score_matches->SetValue().SetInt(matches);

1124

scores.push_back(score_matches);

1128

score_overall_identity->SetId().SetStr(

1130

score_overall_identity->SetValue().

1131

SetReal(

double

(matches)/(aln_length_exons + aln_length_gaps));

1132

scores.push_back(score_overall_identity);

1136

score_splices->SetId().SetStr(

1138

score_splices->SetValue().SetInt(splices_total);

1139

scores.push_back(score_splices);

1143

score_splices_consensus->SetId().SetStr(

1145

score_splices_consensus->SetValue().SetInt(splices_consensus);

1146

scores.push_back(score_splices_consensus);

1150

score_coverage->SetId().SetStr(

1152

score_coverage->SetValue().

1153

SetReal(

double

(aligned_query_bases) / prod_length_no_polya);

1154

scores.push_back(score_coverage);

1158

score_exon_identity->SetId().SetStr(

1160

score_exon_identity->SetValue().

1161

SetReal(

double

(matches) / aln_length_exons);

1162

scores.push_back(score_exon_identity);

1189 "CScoreBuilderBase::ComputeScore(): " 1190 "generic 'score' computation is undefined"

);

1200 "CScoreBuilderBase::ComputeScore(): " 1201 "BLAST scores are available in CScoreBuilder, " 1202 "not CScoreBuilderBase"

);

1209 if

(ranges.

() || !ranges.

()->IsWhole()) {

1211 "positive-count score not supported within a range"

);

1216 if

(ranges.

() || !ranges.

()->IsWhole()) {

1218 "positive-count score not supported within a range"

);

1235 double

pct_identity = 0;

1237

&identities, &mismatches, &pct_identity,

1239 return

pct_identity;

1247 double

pct_identity = 0;

1249

&identities, &mismatches, &pct_identity,

1251 return

pct_identity;

1259 double

pct_identity = 0;

1261

&identities, &mismatches, &pct_identity,

1263 return

pct_identity;

1269 double

pct_coverage = 0;

1271 return

pct_coverage;

1280 "High-quality percent coverage not supported " 1281 "for standard seg representation"

);

1283 if

(ranges.

() || !ranges.

()->IsWhole()) {

1285 "High-quality percent coverage not supported " 1294

SetExcludeExternal());

1297 if

(feat_it->GetData().GetRegion() ==

"alignable"

1298

feat_it->GetAnnot().IsNamed() &&

1299

feat_it->GetAnnot().GetName() ==

"NCBI_GPIPE"

)

1301

alignable_range = feat_it->GetRange();

1305 double

pct_coverage = 0;

1309 return

pct_coverage;

1320 if

(ranges.

() || !ranges.