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

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

NCBI C++ ToolKit: src/algo/blast/core/link_hsps.c Source File

context1, context2;

(context1 < context2)

(context1 > context2)

context1, context2;

(context1 < context2)

(context1 > context2)

context1, context2;

(context1 < context2)

(context1 > context2)

memset(hsp, 0,

(

));

*

,* H2,* best[2],* first_hsp,* last_hsp,** hp_frame_start;

maxscore, cutoff[2];

linked_set, ignore_small_gaps;

gap_decay_rate, gap_prob,

[2];

index, index1, num_links, frame_index;

num_query_frames, num_subject_frames;

*hp_frame_number;

number_of_hsps, total_number_of_hsps;

query_length, length_adjustment;

subject_length_orig = subject_length;

H2_index,H_index;

first_pass, use_current_max;

(hsp_list ==

)

lh_helper_size =

(1024,hsp_list->

+5);

(gapped_calculation)

total_number_of_hsps = hsp_list->

;

number_of_hsps = total_number_of_hsps;

gap_prob = link_hsp_params->

;

num_subject_frames = 1;

(index = 0; index < total_number_of_hsps; ++index) {

link_hsp_array[index]->

= hsp_array[index];

(kTranslatedQuery) {

qsort(link_hsp_array,total_number_of_hsps,

(

*),

qsort(link_hsp_array,total_number_of_hsps,

(

*),

ignore_small_gaps = (cutoff[0] == 0);

hp_frame_number =

(num_subject_frames*num_query_frames,

(

));

hp_frame_start[0] = link_hsp_array[0];

strand_factor = (kTranslatedQuery ? 3 : 1);

(index=0;index<number_of_hsps;index++)

=link_hsp_array[index];

->start_of_chain =

;

hp_frame_number[cur_frame]++;

->prev= index ? link_hsp_array[index-1] :

;

->next= index<(number_of_hsps-1) ? link_hsp_array[index+1] :

;

(

->prev !=

&&

((

->hsp->context/strand_factor) !=

(

->prev->hsp->context/strand_factor) ||

(

(

->hsp->subject.frame) !=

(

->prev->hsp->subject.frame))))

hp_frame_number[cur_frame]--;

hp_frame_number[++cur_frame]++;

hp_frame_start[cur_frame] =

;

->prev->next =

;

num_query_frames = cur_frame+1;

(index=0;index<number_of_hsps;index++)

q_length, s_length;

= link_hsp_array[index];

->q_end_trim = hsp->

.

-

(q_length, trim_size);

(frame_index=0; frame_index<num_query_frames; frame_index++)

hp_start->

= hp_frame_start[frame_index];

hp_frame_start[frame_index]->

= hp_start;

number_of_hsps = hp_frame_number[frame_index];

query_length =

(query_length - length_adjustment, 1);

subject_length = subject_length_orig;

subject_length =

(subject_length - length_adjustment, 1);

lh_helper[0].

= hp_start;

lh_helper[0].

= -10000;

->hsp_link.changed=1;

(number_of_hsps > 0)

best[0] = best[1] =

;

(!ignore_small_gaps){

sum0=

->hsp_link.sum[0];

sum1=

->hsp_link.sum[1];

maxscore = -cutoff[1];

sum=

->hsp_link.sum[1];

(path_changed==0){

(!ignore_small_gaps){

(

=best[0];

!=

;

=

->hsp_link.link[0])

(

->linked_to==-1000) {use_current_max=0;

;}

(

=best[1];

!=

;

=

->hsp_link.link[1])

(

->linked_to==-1000) {use_current_max=0;

;}

(!use_current_max){

(

=hp_start,H_index=1;

!=

;

=

->next,H_index++) {

s_frame =

->hsp->subject.frame;

s_off_t =

->s_offset_trim;

q_off_t =

->q_offset_trim;

lh_helper[H_index].

=

;

lh_helper[H_index].sum[

] =

->hsp_link.sum[

];

(

[

(s_frame)+1],

->hsp_link.sum[1]);

cur_sum=lh_helper[H_index].

[1];

((cur_sum>=prev_sum) && (

>0)){

prev_sum = lh_helper[

].

[1];

lh_helper[1].

= -10000;

(!ignore_small_gaps)

maxscore = -cutoff[index];

(

=hp_start->

;

!=

;

=

->next,H_index++)

H_hsp_xsum=0.0;

(

->hsp->score > cutoff[index]) {

H_query_etrim =

->q_end_trim;

H_sub_etrim =

->s_end_trim;

(H2_index=H_index-1; H2_index>1; H2_index=H2_index-1)

q_off_t,s_off_t,sum;

b1 = q_off_t <= H_query_etrim;

b2 = s_off_t <= H_sub_etrim;

sum = lh_helper[H2_index].

[index];

b4 = ( q_off_t > H_q_et_gap ) ;

b5 = ( s_off_t > H_s_et_gap ) ;

(q_off_t > (H_q_et_gap+trim_size))

(b1|b2|b5|b4)

;

H2=lh_helper[H2_index].

;

score=

->hsp->score;

H_hsp_xsum + score*kbp[

->hsp->context]->

-

kbp[

->hsp->context]->

;

new_sum = H_hsp_sum + (score - cutoff[index]);

->hsp_link.sum[index] = new_sum;

->hsp_link.num[index] = H_hsp_num+1;

->hsp_link.link[index] = H_hsp_link;

lh_helper[H_index].

[index] = new_sum;

(new_sum >= maxscore)

->hsp_link.xsum[index] = new_xsum;

maxscore = -cutoff[index];

(

=hp_start->

;

!=

;

=

->next,H_index++)

H_hsp_xsum=0.0;

->hsp_link.changed=1;

H2 =

->hsp_link.link[index];

->hsp_link.changed=0;

}

(

->hsp->score > cutoff[index]) {

H_query_etrim =

->q_end_trim;

H_sub_etrim =

->s_end_trim;

(!first_pass&&H2&&H2->

>=0){

(H2_index=H_index-1; H2_index>1;)

q_off_t,s_off_t,sum,next_larger;

sum = H2_helper->

[index];

b0 = sum <= H_hsp_sum;

H2_index=next_larger;

b1 = q_off_t <= H_query_etrim;

b2 = s_off_t <= H_sub_etrim;

(0)

(H2_helper->

<=H_hsp_sum)

;

H2 = H2_helper->

;

score=

->hsp->score;

H_hsp_xsum + score*kbp[

->hsp->context]->

-

kbp[

->hsp->context]->

;

new_sum = H_hsp_sum + (score - cutoff[index]);

->hsp_link.sum[index] = new_sum;

->hsp_link.num[index] = H_hsp_num+1;

->hsp_link.link[index] = H_hsp_link;

lh_helper[H_index].

[index] = new_sum;

lh_helper[H_index].

=

(lh_helper[H_index-1].maxsum1, new_sum);

cur_sum=lh_helper[H_index].

[1];

((cur_sum>=prev_sum) && (

>0)){

prev_sum = lh_helper[

].

[1];

(new_sum >= maxscore)

->hsp_link.xsum[index] = new_xsum;

(!ignore_small_gaps)

best[0]->hsp_link.num[0], best[0]->

.

[0],

query_length, subject_length,

best[0]->hsp_link.num[0]) );

( best[0]->hsp_link.num[0] > 1 ) {

( gap_prob == 0 || (

[0] /= gap_prob) >

) {

query_length, subject_length,

best[1]->hsp_link.num[1]));

( best[1]->hsp_link.num[1] > 1 ) {

( 1 - gap_prob == 0 || (

[1] /= 1 - gap_prob) >

) {

best[1]->hsp_link.num[1],

query_length, subject_length,

best[1]->hsp_link.num[1]));

best[ordering_method]->

->

=

[ordering_method];

(best[ordering_method]->hsp_link.link[ordering_method])

(best[ordering_method]->linked_to>0) path_changed=1;

(

=best[ordering_method];

!=

;

=

->hsp_link.link[ordering_method])

(

->linked_to>1) path_changed=1;

->hsp_link.changed=1;

->linked_set = linked_set;

->ordering_method = ordering_method;

->hsp->evalue =

[ordering_method];

(

->next)->

=

->prev;

(

->prev)->

=

->next;

(hp_frame_start);

(hp_frame_number);

(kTranslatedQuery) {

qsort(link_hsp_array,total_number_of_hsps,

(

*),

qsort(link_hsp_array, total_number_of_hsps,

(

*),

qsort(link_hsp_array,total_number_of_hsps,

(

*),

qsort(link_hsp_array, total_number_of_hsps,

(

*),

(index=0, last_hsp=

;index<total_number_of_hsps; index++)

= link_hsp_array[index];

(index=0, last_hsp=

;index<total_number_of_hsps; index++)

= link_hsp_array[index];

(

->linked_set ==

&&

->start_of_chain ==

)

(last_hsp ==

)

->prev = last_hsp;

ordering_method =

->ordering_method;

(

->hsp_link.link[ordering_method] ==

)

H2 = index1<(total_number_of_hsps-1) ? link_hsp_array[index1+1] :

;

H2 = index1<(total_number_of_hsps-1) ? link_hsp_array[index1+1] :

;

num_links =

->hsp_link.num[ordering_method];

link =

->hsp_link.link[ordering_method];

->hsp->num = num_links;

->xsum =

->hsp_link.xsum[ordering_method];

->prev = last_hsp;

link =

->hsp_link.link[ordering_method];

->hsp->num = num_links;

->xsum =

->hsp_link.xsum[ordering_method];

H2 = index1<(total_number_of_hsps-1) ? link_hsp_array[index1+1] :

;

H2 = index1<(total_number_of_hsps-1) ? link_hsp_array[index1+1] :

;

->prev = last_hsp;

(index = 0,

= first_hsp; index < hsp_list->

; index++) {

(link_hsp_array);

gap_decay_rate, sum_evalue;

subject_eff_length, query_eff_length, len_adj;

query_window_size;

subject_window_size;

subject_length/3 : subject_length;

subject_eff_length =

(subject_eff_length - len_adj, 1);

subject_window_size =

num, *

, query_eff_length, subject_eff_length,

((*hp1)->queryId != (*hp2)->queryId)

(*hp1)->queryId - (*hp2)->queryId;

index, begin, end;

(begin < end) {

index = (begin + end) / 2;

(begin < end) {

right_index = (begin + end) / 2;

left_index = qend_index_array[right_index];

begin = right_index + 1;

begin = right_index + 1;

(hsp_set1->

)

hsp_set1 = hsp_set1->

;

(hsp_set2->

)

hsp_set2 = hsp_set2->

;

*merged_size = length = hsp_set1->

->

+ hsp_set2->

->

;

(hsp_set1 || hsp_set2) {

(!hsp_set2 || (hsp_set1 &&

merged_hsps[index] = hsp_set1;

hsp_set1 = hsp_set1->

;

merged_hsps[index] = hsp_set2;

hsp_set2 = hsp_set2->

;

index, new_num;

head_hsp = merged_hsps[0];

(index = 0; index < new_num; ++index) {

(index < new_num - 1) {

link->

= next_link;

next_link->

= link;

link->

->

= new_num;

(merged_hsps);

gap_s, gap_q, overlap;

combined_size = 0;

(!hsp_set1 || !hsp_set2 || !link_hsp_params)

(hsp_set1->

)

( ; hsp_set2->

; hsp_set2 = hsp_set2->

);

(hsp_set1 == hsp_set2)

gap_q = link_hsp_params->

;

gap_s = link_hsp_params->

;

(index = 0; index < combined_size - 1; ++index) {

(merged_hsps);

(index < combined_size - 1)

(index = 0; index < hspcnt; ++index) {

link_hsp_array[index] =

link_hsp_array[index]->

=

;

link_hsp_array[index]->

=

hsp_array[index]->

= 1;

link_hsp_array;

(index = 0; index < hspcnt; ++index)

(link_hsp_array[index]);

(link_hsp_array);

** qend_index_ptr)

current_end = 0;

current_index = 0;

*qend_index_ptr = qend_index_array = (

*)

(hspcnt,

(

));

(!qend_index_array)

(index = 1; index < hspcnt; ++index) {

link = hsp_array[index];

current_index = index;

qend_index_array[index] = current_index;

hspcnt, index, index1;

(!link_hsp_params || !sbp || !query_info)

(!hsp_list || hsp_list->

<= 1)

(gapped_calculation) {

kbp_array = sbp->

;

hspcnt = hsp_list->

;

memcpy(offset_hsp_array, link_hsp_array, hspcnt*

(

*));

(index = 0; index < hspcnt && score_hsp_array[index]; ) {

best_evalue, best_sum_score = 0;

hsp_index_left, hsp_index_right;

(index<hspcnt && score_hsp_array[index] &&

(score_hsp_array[index]->

||

score_hsp_array[index]->

))

head_hsp = score_hsp_array[index];

(tail_hsp = head_hsp; tail_hsp->

; tail_hsp = tail_hsp->

);

best_evalue = head_hsp->

->

;

head_hsp->

, left_offset);

(index1 = hsp_index_left; index1 < hsp_index_right; ++index1) {

link_hsp_params, program)) {

((evalue =

(program, query_info, subject_length,

link_hsp_params, head_hsp, lhsp,

best_evalue = evalue;

(score_hsp_array);

(offset_hsp_array);

(qend_index_array);

(!hsp_list || hsp_list->

== 0)

(link_hsp_params);

(index = 0; index < hsp_list->

; ++index)

subject_length, sbp, link_hsp_params,

gapped_calculation);

hsp_list, gapped_calculation,

,sbp,

subject_length, sbp, link_hsp_params,

gapped_calculation);

(index = 1; index < hsp_list->

; ++index) {

#define sfree(x)

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

#define CODON_LENGTH

Codons are always of length 3.

#define NUM_STRANDS

Number of frames in a nucleotide sequence.

#define NUM_FRAMES

Number of frames to which we translate in translating searches.

int ScoreCompareHSPs(const void *h1, const void *h2)

Comparison callback function for sorting HSPs, first by score in descending order,...

Int2 Blast_HSPListGetEvalues(EBlastProgramType program_number, const BlastQueryInfo *query_info, Int4 subject_length, BlastHSPList *hsp_list, Boolean gapped_calculation, Boolean RPS_prelim, const BlastScoreBlk *sbp, double gap_decay_rate, double scaling_factor)

Calculate the expected values for all HSPs in a hit list, without using the sum statistics.

void Blast_HSPListAdjustOddBlastnScores(BlastHSPList *hsp_list, Boolean gapped_calculation, const BlastScoreBlk *sbp)

For nucleotide BLAST, if the match reward score is equal to 2, random alignments are dominated by run...

void Blast_HSPListSortByScore(BlastHSPList *hsp_list)

Sort the HSPs in an HSP list by score.

Utilities for dealing with BLAST HSPs in the core of BLAST.

Boolean Blast_QueryIsTranslated(EBlastProgramType p)

Returns true if the query is translated.

Boolean Blast_QueryIsNucleotide(EBlastProgramType p)

Returns true if the query is nucleotide.

EBlastProgramType

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

Boolean Blast_SubjectIsTranslated(EBlastProgramType p)

Returns true if the subject is translated.

double BLAST_GapDecayDivisor(double decayrate, unsigned nsegs)

Compute a divisor used to weight the evalue of a collection of "nsegs" distinct alignments.

double BLAST_LargeGapSumE(Int2 num, double xsum, Int4 query_length, Int4 subject_length, Int8 searchsp_eff, double weight_divisor)

Calculates the e-value if a collection of distinct alignments with arbitrarily large gaps between the...

double BLAST_UnevenGapSumE(Int4 query_start_points, Int4 subject_start_points, Int2 num, double xsum, Int4 query_length, Int4 subject_length, Int8 searchsp_eff, double weight_divisor)

Calculates the e-value of a collection multiple distinct alignments with asymmetric gaps between the ...

double BLAST_SmallGapSumE(Int4 start_points, Int2 num, double xsum, Int4 query_length, Int4 subject_length, Int8 searchsp_eff, double weight_divisor)

Calculates the e-value for alignments with "small" gaps (typically under fifty residues/basepairs) fo...

Various auxiliary BLAST utility functions.

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

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

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

if(yy_accept[yy_current_state])

static int s_RevCompareHSPsTransl(const void *v1, const void *v2)

Like s_RevCompareHSPs, except with additional logic to distinguish HSPs that lie within different str...

struct LinkHelpStruct LinkHelpStruct

The helper array contains the info used frequently in the inner for loops of the HSP linking algorith...

static Int2 s_BlastUnevenGapLinkHSPs(EBlastProgramType program, BlastHSPList *hsp_list, const BlastQueryInfo *query_info, Int4 subject_length, const BlastScoreBlk *sbp, const BlastLinkHSPParameters *link_hsp_params, Boolean gapped_calculation)

Greedy algorithm to link HSPs with uneven gaps.

static Int2 s_BlastEvenGapLinkHSPs(EBlastProgramType program_number, BlastHSPList *hsp_list, const BlastQueryInfo *query_info, Int4 subject_length, const BlastScoreBlk *sbp, const BlastLinkHSPParameters *link_hsp_params, Boolean gapped_calculation)

Perform even gap linking on a list of HSPs.

struct BlastLinkedHSPSet BlastLinkedHSPSet

Simple doubly linked list of HSPs, used for calculating sum statistics.

static int s_FwdCompareHSPsTransl(const void *v1, const void *v2)

Like s_FwdCompareHSPs, except with additional logic to distinguish HSPs that lie within different str...

static int s_FwdCompareLinkedHSPSets(const void *v1, const void *v2)

Callback for sorting an array of HSPs, encapsulated in BlastLinkedHSPSet structures,...

Int2 BLAST_LinkHsps(EBlastProgramType program_number, BlastHSPList *hsp_list, const BlastQueryInfo *query_info, Int4 subject_length, const BlastScoreBlk *sbp, const BlastLinkHSPParameters *link_hsp_params, Boolean gapped_calculation)

Link HSPs using sum statistics.

static int s_FwdCompareHSPs(const void *v1, const void *v2)

Callback used by qsort to sort a list of HSPs, encapsulated in LinkHSPStruct structures,...

static BlastLinkedHSPSet ** s_LinkedHSPSetArrayCleanUp(BlastLinkedHSPSet **link_hsp_array, Int4 hspcnt)

Frees the array of special structures, used for linking HSPs and restores the original contexts and s...

static int s_RevCompareHSPs(const void *v1, const void *v2)

Callback used by qsort to sort a list of HSPs (encapsulated in LinkHSPStruct structures) in order of ...

static int s_SumScoreCompareLinkedHSPSets(const void *v1, const void *v2)

Callback used by qsort to sort a list of BlastLinkedHSPSet structures in order of decreasing sum scor...

ELinkOrderingMethod

Describes the method for ordering HSPs.

@ eLinkSmallGaps

favor small gaps when linking an HSP

@ eOrderingMethods

number of methods (last in list)

@ eLinkLargeGaps

favor large gaps when linking an HSP

static Int4 s_HSPOffsetBinarySearch(BlastLinkedHSPSet **hsp_array, Int4 size, Uint4 queryId, Int4 offset)

Find an HSP on the same queryId as the one given, with closest start offset that is greater than a sp...

static int s_RevCompareHSPsTbn(const void *v1, const void *v2)

Callback used by qsort to sort a list of HSPs (encapsulated in LinkHSPStruct structures) in order of ...

static BlastLinkedHSPSet ** s_MergeLinkedHSPSets(BlastLinkedHSPSet *hsp_set1, BlastLinkedHSPSet *hsp_set2, Int4 *merged_size)

Merges HSPs from two linked HSP sets into an array of HSPs, sorted in increasing order of contexts an...

static int s_RevCompareHSPsTbx(const void *v1, const void *v2)

Callback used by qsort to sort a list of HSPs (encapsulated in LinkHSPStruct structures) in order of ...

struct LinkHSPStruct LinkHSPStruct

Structure containing all information internal to the process of linking HSPs.

static Int2 s_LinkedHSPSetArrayIndexQueryEnds(BlastLinkedHSPSet **hsp_array, Int4 hspcnt, Int4 **qend_index_ptr)

Given an array of HSPs (H), sorted in increasing order of query offsets, fills an array of indices in...

struct BlastHSPLink BlastHSPLink

The following structure is used in "link_hsps" to decide between two different "gapping" models.

static BlastLinkedHSPSet ** s_LinkedHSPSetArraySetUp(BlastHSP **hsp_array, Int4 hspcnt, Blast_KarlinBlk **kbp_array, EBlastProgramType program)

Sets up an array of wrapper structures for an array of BlastHSP's.

static LinkHSPStruct * s_LinkHSPStructReset(LinkHSPStruct *lhsp)

Initialize a LinkHSPStruct.

static Int4 s_HSPOffsetEndBinarySearch(BlastLinkedHSPSet **hsp_array, Int4 size, Int4 *qend_index_array, Uint4 queryId, Int4 offset)

Find an HSP in an array sorted in increasing order of query offsets and increasing order of queryId,...

static Boolean s_LinkedHSPSetsAdmissible(BlastLinkedHSPSet *hsp_set1, BlastLinkedHSPSet *hsp_set2, const BlastLinkHSPParameters *link_hsp_params, EBlastProgramType program)

Checks if new candidate HSP is admissible to be linked to a set of HSPs on the left.

static double s_SumHSPEvalue(EBlastProgramType program_number, const BlastQueryInfo *query_info, Int4 subject_length, const BlastLinkHSPParameters *link_hsp_params, BlastLinkedHSPSet *head_hsp, BlastLinkedHSPSet *new_hsp, double *sum_score)

Calculates e-value of a set of HSPs with sum statistics.

static BlastLinkedHSPSet * s_CombineLinkedHSPSets(BlastLinkedHSPSet *hsp_set1, BlastLinkedHSPSet *hsp_set2, double sum_score, double evalue)

Combines two linked sets of HSPs into a single set.

Functions to link HSPs using sum statistics.

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

#define MIN(a, b)

returns smaller of a and b.

#define INT4_MAX

largest nubmer represented by signed int

#define SIGN(a)

return +1 for a > 0, -1 for a < 0

Uint1 Boolean

bool replacment for C

#define TRUE

bool replacment for C indicating true.

#define FALSE

bool replacment for C indicating false.

#define ASSERT

macro for assert.

#define MAX(a, b)

returns larger of a and b.

Int4 query_length

Length of this query, strand or frame.

Int4 length_adjustment

Length adjustment for boundary conditions.

Int8 eff_searchsp

Effective search space for this context.

The following structure is used in "link_hsps" to decide between two different "gapping" models.

Int2 num[eOrderingMethods]

number of HSP in the ordering.

Int4 changed

Has the link been changed since previous access?

double xsum[eOrderingMethods]

Sum-Score of HSP, multiplied by the appropriate Lambda.

struct LinkHSPStruct * link[eOrderingMethods]

Best choice of HSP to link with.

Int4 sum[eOrderingMethods]

Sum-Score of HSP.

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

Int4 hspcnt

Number of HSPs saved.

BlastHSP ** hsp_array

Array of pointers to individual HSPs.

double best_evalue

Smallest e-value for HSPs in this list.

Structure holding all information about an HSP.

double evalue

This HSP's e-value.

BlastSeg query

Query sequence info.

Int4 context

Context number of query.

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.

Int4 score

This HSP's raw score.

Parameter block for linking HSPs with sum statistics.

double gap_decay_rate

Decay rate for linking HSPs and calculating cutoff scores.

double gap_prob

Probability of decay for linking HSPs.

Int4 cutoff_big_gap

Cutoff sum score for linked HSPs with big gaps.

Int4 cutoff_small_gap

Cutoff sum score for linked HSPs with small gaps.

Int4 overlap_size

Maximal overlap allowed in successive linked HSPs.

Int4 longest_intron

Length of a longest intron for uneven gap linking of HSPs.

Int4 gap_size

Small gap size for linking HSPs.

Simple doubly linked list of HSPs, used for calculating sum statistics.

Uint4 queryId

Used for support of OOF linking.

BlastHSP * hsp

HSP for the current link in the chain.

struct BlastLinkedHSPSet * next

Next link in the chain.

double sum_score

Sum bit score for the linked set.

struct BlastLinkedHSPSet * prev

Previous link in the chain.

The query related information.

BlastContextInfo * contexts

Information per context.

int num_queries

Number of query sequences.

Structure used for scoring calculations.

Blast_KarlinBlk ** kbp

Karlin-Altschul parameters.

Blast_KarlinBlk ** kbp_gap

K-A parameters for gapped alignments.

Int2 frame

Translation frame.

Int4 offset

Start of hsp.

Structure to hold the Karlin-Altschul parameters.

double Lambda

Lambda value used in statistics.

double logK

natural log of K value used in statistics

Structure containing all information internal to the process of linking HSPs.

Boolean start_of_chain

If TRUE, this HSP starts a chain along the "link" pointer.

Int4 q_offset_trim

Start of trimmed hsp in query.

BlastHSP * hsp

Specific HSP this structure corresponds to.

Int4 s_offset_trim

Start of trimmed hsp in subject.

struct LinkHSPStruct * next

Next HSP in a set, if any.

Int4 linked_to

Where this HSP is linked to?

Int4 s_end_trim

End of trimmed HSP in subject.

Int4 q_end_trim

End of trimmed HSP in query.

struct LinkHSPStruct * prev

Previous HSP in a set, if any.

double xsum

Normalized score of a set of HSPs.

ELinkOrderingMethod ordering_method

Which method (max or no max for gaps) was used for linking HSPs?

BlastHSPLink hsp_link

Auxiliary structure for keeping track of sum scores, etc.

Boolean linked_set

Is this HSp part of a linked set?

The helper array contains the info used frequently in the inner for loops of the HSP linking algorith...

Int4 next_larger

offset into array of HelpStructs containing HSP with higher score, used in bailout calculations

Int4 q_off_trim

query start of trimmed HSP

Int4 maxsum1

threshold for stopping link attempts (?)

LinkHSPStruct * ptr

The HSP to which the info belongs.

Int4 s_off_trim

subject start of trimmed HSP

Int4 sum[eOrderingMethods]

raw score of linked set containing HSP(?)

static CS_CONTEXT * context

voidp calloc(uInt items, uInt size)

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