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

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

NCBI C++ ToolKit: src/algo/blast/api/blast_seqalign.cpp Source File

retval = -(pos + pos2advance - 1);

strand,

translate,

length,

original_length,

retval = original_length -

,

nsegs,

query_length,

subject_length,

translate1,

translate2)

length1 = query_length;

length2 = subject_length;

lengths.reserve(nsegs);

(

esp_index =

; esp_index< (

)esp->

&& esp_index < (

)(

+nsegs); esp_index++) {

(esp->

[esp_index]) {

strands.push_back(m_strand);

strands.push_back(s_strand);

starts.push_back(m_start);

starts.push_back(s_start);

strands.push_back(m_strand);

starts.push_back(m_start);

starts.push_back(s_start);

strands.push_back(s_strand);

starts.push_back(m_start);

starts.push_back(s_start);

lengths.push_back(esp->

[esp_index]);

(lengths.size() != nsegs)

lengths.resize(nsegs);

(starts.size() != nsegs*2)

starts.resize(nsegs*2);

(strands.size() != nsegs*2)

strands.resize(nsegs*2);

ids.push_back(master);

ids.push_back(slave);

dense_seg.

((

) lengths.size());

dense_seg.

().swap(lengths);

translate_master,

translate_slave)

nsegs = (

) lengths.size();

(

= 0;

< nsegs;

++) {

( (m_start = starts[2*

]) !=

) {

master_loc->

().SetId(*master);

master_loc->

().SetFrom(m_start);

(translate_master)

m_stop = m_start + lengths[

] - 1;

master_loc->

().SetTo(m_stop);

master_loc->

().SetStrand(strands[2*

]);

( (s_start = starts[2*

+1]) !=

) {

slave_loc->

().SetId(*slave);

slave_loc->

().SetFrom(s_start);

s_stop = s_start + lengths[

] - 1;

slave_loc->

().SetTo(s_stop);

slave_loc->

().SetStrand(strands[2*

+1]);

std_seg->SetIds().push_back(master);

std_seg->SetIds().push_back(slave);

std_seg->SetLoc().push_back(master_loc);

std_seg->SetLoc().push_back(slave_loc);

retval.push_back(std_seg);

(

index=0; index<esp->

; index++)

temp_num = esp->

[index];

esp->

[index] = esp->

[index-1];

esp->

[index-1] = temp_num;

esp->

[index-1] = temp_op;

product_length = product_end - product_start + 1;

genomic_length = genomic_end - genomic_start + 1;

(

& it : exon.

()) {

(it->Which()) {

p += it->GetMismatch();

+= it->GetMismatch();

p += it->GetProduct_ins();

+= it->GetGenomic_ins();

cerr <<

<< product_id.

()

(p != product_length) {

<< product_length <<

<< p << endl;

(

!= genomic_length) {

<< genomic_length <<

<<

<< endl;

kGap = 15;

(last_h->

&&

last_h = last_h->

;

exon->SetProduct_start().SetNucpos(hsp->

.

);

exon->SetProduct_end().SetNucpos(last_hsp->

.

- 1);

exon->SetGenomic_end(last_hsp->

.

- 1);

exon->SetProduct_strand(product_strand);

exon->SetGenomic_strand(genomic_strand);

exon->SetAcceptor_before_exon().SetBases(l_bases);

exon->SetDonor_after_exon().SetBases(r_bases);

= hh, hh = hh->next) {

query_pos = hh->hsp->query.offset;

subject_pos = hh->hsp->subject.offset;

(hh->hsp->query.offset >=

->hsp->query.end);

(hh->hsp->subject.offset >=

->hsp->subject.end);

(hh->hsp->query.offset >

->hsp->query.end) {

chunk->SetProduct_ins(hh->hsp->query.offset -

->hsp->query.end);

exon->SetParts().push_back(chunk);

(hh->hsp->subject.offset >

->hsp->subject.end) {

chunk->SetGenomic_ins(hh->hsp->subject.offset -

->hsp->subject.end);

exon->SetParts().push_back(chunk);

query_pos += num_matches;

subject_pos += num_matches;

(num_matches > 0) {

chunk->SetMatch(num_matches);

exon->SetParts().push_back(chunk);

chunk->SetGenomic_ins(1);

chunk->SetProduct_ins(1);

chunk->SetMismatch(1);

exon->SetParts().push_back(chunk);

num_matches =

(hh->hsp->query.end - query_pos, 0);

(hh->hsp->query.end - query_pos >= -1);

(num_matches > 0) {

chunk->SetMatch(num_matches);

exon->SetParts().push_back(chunk);

exons.push_back(exon);

translate_master,

translate_slave)

(translate_master || translate_slave) {

translate_master, translate_slave);

query_length,

subject_length)

translate1, translate2;

is_disc_align =

;

(hsp->

== 0) {

(

=0;

<

->size;

++) {

is_disc_align =

;

(

index=0; index< esp->

; index++)

skip_region =

;

(index2=

; index2<esp->

; index2++, nsegs++){

strands, query_length, subject_length,

translate1, translate2);

translate1, translate2);

seqalign->

().SetDisc().Set().push_back(sa_tmp);

strands, query_length, subject_length,

translate1, translate2);

query_length,

subject_length)

original_length1, original_length2;

from1, from2, to1, to2;

original_length1 = subject_length;

original_length2 = query_length;

id1.

(subject_id);

id2.

(query_id);

original_length1 = query_length;

original_length2 = subject_length;

id1.

(query_id);

id2.

(subject_id);

first_shift =

;

(

index=0; index<esp->

; index++)

(esp->

[index]) {

first_shift =

;

slp1->

().SetTo(

(start1,original_length1) - 1);

slp1->

().SetId(*id1);

slp1->

().SetStrand(strand1);

to1 =

(start1,original_length1) - 1;

slp1->

().SetTo(to1);

slp1->

().SetId(*id1);

slp1->

().SetStrand(strand1);

to2 =

(start2,original_length2) - 1;

slp2->

().SetFrom(from2);

slp2->

().SetTo(to2);

(start2 > original_length2)

slp1->

().SetTo(to1 - 1);

slp2->

().SetTo(original_length2 - from2 - 1);

slp2->

().SetFrom(original_length2 - to2 - 1);

slp2->

().SetId(*id2);

slp2->

().SetStrand(strand2);

seg->SetLoc().push_back(slp2);

seg->SetLoc().push_back(slp1);

seg->SetLoc().push_back(slp1);

seg->SetLoc().push_back(slp2);

ids.resize(seg->GetDim());

seqalign->

().SetStd().push_back(seg);

first_shift =

;

to2 =

(start2,original_length2) - 1;

slp2->

().SetFrom(from2);

slp2->

().SetTo(to2);

slp2->

().SetTo(original_length2 - from2 - 1);

slp2->

().SetFrom(original_length2 - to2 - 1);

slp2->

().SetId(*id2);

slp2->

().SetStrand(strand2);

first_shift =

;

to1 =

(start1, original_length1) - 1;

(to2 >= original_length2) {

to2 = original_length2 - from2 - 1;

from2 = original_length2 - tmp_int - 1;

slp1->

().SetFrom(from1);

slp1->

().SetTo(to1);

slp1->

().SetId(*id1);

slp1->

().SetStrand(strand1);

slp2->

().SetFrom(from2);

slp2->

().SetTo(to2);

slp2->

().SetId(*id2);

slp2->

().SetStrand(strand2);

to1 =

(start1,original_length1) - 1;

(to2 >= original_length2) {

to2 = original_length2 -1;

to2 = original_length2 - from2 - 1;

from2 = original_length2 - tmp_int - 1;

slp1->

().SetFrom(from1);

slp1->

().SetTo(to1);

slp1->

().SetId(*id1);

slp1->

().SetStrand(strand1);

slp2->

().SetFrom(from2);

slp2->

().SetTo(to2);

slp2->

().SetId(*id2);

slp2->

().SetStrand(strand2);

first_shift =

;

(seq_int2_last) {

seq_int2_last->

(start2 - 1);

seq_int2_last->

(original_length2 - start2);

(seq_int2_last->

() > seq_int2_last->

()) {

seq_int2_last->

(seq_int2_last->

() + 3);

seq_int1_last->

() != 0)

seq_int1_last->

(seq_int1_last->

() + 1);

to2 =

(start2,original_length2) - 1;

to2 = original_length2 - from2 - 1;

from2 = original_length2 - tmp_int - 1;

slp2->

().SetFrom(from2);

slp2->

().SetTo(to2);

slp2->

().SetId(*id2);

seg->SetLoc().push_back(slp2);

seg->SetLoc().push_back(slp1);

seg->SetLoc().push_back(slp1);

seg->SetLoc().push_back(slp2);

ids.resize(seg->GetDim());

seqalign->

().SetStd().push_back(seg);

(

& ident_string,

d,

,

is_integer)

retval->SetId().SetStr(ident_string);

retval->SetValue().SetInt(

);

retval->SetValue().SetReal(d);

(hsp->

> 1) {

(evalue >= 0.0) {

( !seqid_list.empty() ) {

retval += seqid_list.size();

vector<string> & seqid_list,

(

);

kBlastScore(

);

(hsp->

> 1) {

kSumN(

);

(evalue >= 0.0) {

score_type = (hsp->

<= 1) ?

:

;

scores.push_back(

(score_type, evalue, 0,

));

kBitScore(

);

kNumIdent(

);

kCompAdj(

);

( !seqid_list.empty() ) {

(vector<string>, sid, seqid_list) {

scores.push_back(

(*sid, 0.0, 0,

));

kNumPositives(

);

(query_length > 0) {

kQueryCovHsp(

);

scores.push_back(

(kQueryCovHsp, hsp_coverage, 0,

));

vector<string> & seqid_list)

(seqid_list.empty())

userObject->

().SetStr(

);

userObject->

(

, seqid_list);

seqalign->

().push_back(userObject);

vector<string> & seqid_list,

query_length,

subject_length,

vector<string> & seqid_list)

ids.push_back(query_id);

ids.push_back(subject_id);

starts.push_back(query_length - hsp->

.

);

starts.push_back(subject_length - hsp->

.

);

query_length,

subject_length,

vector<string> & seqid_list)

query_loc->

().SetId(*query_id);

subject_loc->

().SetId(*subject_id);

ids.push_back(query_id);

ids.push_back(subject_id);

query_loc->

().SetFrom(query_length -

subject_loc->

().SetFrom(subject_length -

subject_loc->

().SetTo(subject_length -

retval->SetLoc().push_back(query_loc);

retval->SetLoc().push_back(subject_loc);

subject_length,

vector<string> & seqid_list,

vector<string> emptyList;

(index=0; index<hsp_list->

; index++) {

seqalign->

().SetDendiag().push_back(

(index=0; index<hsp_list->

; index++) {

seqalign->

().SetStd().push_back(

sa_vector.push_back(seqalign);

query_length,

subject_length,

is_ooframe,

vector<string> & seqid_list,

sa_vector.reserve(hsp_list->

);

vector<string> emptyList;

(

index = 0; index < hsp_list->

; index++) {

query_length, subject_length);

query_length, subject_length);

(seqalign.

())

;

sa_vector.push_back(seqalign);

retval->

().clear();

query_row = 0;

(

.IsInt()) {

q_shift =

.GetInt().GetFrom();

kSubjDimension = 1;

(

index = 0; index < hit_list->

; index++) {

kOid = hsp_list->

;

(subject_id.

()){

vector <TSeqRange> ranges;

(

=0;

<hsp_list->

;

++) {

ranges.push_back(rg);

(!ranges.empty() && seqinfo_src->

(kOid, ranges, masks)) {

subj_masks.push_back(masks);

vector<string> seqid_list;

vector<CRef<CSeq_align > > hit_align;

seq_aligns->

().push_back(*iter);

seq_aligns->

().push_back(*iter);

vector<TSeqLocInfoVector>& subj_masks)

(

pattern_index = 0; pattern_index <

->num_patterns;

(one_phi_results) {

*

.GetSeq_loc(0),

subj_masks[pattern_index]));

retval.push_back(seq_aligns);

*

.GetSeq_loc(0),

subj_masks[pattern_index]));

retval.push_back(seq_aligns);

(phi_results);

(

index = 0; index < hsp_list->

; index++) {

vector<TSeqLocInfoVector>& subj_masks)

vector<CRef<CSeq_align > > hit_align;

retval.reserve(

->num_queries);

(

qindex = 0; qindex <

->num_queries; qindex++) {

(sindex = 0; sindex < hit_list->

; ++sindex) {

(hsp_list->

==

(subj_idx))

vector<string> seqid_list;

vector <TSeqRange> ranges;

(

=0;

<hsp_list->

;

++) {

ranges.push_back(rg);

(!ranges.empty() &&

seqinfo_src.

(subj_idx, ranges, masks)) {

subj_masks[qindex].push_back(masks);

seq_aligns->

().push_back(*iter);

retval.push_back(seq_aligns);

num_queries,

num_subjects)

result_alnvec.reserve(alnvec.size());

(

iQuery = 0; iQuery < num_queries; iQuery++)

(

iSubject = 0; iSubject < num_subjects; iSubject++)

iLinearIndex = iSubject * num_queries + iQuery;

result_alnvec.push_back(aln_set);

(result_alnvec.size() == alnvec.size());

result_alnvec;

vector<TSeqLocInfoVector>& subj_masks)

seqinfo_size = seqinfo_src->

();

retval.reserve(query_data.

() * seqinfo_size);

num_of_queries =

->num_queries;

subj_masks.resize(num_of_queries *seqinfo_size);

(

index = 0; index < seqinfo_size; index++) {

vector<TSeqLocInfoVector> tmp_subj_masks(num_of_queries);

*seqinfo_src,

, index,

is_gapped, is_ooframe,

(TSeqAlignVector::size_type

= 0;

< seqalign.size(); ++

) {

retval.push_back(seqalign[

]);

subj_masks[ seqinfo_size *

+ index] = tmp_subj_masks[

];

vector<TSeqLocInfoVector>& subj_masks)

subj_masks.resize(

->num_queries);

retval.reserve(

->num_queries);

(

index = 0; index <

->num_queries; index++) {

*

.GetSeq_loc(index),

subj_masks[index]));

retval.push_back(seq_aligns);

(

<< index <<

<< seq_aligns->

().size()

vector<TSeqLocInfoVector>& subj_masks,

local_data, &seqinfo_src,

&seqinfo_src, gapped,

oof_mode, subj_masks);

query_length,

subject_length,

vector<string> & seqid_list)

query_loc->

().SetId(*query_id);

subject_loc->

().SetId(*subject_id);

ids.push_back(query_id);

ids.push_back(subject_id);

query_loc->

().SetFrom(query_length - hsp->

.

);

retval->SetLoc().push_back(query_loc);

retval->SetLoc().push_back(subject_loc);

vector<string> & ) =

;

(hsp_list->

> 0)

vector<string> seqid_list;

(

j = 0; j < hsp_list->

; j++)

seg_list.push_back((*fun_ptr) (hsp, query_id, subject_id,

query_length, subject_length, seqid_list));

CRef< CSeq_align > RemapAlignToLoc(const CSeq_align &align, CSeq_align::TDim row, const CSeq_loc &loc)

Remap seq-align row to the seq-loc.

Contains C++ wrapper classes to structures in algo/blast/core as well as some auxiliary functions to ...

#define sfree(x)

Safe free a pointer: belongs to a higher level header.

#define CODON_LENGTH

Codons are always of length 3.

void Blast_HSPListSortByEvalue(BlastHSPList *hsp_list)

Sort the HSPs in an HSP list by e-value, with scores and other criteria used to resolve ties.

BlastHSPResults ** PHIBlast_HSPResultsSplit(const BlastHSPResults *results, const SPHIQueryInfo *pattern_info)

Splits the BlastHSPResults structure for a PHI BLAST search into an array of BlastHSPResults structur...

double Blast_HSPGetQueryCoverage(const BlastHSP *hsp, Int4 query_length)

Calculate query coverage percentage of an hsp.

Boolean Blast_ProgramIsPhiBlast(EBlastProgramType p)

Returns true if program is PHI-BLAST (i.e.

Boolean Blast_QueryIsTranslated(EBlastProgramType p)

Returns true if the query is translated.

#define TRANSLATED_SUBJECT_MASK

This bit is on if the subject is translated.

EBlastProgramType

Defines the engine's notion of the different applications of the BLAST algorithm.

#define TRANSLATED_QUERY_MASK

This bit is on if the query is translated.

Utility function to convert internal BLAST result structures into objects::CSeq_align_set objects.

vector< CRef< objects::CSeq_align_set > > TSeqAlignVector

Vector of Seq-align-sets.

EResultType

Specifies the style of Seq-aligns that should be built from the internal BLAST data structures.

@ eSequenceComparison

Seq-aligns in the BLAST 2 Sequence style (one alignment per query-subject pair)

Wrapper class for BlastHSPResults .

void OffsetRow(TDim row, TSignedSeqPos offset)

Offset row's coords.

Seq-loc iterator class – iterates all intervals from a seq-loc in the correct order.

void Validate(bool full_test=false) const

Validators.

CUser_object & AddField(const string &label, const string &value, EParseField parse=eParse_String)

add a data field to the user object that holds a given value

Abstract base class to encapsulate retrieval of sequence identifiers.

Provides access (not ownership) to the C structures used to configure local BLAST search class implem...

Collection of masked regions for a single query sequence.

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

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

EGapAlignOpType

Operation types within the edit script.

@ eGapAlignDel2

Frame shift deletion of two nucleotides.

@ eGapAlignIns2

Frame shift insertion of two nucleotides.

@ eGapAlignIns1

Frame shift insertion of one nucleotide.

@ eGapAlignIns

Insertion: a gap in subject.

@ eGapAlignDel1

Frame shift deletion of one nucleotide.

@ eGapAlignDecline

Non-aligned region.

@ eGapAlignSub

Substitution.

@ eGapAlignDel

Deletion: a gap in query.

virtual CConstRef< objects::CSeq_loc > GetSeq_loc(size_t index)=0

Get the Seq_loc for the sequence indicated by index.

void BLASTPrelminSearchHitListToStdSeg(EBlastProgramType program, BlastHitList *hit_list, const CSeq_loc &query_loc, TSeqPos query_length, const IBlastSeqInfoSrc *subject_seqinfo, list< CRef< CStd_seg > > &seg_list)

CRef< CDense_diag > x_UngappedHSPToDenseDiag(BlastHSP *hsp, CRef< CSeq_id > query_id, CRef< CSeq_id > subject_id, Int4 query_length, Int4 subject_length, const vector< string > &seqid_list)

Creates a Dense-diag object from HSP information and sequence identifiers for a non-translated ungapp...

static CSeq_align::C_Segs::TStd s_CreateStdSegs(CRef< CSeq_id > master, CRef< CSeq_id > slave, CDense_seg::TStarts &starts, CDense_seg::TLens &lengths, CDense_seg::TStrands &strands, bool translate_master, bool translate_slave)

Creates a Std-seg object from the starts, lengths and strands vectors and two Seq-ids for a translate...

virtual CConstRef< objects::CSeq_loc > GetSeqLoc(Uint4 index) const =0

Method to retrieve the sequence location given its ordinal number.

static int s_GetCurrPos(int &pos, int pos2advance)

Advances position in a sequence, according to an edit script instruction.

static const TSeqPos kBlastAlignmentDim

BLAST alignments have always 2 dimensions (i.e.

static void s_CollectSeqAlignData(const BlastHSP *hsp, const GapEditScript *esp, unsigned int first, unsigned int nsegs, CDense_seg::TStarts &starts, CDense_seg::TLens &lengths, CDense_seg::TStrands &strands, Int4 query_length, Int4 subject_length, bool translate1, bool translate2)

Fills vectors of start positions, lengths and strands for all alignment segments.

static void s_CorrectUASequence(BlastHSP *hsp)

Checks if any decline-to-align segments immediately follow an insertion or deletion,...

#define SMALLEST_EVALUE

Threshold below which e-values are saved as 0.

static CRef< CSeq_align > s_BlastHSP2SeqAlign(EBlastProgramType program, BlastHSP *hsp, CRef< CSeq_id > id1, CRef< CSeq_id > id2, Int4 query_length, Int4 subject_length)

Converts a traceback editing block to a Seq-align, provided the 2 sequence identifiers.

static void s_CreateDenseg(CDense_seg &dense_seg, CRef< CSeq_id > master, CRef< CSeq_id > slave, CDense_seg::TStarts &starts, CDense_seg::TLens &lengths, CDense_seg::TStrands &strands)

Creates a Dense-seg object from the starts, lengths and strands vectors and two Seq-ids.

const char BLASTNA_TO_IUPACNA[]

Translates between blastna and iupacna.

void GetFilteredRedundantSeqids(const IBlastSeqInfoSrc &sisrc, int oid, vector< string > &seqids, bool use_gis=true)

Get Seqids for a sequence in a redundant database.

static size_t s_CalculateScoreVectorSize(const BlastHSP *hsp, const vector< string > &seqid_list)

Computes the exact size of a CSeq_align::TScore for a given HSP.

static TSeqPos s_GetAlignmentStart(int &curr_pos, int num, ENa_strand strand, bool translate, int length, int original_length, short frame)

Finds the starting position of a sequence segment in an alignment, given an editing script.

static CRef< CScore > s_MakeScore(const string &ident_string, double d, int i, bool is_integer)

Creates and initializes CScore with a given name, and with integer or double value.

CRef< CSeq_align_set > BlastHitList2SeqAlign_OMF(const BlastHitList *hit_list, EBlastProgramType prog, const CSeq_loc &query_loc, TSeqPos query_length, const IBlastSeqInfoSrc *seqinfo_src, bool is_gapped, bool is_ooframe, TSeqLocInfoVector &subj_masks)

static Int4 s_GetProteinFrameLength(Int4 nuc_length, Int2 frame)

Finds length of a protein frame given a nucleotide length and a frame number.

static TSeqAlignVector s_BLAST_OneSubjectResults2CSeqAlign(const BlastHSPResults *results, ILocalQueryData &query_data, const IBlastSeqInfoSrc &seqinfo_src, EBlastProgramType prog, Uint4 subj_idx, bool is_gapped, bool is_ooframe, vector< TSeqLocInfoVector > &subj_masks)

Extracts results from the BlastHSPResults structure for only one subject sequence,...

CRef< CStd_seg > x_NonTranslatedHSPToStdSeg(BlastHSP *hsp, CRef< CSeq_id > query_id, CRef< CSeq_id > subject_id, Int4 query_length, Int4 subject_length, const vector< string > &seqid_list)

Creates a Std-seg object from HSP information and sequence identifiers for a non-translated ungapped ...

static void s_AddUserObjectToSeqAlign(CRef< CSeq_align > &seqalign, const vector< string > &seqid_list)

Produce UserObject with Seq-ids to limit formatting to ("use_this_gi")

virtual BlastQueryInfo * GetQueryInfo()=0

Accessor for the BlastQueryInfo structure.

static ENa_strand s_Frame2Strand(short frame)

Converts a frame into the appropriate strand.

TSeqAlignVector PhiBlastResults2SeqAlign_OMF(const BlastHSPResults *results, EBlastProgramType prog, class ILocalQueryData &query, const IBlastSeqInfoSrc *seqinfo_src, const SPHIQueryInfo *pattern_info, vector< TSeqLocInfoVector > &subj_masks)

static TSeqAlignVector s_BlastResults2SeqAlignDatabaseSearch_OMF(const BlastHSPResults *results, EBlastProgramType prog, class ILocalQueryData &query, const IBlastSeqInfoSrc *seqinfo_src, bool is_gapped, bool is_ooframe, vector< TSeqLocInfoVector > &subj_masks)

#define GAP_VALUE

Value in the Dense-seg indicating a gap.

static CRef< CSeq_align > s_CreateSeqAlign(CRef< CSeq_id > master, CRef< CSeq_id > slave, CDense_seg::TStarts starts, CDense_seg::TLens lengths, CDense_seg::TStrands strands, bool translate_master, bool translate_slave)

Creates a Seq-align for a single HSP from precalculated vectors of start positions,...

static void s_ValidateExon(const CSpliced_exon &exon, const CSeq_id &product_id, const CSeq_id &genomic_id)

virtual size_t GetNumQueries()=0

Get the number of queries.

static void s_RemapToSubjectLoc(CRef< CSeq_align > &subj_aligns, const CSeq_loc &subj_loc)

Remap subject alignment if its location specified the reverse strand or a starting location other tha...

TSeqAlignVector LocalBlastResults2SeqAlign(BlastHSPResults *hsp_results, ILocalQueryData &local_data, const IBlastSeqInfoSrc &seqinfo_src, EBlastProgramType program, bool gapped, bool oof_mode, vector< TSeqLocInfoVector > &subj_masks, EResultType result_type)

Convert traceback output into Seq-align format.

CRef< CSeq_align_set > CreateEmptySeq_align_set()

Constructs an empty Seq-align-set containing an empty discontinuous seq-align, and appends it to a pr...

void BLASTHspListToSeqAlign(EBlastProgramType program, BlastHSPList *hsp_list, CRef< CSeq_id > query_id, CRef< CSeq_id > subject_id, Int4 query_length, Int4 subject_length, bool is_ooframe, const vector< string > &seqid_list, vector< CRef< CSeq_align > > &sa_vector)

This is called for each query and each subject in a BLAST search.

virtual size_t Size() const =0

Returns the size of the underlying container of sequences.

void MakeSplicedSeg(CSpliced_seg &spliced_seg, CRef< CSeq_id > product_id, CRef< CSeq_id > genomic_id, int product_length, const HSPChain *chain)

Convert a spliced alignmeny in BlastHSPChain into Spliced_seg.

virtual size_t GetSeqLength(size_t index)=0

Get the length of the sequence indicated by index.

void BLASTUngappedHspListToSeqAlign(EBlastProgramType program, BlastHSPList *hsp_list, CRef< CSeq_id > query_id, CRef< CSeq_id > subject_id, Int4 query_length, Int4 subject_length, const vector< string > &seqid_list, vector< CRef< CSeq_align > > &sa_vector)

Creates a Seq-align from an HSP list for an ungapped search.

CRef< CStd_seg > x_UngappedHSPToStdSeg(BlastHSP *hsp, CRef< CSeq_id > query_id, CRef< CSeq_id > subject_id, Int4 query_length, Int4 subject_length, const vector< string > &seqid_list)

Creates a Std-seg object from HSP information and sequence identifiers for a translated ungapped sear...

void RemapToQueryLoc(CRef< CSeq_align > sar, const CSeq_loc &query)

Remaps Seq-align offsets relative to the query Seq-loc.

virtual bool CanReturnPartialSequence() const =0

Return true if the implementation can return anything besides a seq-loc for the entire sequence.

static TSeqAlignVector s_BlastResults2SeqAlignSequenceCmp_OMF(const BlastHSPResults *results, EBlastProgramType prog, class ILocalQueryData &query_data, const IBlastSeqInfoSrc *seqinfo_src, bool is_gapped, bool is_ooframe, vector< TSeqLocInfoVector > &subj_masks)

static void s_AddScoresToSeqAlign(CRef< CSeq_align > &seqalign, const BlastHSP *hsp, const vector< string > &seqid_list, Int4 query_length)

Given an HSP structure, creates a list of scores and inserts them into a Seq-align.

static void s_BuildScoreList(const BlastHSP *hsp, CSeq_align::TScore &scores, const vector< string > &seqid_list, Int4 query_length)

Creates a list of score objects for a Seq-align, given an HSP structure.

void GetSequenceLengthAndId(const IBlastSeqInfoSrc *seqinfo_src, int oid, CRef< objects::CSeq_id > &seqid, TSeqPos *length)

Retrieves subject sequence Seq-id and length.

static void s_AdjustNegativeSubjFrameInBlastn(ENa_strand subj_strand, EBlastProgramType program, BlastHSPList *hsp_list)

This function changes the subject frame for HSPs if the program is blastn and the subject was specifi...

virtual bool GetMasks(Uint4 index, const TSeqRange &target_range, TMaskedSubjRegions &retval) const =0

Retrieves the subject masks for the corresponding index.

static TSeqAlignVector s_TransposeSeqAlignVector(const TSeqAlignVector &alnvec, const size_t num_queries, const size_t num_subjects)

Transpose the (linearly organized) seqalign set matrix from (q1 s1 q2 s1 ...

static CRef< CSeq_align > s_OOFBlastHSP2SeqAlign(EBlastProgramType program, BlastHSP *hsp, CRef< CSeq_id > query_id, CRef< CSeq_id > subject_id, Int4 query_length, Int4 subject_length)

This function is used for out-of-frame traceback conversion Converts an OOF editing script chain to a...

unsigned int TSeqPos

Type for sequence locations and lengths.

#define ITERATE(Type, Var, Cont)

ITERATE macro to sequence through container elements.

int TSignedSeqPos

Type for signed sequence position.

#define NON_CONST_ITERATE(Type, Var, Cont)

Non constant version of ITERATE macro.

#define LOG_POST(message)

This macro is deprecated and it's strongly recomended to move in all projects (except tests) to macro...

void Info(CExceptionArgs_Base &args)

C & SerialAssign(C &dest, const C &src, ESerialRecursionMode how=eRecursive)

Set object to copy of another one.

const string AsFastaString(void) const

const CSeq_id * GetId(void) const

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

TObjectType * GetPointer(void) THROWS_NONE

Get pointer,.

void Reset(void)

Reset reference object.

bool Empty(void) const THROWS_NONE

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

uint8_t Uint1

1-byte (8-bit) unsigned integer

int16_t Int2

2-byte (16-bit) signed integer

int32_t Int4

4-byte (32-bit) signed integer

uint32_t Uint4

4-byte (32-bit) unsigned integer

#define END_NCBI_SCOPE

End previously defined NCBI scope.

#define USING_SCOPE(ns)

Use the specified namespace.

#define END_SCOPE(ns)

End the previously defined scope.

#define BEGIN_NCBI_SCOPE

Define ncbi namespace.

#define BEGIN_SCOPE(ns)

Define a new scope.

static string UIntToString(unsigned int value, TNumToStringFlags flags=0, int base=10)

Convert UInt to string.

void SetFrom(TFrom value)

Assign a value to From data member.

void SetTo(TTo value)

Assign a value to To data member.

void SetType(TType &value)

Assign a value to Type data member.

Tdata & Set(void)

Assign a value to data member.

TScore & SetScore(void)

Assign a value to Score data member.

TLens & SetLens(void)

Assign a value to Lens data member.

vector< CRef< CScore > > TScore

list< CRef< CStd_seg > > TStd

void SetProduct_id(TProduct_id &value)

Assign a value to Product_id data member.

TGenomic_start GetGenomic_start(void) const

Get the Genomic_start member data.

void SetSegs(TSegs &value)

Assign a value to Segs data member.

vector< ENa_strand > TStrands

TExons & SetExons(void)

Assign a value to Exons data member.

void SetProduct_length(TProduct_length value)

Assign a value to Product_length data member.

void SetDim(TDim value)

Assign a value to Dim data member.

vector< TSignedSeqPos > TStarts

void SetDim(TDim value)

Assign a value to Dim data member.

vector< TSeqPos > TStarts

void SetType(TType value)

Assign a value to Type data member.

vector< CRef< CSeq_id > > TIds

const TParts & GetParts(void) const

Get the Parts member data.

const TProduct_start & GetProduct_start(void) const

Get the Product_start member data.

vector< CRef< CSeq_id > > TIds

const TProduct_end & GetProduct_end(void) const

Get the Product_end member data.

vector< CRef< CSeq_id > > TIds

TExt & SetExt(void)

Assign a value to Ext data member.

TStarts & SetStarts(void)

Assign a value to Starts data member.

void SetProduct_type(TProduct_type value)

Assign a value to Product_type data member.

TStrands & SetStrands(void)

Assign a value to Strands data member.

list< CRef< CSpliced_exon > > TExons

vector< ENa_strand > TStrands

void SetGenomic_id(TGenomic_id &value)

Assign a value to Genomic_id data member.

void SetNumseg(TNumseg value)

Assign a value to Numseg data member.

TGenomic_end GetGenomic_end(void) const

Get the Genomic_end member data.

TIds & SetIds(void)

Assign a value to Ids data member.

TNucpos GetNucpos(void) const

Get the variant data.

const Tdata & Get(void) const

Get the member data.

@ e_Product_ins

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

@ 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

@ eType_partial

mapping pieces together

@ eType_diags

unbroken, but not ordered, diagonals

@ eProduct_type_transcript

void SetTo(TTo value)

Assign a value to To data member.

ENa_strand

strand of nucleic acid

TFrom GetFrom(void) const

Get the From member data.

void SetFrom(TFrom value)

Assign a value to From data member.

bool IsGi(void) const

Check if variant Gi is selected.

TTo GetTo(void) const

Get the To member data.

bool IsWhole(void) const

Check if variant Whole is selected.

bool IsInt(void) const

Check if variant Int is selected.

unsigned int

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

#define MAPPER_SPLICE_SIGNAL

if(yy_accept[yy_current_state])

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

#define MIN(a, b)

returns smaller of a and b.

Uint1 Boolean

bool replacment for C

#define TRUE

bool replacment for C indicating true.

#define FALSE

bool replacment for C indicating false.

#define ABS(a)

returns absolute value of a (|a|)

#define MAX(a, b)

returns larger of a and b.

static int pattern_info(int what, void *where, BOOL unsetok)

NOTE: This file contains work in progress and the APIs are likely to change, please do not rely on th...

vector< TMaskedQueryRegions > TSeqLocInfoVector

Collection of masked regions for all queries in a BLAST search.

static const char * kScore

The structure to hold all HSPs for a given sequence after the gapped alignment.

Int4 oid

The ordinal id of the subject sequence this HSP list is for.

Int4 hspcnt

Number of HSPs saved.

BlastHSP ** hsp_array

Array of pointers to individual HSPs.

Uint1 left_edge

Two subject bases before the alignment in the four least significant bits and flags in most significa...

The structure to contain all BLAST results, for multiple queries.

BlastHitList ** hitlist_array

Array of results for individual query sequences.

Structure holding all information about an HSP.

double evalue

This HSP's e-value.

Int4 num_ident

Number of identical base pairs in this HSP.

BlastSeg query

Query sequence info.

double bit_score

Bit score, calculated from score.

Int4 num

How many HSP's are linked together for sum statistics evaluation? If unset (0), this HSP is not part ...

BlastSeg subject

Subject sequence info.

GapEditScript * gap_info

ALL gapped alignment is here.

Int2 comp_adjustment_method

which mode of composition adjustment was used; relevant only for blastp and tblastn

Int4 score

This HSP's raw score.

BlastHSPMappingInfo * map_info

The structure to contain all BLAST results for one query sequence.

BlastHSPList ** hsplist_array

Array of HSP lists for individual database hits.

Int4 hsplist_count

Filled size of the HSP lists array.

The query related information.

struct SPHIQueryInfo * pattern_info

Counts of PHI BLAST pattern occurrences, used in PHI BLAST only.

Int2 frame

Translation frame.

Int4 offset

Start of hsp.

Edit script: linked list of correspondencies between two sequences.

Int4 * num

Array of number of operations.

Int4 size

Size of above arrays.

EGapAlignOpType * op_type

Array of type of operation.

A chain of HSPs: spliced alignment.

HSPContainer * hsps

A list of HSPs that belong to this chain.

struct HSPContainer * next

Uint1 query_base

Query base at this position.

Uint1 subject_base

Subject base at this position.

Int4 query_pos

Query position.

Alignment edit script for gapped alignment.

In PHI BLAST, structure containing information about all pattern occurrences in query.

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

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4