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__hspstream_8c_source.html below:

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

(index=0; index < hsp_stream->

; index++)

(hsp_stream->

) {

(*yy)->

- (*xx)->oid;

(hsp_stream->

) {

(

= 0;

<

->num_queries;

++) {

(hitlist ==

)

(hsplist ==

)

(num_hsplists > 1) {

(!hsp_stream || !hsp_stream->

)

(!hsp_stream || !

) {

*hsp_list_out =

;

last_hsplist_index = -1, index = 0;

index < results->num_queries; ++index) {

(

->hitlist_array[index] &&

->hitlist_array[index]->hsplist_count > 0)

(index >=

->num_queries)

hit_list =

->hitlist_array[index];

*hsp_list_out = hit_list->

[last_hsplist_index];

(hsp_stream->

) {

contexts_per_query = 0;

num_queries = 0, num_ctx = 0, num_ctx_offsets = 0;

*query_list =

, *offset_list =

, num_contexts = 0;

(!stream1 || !stream2)

&context_list, &num_contexts);

fprintf(stderr,

, chunk_num);

fprintf(stderr,

);

(num_queries = 0; query_list[num_queries] !=

; num_queries++)

fprintf(stderr,

, query_list[num_queries]);

fprintf(stderr,

);

fprintf(stderr,

);

(num_ctx = 0; num_ctx < num_contexts; num_ctx++)

fprintf(stderr,

, context_list[num_ctx]);

fprintf(stderr,

);

fprintf(stderr,

);

(num_ctx_offsets = 0; offset_list[num_ctx_offsets] !=

;

fprintf(stderr,

, offset_list[num_ctx_offsets]);

fprintf(stderr,

);

(num_queries = 0; query_list[num_queries] !=

; num_queries++) ;

(num_ctx = 0, max_ctx =

; num_ctx < (

)num_contexts; num_ctx++)

max_ctx =

(max_ctx, context_list[num_ctx]);

(num_ctx_offsets = 0; offset_list[num_ctx_offsets] !=

;

global_query = query_list[

];

(hitlist ==

) {

fprintf(stderr,

, global_query);

(j = 0; j < contexts_per_query; j++) {

split_points[j] = -1;

(j = 0; j < contexts_per_query; j++) {

local_context =

* contexts_per_query + j;

(context_list[local_context] >= 0) {

split_points[context_list[local_context] % contexts_per_query] =

offset_list[local_context];

fprintf(stderr,

,

);

(j = 0; j < contexts_per_query; j++) {

fprintf(stderr,

, split_points[j]);

fprintf(stderr,

);

(k = 0; k < hsplist->

; k++) {

(local_context <= max_ctx);

(local_context < num_ctx);

(local_context < num_ctx_offsets);

hsp->

= context_list[local_context];

hsp->

.

+= offset_list[local_context];

hsp->

.

+= offset_list[local_context];

->hitlist_array + global_query,

contexts_per_query, split_points,

(hitlist ==

)

fprintf(stderr,

,

->num_queries);

(hitlist ==

)

(k = 0; k < hsplist->

; k++) {

fprintf(stderr,

, hsp->

,

(context_list);

(!hsp_stream || !batch)

(num_hsplists == 0)

target_oid = hsplist->

;

(

= 0;

< num_hsplists;

++) {

(hsplist->

!= target_oid)

(batch !=

) {

(batch !=

) {

hsp_stream->

= program;

hsp_stream->

= writer;

(!hsp_stream || (hsp_stream->

&& lock)) {

hsp_stream->

= lock;

(!hsp_stream || !pipe) {

(; p && p->

; p = p->

);

(writer_info && *writer_info) {

writer = ((*writer_info)->NewFnPtr) ((*writer_info)->params, query_info,

(*writer_info);

(writer_info && *writer_info ==

);

(

->next) {

p->

= (

->NewFnPtr) (

->params, query_info);

pipe = (

->NewFnPtr) (

->params, query_info);

(index =

; index < old_count; index++) {

(index = 0; index <

->num_queries; index++) {

hit_list =

->hitlist_array[index];

REF_HIT_NUM =

(500, hitlist_size);

MIN_BUF_SZ = REF_HIT_NUM + 600;

best_evalue = 0, evalue_limit = 0;

mag = -180, pct = 90,

= 0;

(best_evalue != 0 ){

mag =

(mag*pct/100, mag +10);

evalue_limit = (mag >= 0)? best_evalue*3: 9.9* pow(10, mag);

(;

< max_index;

+=100) {

#define sfree(x)

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

#define NUM_FRAMES

Number of frames to which we translate in translating searches.

EBlastStage

Enumeration for the stages in the BLAST search.

@ eTracebackSearch

Traceback stage.

@ ePrelimSearch

Preliminary stage.

Int2 Blast_HSPResultsReverseSort(BlastHSPResults *results)

Sort each hit list in the BLAST results by best e-value, in reverse order.

BlastHSPResults * Blast_HSPResultsFree(BlastHSPResults *results)

Deallocate memory for BLAST results.

Int2 Blast_HitListMerge(BlastHitList **old_hit_list_ptr, BlastHitList **combined_hit_list_ptr, Int4 contexts_per_query, Int4 *split_offsets, Int4 chunk_overlap_size, Boolean allow_gap)

Combine two hitlists; both HitLists must contain HSPs that represent alignments to the same query seq...

Int2 Blast_HSPResultsReverseOrder(BlastHSPResults *results)

Reverse order of HSP lists in each hit list in the BLAST results.

Int2 Blast_HitListSortByEvalue(BlastHitList *hit_list)

Sort BlastHitLIst bon evalue.

BlastHSPResults * Blast_HSPResultsNew(Int4 num_queries)

Initialize the results structure.

BlastHSPList * Blast_HSPListFree(BlastHSPList *hsp_list)

Deallocate memory for an HSP list structure as well as all it's components.

void Blast_HSPListSortByScore(BlastHSPList *hsp_list)

Sort the HSPs in an HSP list by score.

BlastHSPWriter * BlastHSPWriterNew(BlastHSPWriterInfo **writer_info, BlastQueryInfo *query_info, BLAST_SequenceBlk *query)

A generic function to create writer.

void BlastHSPStreamSimpleClose(BlastHSPStream *hsp_stream)

Closes the BlastHSPStream structure for writing without any sorting as done in BlastHSPStreamClose.

void BlastHSPStreamClose(BlastHSPStream *hsp_stream)

Prohibit any future writing to the HSP stream when all results are written.

BlastHSPPipe * BlastHSPPipeNew(BlastHSPPipeInfo **pipe_info, BlastQueryInfo *query_info)

A generic function to create pipe.

static void s_FinalizeWriter(BlastHSPStream *hsp_stream)

certain hspstreams (such as besthit and culling) uses its own data structure and therefore must be fi...

void s_TrimHitList(BlastHitList *hitlist, int count)

int BlastHSPStreamMerge(SSplitQueryBlk *squery_blk, Uint4 chunk_num, BlastHSPStream *stream1, BlastHSPStream *stream2)

Merge two HSPStreams.

static int s_SortHSPListByOid(const void *x, const void *y)

callback used to sort HSP lists in order of decreasing OID

int BlastHSPStreamWrite(BlastHSPStream *hsp_stream, BlastHSPList **hsp_list)

Write an HSP list to the collector HSP stream.

BlastHSPStreamResultBatch * Blast_HSPStreamResultBatchReset(BlastHSPStreamResultBatch *batch)

free the list of HSPLists within a batch

BlastHSPStream * BlastHSPStreamFree(BlastHSPStream *hsp_stream)

Default hit saving stream methods.

void BlastHSPStreamMappingClose(BlastHSPStream *hsp_stream, BlastMappingResults *results)

Closes BlastHSPStream structure for mapping and produces BlastMappingResults.

BlastHSPStream * BlastHSPStreamNew(EBlastProgramType program, const BlastExtensionOptions *extn_opts, Boolean sort_on_read, Int4 num_queries, BlastHSPWriter *writer)

Initialize the HSP stream.

const int kBlastHSPStream_Eof

Return value when the end of the stream is reached (applicable to read method only)

int BlastHSPStreamRegisterMTLock(BlastHSPStream *hsp_stream, MT_LOCK lock)

Attach a mutex lock to a stream to protect multiple access during writing.

const int kBlastHSPStream_Success

Standard success return value for BlastHSPStream methods.

void BlastHSPCBSStreamClose(BlastHSPStream *hsp_stream, int hitlist_size)

BlastHSPPipeInfo * BlastHSPPipeInfo_Add(BlastHSPPipeInfo **head, BlastHSPPipeInfo *node)

Adds node to the linked list starting a head, which should be NULL when initializing the linked list,...

int BlastHSPStreamRegisterPipe(BlastHSPStream *hsp_stream, BlastHSPPipe *pipe, EBlastStage stage)

Insert the user-specified pipe to the *end* of the pipeline.

void BlastHSPStreamTBackClose(BlastHSPStream *hsp_stream, BlastHSPResults *results)

Closing the HSP after traceback is done.

BlastHSPStreamResultBatch * Blast_HSPStreamResultBatchInit(Int4 num_hsplists)

create a new batch to hold HSP results

int BlastHSPStreamRead(BlastHSPStream *hsp_stream, BlastHSPList **hsp_list_out)

Read one HSP list from the results saved in an HSP list collector.

const int kBlastHSPStream_Error

Standard error return value for BlastHSPStream methods.

BlastHSPStreamResultBatch * Blast_HSPStreamResultBatchFree(BlastHSPStreamResultBatch *batch)

free a batch of HSP results.

int BlastHSPStreamBatchRead(BlastHSPStream *hsp_stream, BlastHSPStreamResultBatch *batch)

Batch read function for this BlastHSPStream implementation.

Declaration of ADT to save and retrieve lists of HSPs in the BLAST engine.

Private interfaces to support the multi-threaded traceback in conjunction with the BlastHSPStream.

Boolean Blast_QueryIsPssm(EBlastProgramType p)

Returns true if the query is PSSM.

Boolean Blast_QueryIsProtein(EBlastProgramType p)

Returns true if the query is protein.

EBlastProgramType

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

Various auxiliary BLAST utility functions.

Int1 BLAST_ContextToFrame(EBlastProgramType prog_number, Uint4 context_number)

This function translates the context number of a context into the frame of the sequence.

unsigned int BLAST_GetNumberOfContexts(EBlastProgramType program)

Get the number of contexts for a given program.

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

MT_LOCK MT_LOCK_Delete(MT_LOCK lk)

Decrement internal reference count by 1, and if it reaches 0, then destroy the handle,...

#define MT_LOCK_Do(lk, how)

Call "lk->handler(lk->data, how)".

@ eMT_Unlock

unlock critical section

@ eMT_Lock

lock critical section

Uint1 Boolean

bool replacment for C

#define TRUE

bool replacment for C indicating true.

#define FALSE

bool replacment for C indicating false.

#define UINT4_MAX

largest number represented by unsigned int.

#define ASSERT

macro for assert.

#define INT4_MIN

Smallest (most negative) number represented by signed int.

#define MAX(a, b)

returns larger of a and b.

Boolean SplitQueryBlk_AllowGap(SSplitQueryBlk *squery_blk)

Determines whether HSPs on different diagnonals may be merged.

Int2 SplitQueryBlk_GetQueryIndicesForChunk(const SSplitQueryBlk *squery_blk, Uint4 chunk_num, Uint4 **query_indices)

Retrieve an array of query indices for the requested chunk.

Int2 SplitQueryBlk_GetContextOffsetsForChunk(const SSplitQueryBlk *squery_blk, Uint4 chunk_num, Uint4 **context_offsets)

Retrieve an array of context offsets for the requested chunk.

Int2 SplitQueryBlk_GetQueryContextsForChunk(const SSplitQueryBlk *squery_blk, Uint4 chunk_num, Int4 **query_contexts, Uint4 *num_query_contexts)

Retrieve an array of query contexts for the requested chunk.

size_t SplitQueryBlk_GetChunkOverlapSize(const SSplitQueryBlk *squery_blk)

Returns the query chunk overlap size.

Structure to hold a sequence.

Options used for gapped extension These include: a.

Int4 compositionBasedStats

mode of compositional adjustment to use; if zero then compositional adjustment is not used

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.

double best_evalue

Smallest e-value for HSPs in this list.

Int4 query_index

Index of the query which this HSPList corresponds to.

A wrap of data structure used to create a pipe.

ADT definition of BlastHSPPipe.

void * data

data structure

BlastHSPPipe * next

the next pipe in chain

BlastHSPPipeRunFn RunFnPtr

BlastHSPPipeFreeFn FreeFnPtr

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

structure used to hold a collection of hits retrieved from the HSPStream

Int4 num_hsplists

number of lists of HSPs returned

BlastHSPList ** hsplist_array

array of HSP lists returned

Default implementation of BlastHSPStream.

BlastHSPWriter * writer

writer to be applied when writing

Int4 num_hsplists_alloc

number of entries in sorted_hsplists

Boolean writer_finalized

Is writer ever finalized?

Int4 num_hsplists

number of HSPlists saved

BlastHSPList ** sorted_hsplists

list of all HSPlists from 'results' combined, sorted in order of decreasing subject OID

BlastHSPResults * results

Structure for saving HSP lists.

EBlastProgramType program

BLAST program type.

Boolean results_sorted

Have the results already been sorted? Set to true after the first read call.

MT_LOCK x_lock

Mutex for writing and reading results.

BlastHSPPipe * tback_pipe

registered traceback pipeline

Boolean writer_initialized

Is writer already initialized?

SSortByScoreStruct * sort_by_score

BlastHSPPipe * pre_pipe

registered preliminary pipeline (unused for now)

A wrap of data structure used to create a writer.

ADT definition of BlastHSPWriter.

void * data

data structure

BlastHSPWriterFinalFn FinalFnPtr

BlastHSPWriterFreeFn FreeFnPtr

BlastHSPWriterRunFn RunFnPtr

BlastHSPWriterInitFn InitFnPtr

Structure holding all information about an HSP.

BlastSeg query

Query sequence info.

Int4 context

Context number of query.

BlastSeg subject

Subject sequence info.

Int4 score

This HSP's raw score.

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.

Structure that contains BLAST mapping results.

The query related information.

Int4 gapped_start

Where the gapped extension started.

Int2 frame

Translation frame.

Int4 offset

Start of hsp.

Auxiliary structure to allow sorting the results by score for the composition-based statistics code.

Int4 first_query_index

Index of the first query to try getting results from.

Boolean sort_on_read

Should the results be sorted on the first read call?

Structure to keep track of which query sequences are allocated to each query chunk.

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