BlastHSPStream*
BlastHSPStreamNew(EBlastProgramType program,
const BlastExtensionOptions* extn_opts,
Boolean sort_on_read,
Int4 num_queries,
BlastHSPWriter *writer)
{
BlastHSPStream* hsp_stream =
(BlastHSPStream*) malloc(sizeof(BlastHSPStream));
hsp_stream->program = program;
hsp_stream->num_hsplists = 0;
hsp_stream->num_hsplists_alloc = 100;
hsp_stream->sorted_hsplists = (BlastHSPList **)malloc(
hsp_stream->num_hsplists_alloc *
sizeof(BlastHSPList *));
hsp_stream->results = Blast_HSPResultsNew(num_queries);
hsp_stream->results_sorted = FALSE;
/* This is needed to meet a pre-condition of the composition-based
* statistics code */
if ((Blast_QueryIsProtein(program) || Blast_QueryIsPssm(program)) &&
extn_opts->compositionBasedStats != 0) {
hsp_stream->sort_by_score =
(SSortByScoreStruct*)calloc(1, sizeof(SSortByScoreStruct));
hsp_stream->sort_by_score->sort_on_read = sort_on_read;
hsp_stream->sort_by_score->first_query_index = 0;
} else {
hsp_stream->sort_by_score = NULL;
}
hsp_stream->x_lock = NULL;
hsp_stream->writer = writer;
hsp_stream->writer_initialized = FALSE;
hsp_stream->writer_finalized = FALSE;
hsp_stream->pre_pipe = NULL;
hsp_stream->tback_pipe = NULL;
return hsp_stream;
}
Int2 SThreadLocalDataArraySetup(SThreadLocalDataArray* array,
EBlastProgramType program,
const BlastScoringOptions* score_options,
const BlastEffectiveLengthsOptions* eff_len_options,
const BlastExtensionOptions* ext_options,
const BlastHitSavingOptions* hit_options,
BlastQueryInfo* query_info,
BlastScoreBlk* sbp,
const BlastSeqSrc* seqsrc)
{
Uint4 i;
Int2 status = 0;
if (!array)
return BLASTERR_INVALIDPARAM;
for (i = 0; i < array->num_elems; i++) {
status =
BLAST_GapAlignSetUp(program, seqsrc, score_options, eff_len_options,
ext_options, hit_options, query_info, sbp,
&array->tld[i]->score_params,
&array->tld[i]->ext_params,
&array->tld[i]->hit_params,
&array->tld[i]->eff_len_params,
&array->tld[i]->gap_align);
if (status)
return status;
if ( !(array->tld[i]->query_info = BlastQueryInfoDup(query_info)) ) {
return BLASTERR_MEMORY;
}
if ( !(array->tld[i]->seqsrc = BlastSeqSrcCopy(seqsrc)) ) {
return BLASTERR_MEMORY;
}
if ( !(array->tld[i]->results = Blast_HSPResultsNew(query_info->num_queries)) ) {
return BLASTERR_MEMORY;
}
}
return 0;
}
BlastHSPResults* SThreadLocalDataArrayConsolidateResults(SThreadLocalDataArray* array)
{
BlastHSPResults* retval = NULL;
Int4 num_queries = 0, query_idx = 0, hitlist_size = 0;
Uint4* num_hsplists_per_query = NULL;
if ( !array ) {
return retval;
}
num_hsplists_per_query = s_CountHspListsPerQuery(array, &num_queries);
if ( !(retval = Blast_HSPResultsNew(num_queries)) ) {
sfree(num_hsplists_per_query);
return retval;
}
hitlist_size = array->tld[0]->hit_params->options->hitlist_size;
for (query_idx = 0; query_idx < num_queries; query_idx++) {
Uint4 tid = 0;
BlastHitList* hits4query = retval->hitlist_array[query_idx] =
Blast_HitListNew(hitlist_size);
if ( !hits4query ) {
retval = Blast_HSPResultsFree(retval);
break;
}
hits4query->hsplist_array = (BlastHSPList**)
calloc(num_hsplists_per_query[query_idx], sizeof(BlastHSPList*));
if ( !hits4query->hsplist_array ) {
retval = Blast_HSPResultsFree(retval);
break;
}
/* Consolidate the results for query_idx from all threads */
for (tid = 0; tid < array->num_elems; tid++) {
BlastHSPResults* thread_results = array->tld[tid]->results;
BlastHitList* thread_hitlist = thread_results->hitlist_array[query_idx];
Int4 i;
if ( !thread_hitlist ) {
continue;
}
/* transfer the BlastHSPList to the consolidated structure */
for (i = 0; i < thread_hitlist->hsplist_count; i++) {
if ( !Blast_HSPList_IsEmpty(thread_hitlist->hsplist_array[i])) {
hits4query->hsplist_array[hits4query->hsplist_count++] =
thread_hitlist->hsplist_array[i];
thread_hitlist->hsplist_array[i] = NULL;
}
}
hits4query->worst_evalue = !tid
? thread_hitlist->worst_evalue
: MAX(thread_hitlist->worst_evalue, hits4query->worst_evalue);
hits4query->low_score = !tid
? thread_hitlist->low_score
: MAX(thread_hitlist->low_score, hits4query->low_score);
}
}
sfree(num_hsplists_per_query);
return retval;
}
