~ubuntu-branches/ubuntu/karmic/ncbi-tools6/karmic

 

/* ===========================================================================

*

 

Contents: Utilities for BLAST

 

 

******************************************************************************/

/*

 *

* $Log: blastutl.c,v $

* Revision 6.447  2004/10/18 13:02:41  madden

* Changes from Mike Gertz:

*         - In score_compare_hsps, query_offset_compare_hsp and

#include <simutil.h>

#include <blfmtutl.h>

 

typedef struct _pgp_blast_options {

    BLAST_OptionsBlkPtr options;

    CharPtr blast_database;

{

    BLAST_ScorePtr *retval = NULL;

    posSearchItems *posSearch = NULL;

    Nlm_FloatHi scalingFactor = search->pbp->scalingFactor;

    BLAST_ScoreBlkPtr sbp = NULL;

    ValNodePtr error_return;

    Int4 i, gap_open, gap_extend;

 

    if (!search || !compactSearch || !posFreqs)

        return NULL;

    }

 

    if (sbp->kbp_ideal == NULL)

        sbp->kbp_ideal = BlastKarlinBlkStandardCalcEx(sbp);

    compactSearch->lambda =  sbp->kbp_gap_std[0]->Lambda;

                        options->db_length : SeqLocLen(pssm_slp);

        Int4 nseqs = (options->dbseq_num != 0) ?  options->dbseq_num : 1;

 

        sa_array[i] = B2SPssmOnTheFlyByLoc(search, target_seqs[i]);

    }

 

        /* If filtering is performed, do not reverse the sequence.  

           In this case the wrong sequence would be filtered. */

        reverse_forbidden = FALSE;

                        StringCmp(options->filter_string, "F")) ||

                        matrix != NULL)

        {

                reverse_forbidden = TRUE;

 

        seqalign = BlastTwoSequencesCore(search, subject_slp, subject_seq, subject_length, reverse);

 

        if (complement)

        {

                seqalign = SeqAlignListReverseStrand(seqalign);

        register int state;

        Int2 total_remainder;

        Int4 prot_length;

        Uint1 last_remainder, last_byte, remainder;

        register Uint1Ptr translation, nt_seq_end, nt_seq_start;

        Uint1Ptr prot_seq_start;

    return 0;

}

 

typedef struct _blast_result_with_subject_id {

   BLASTResultHspPtr hsp;

   Int4 hitlist_index, hsp_index;

   else /* Should never happen */

      return 0;

}

 

#define CLUSTER_LENGTH_THRESH 0.1

#define CLUSTER_OVERLAP_THRESH 0.9

#define CLUSTER_SCORE_THRESH 1.6

 

SeqAlignPtr LIBCALL

BioseqBlastEngineCore(BlastSearchBlkPtr search, BLAST_OptionsBlkPtr options,

                        Int4Ptr *pos_matrix)

{

        BLAST_KarlinBlkPtr kbp;

        FloatHi bit_score;

 

        head = seqalign = NULL;

 

        if (search == NULL || search->query_invalid)

                return NULL;

 

        /* If pos_matrix is not NULL, then psi-blast iterations are being 

        performed.  The first psi-blast iteration should be with normal

        blast. */

                       search->wfp_second = BLAST_WordFinderNew(search->sbp->alphabet_size,options->wordsize,1, FALSE);

                }

 

                /* Only find words once if thresholds are the same. */

                 search->wfp = search->wfp_first;

                 if (search->whole_query == TRUE)

                        BlastNewFindWords(search, search->required_start, search->required_end, search->pbp->threshold_second, (Uint1) 0);

                 lookup_position_aux_destruct(search->wfp->lookup);

                 search->wfp_second = search->wfp_first;

        }

 

        /* Starting awake thread if multithreaded. */

 

{

        Boolean make_seqloc, start=TRUE;

        SeqIntPtr sint;

        SeqLocPtr retval=NULL;

 

    BlastThrInfoPtr thr_info;

    

    thr_info = MemNew(sizeof(BlastThrInfo));

    

    return thr_info;

}

            new_search->query_dnap = BlastMakeCopyQueryDNAP(search->query_dnap);

 

        new_search->thr_info = search->thr_info;

        new_search->semid = search->semid;

        

#ifdef BLAST_COLLECT_STATS

        Boolean mask_state;

        Char cmd_buf[2*PATH_MAX], temp_file[PATH_MAX];

        CharPtr filter_dir;

        SeqEntryPtr sep;

        SeqLocPtr slp_mask;

        SeqPortPtr spp_filter, spp_unfilter;

        /* -z Effective database length */

        index = BlastGetLetterIndex(opt_str, 'z');

        if (values[index] != NULL) {

        }

 

        /* -c Constant in pseudocounts for multipass version */

           if (options->is_megablast_search)

              options->mb_template_length = atoi(values[index]);

           else 

        }

 

        /* -g  Scan every base of the database for megablast */

 

BLAST_HSPPtr BLAST_HSPFree(BLAST_HSPPtr hsp)

{

   hsp->gap_info = GapXEditBlockDelete(hsp->gap_info);

}

 

/* 

score_compare_hsps(VoidPtr v1, VoidPtr v2)

 

{

    }

}

 

/*

}

 

/*

*/

Boolean

{

}

/*

        Gets the ratio used to change an evalue calculated with the subject

        sequence length to one with a db length.

        if (h1->query.offset > h2->query.offset)

                return 1;

 

        return 0;

}

 

        if (h1->query.end > h2->query.end)

                return 1;

 

        return 0;

}

/*

{

        Int4 index1, index, increment;

 

                return 0;

 

        HeapSort(hsp_array, hsp_count, sizeof(BLAST_HSPPtr), query_offset_compare_hsp);

BlastGappedScoreInternal(BlastSearchBlkPtr search, Uint1Ptr subject, Int4 subject_length, GapAlignBlkPtr gap_align, BLAST_HSPPtr *hsp_array, Int4Ptr hspcnt, Int4Ptr hspcnt_max, Int4 hspmax, Int2 frame)

 

{

        BLAST_HSPPtr PNTR hsp_array_new;

        BLAST_HSP_helperPtr helper;

        Boolean hsp_start_is_contained, hsp_end_is_contained;

                           }

                        }

                }

                if (hsp_start_is_contained == FALSE ||

                {

                        gap_align->include_query = 0;

 

                        hsp->query.length = hsp->query.end - hsp->query.offset;

                        hsp->subject.length = hsp->subject.end - hsp->subject.offset;

                        hsp->score = gap_align->score;

 

                else

                { /* Contained within another HSP, delete. */

                        hsp_array[index] = BLAST_HSPFree(hsp_array[index]);

BlastNtGappedScoreInternal(BlastSearchBlkPtr search, Uint1Ptr subject, Int4 subject_length, GapAlignBlkPtr gap_align, BLAST_HSPPtr *hsp_array, Int4Ptr hspcnt, Int4Ptr hspcnt_max, Int4 hspmax)

 

{

        BLAST_HSP_helperPtr helper;

        Boolean hsp_start_is_contained, hsp_end_is_contained;

        Int4 hsp_cnt=0, index, index1, next_offset, query_length;

    return;

}

 

{

    Int4 index, index1;

    BLAST_HSPPtr hsp, hsp1;

    Int4 index, index1, index2, query_length, max_offset;

    Int4Ptr translated_subject_length=NULL; 

    Int4Ptr translated_subject_length_orig=NULL;

    Uint1Ptr query, PNTR translated_subject=NULL, PNTR translated_subject_orig=NULL;

    ValNodePtr gi_list=NULL;

    BLAST_HitListPtr tmp_hitlist;

                   keep = FALSE;

                }

 

                   if (search->pbp->mb_params) {

                      FloatHi searchsp_eff = (FloatHi) search->dblen_eff *

                         (FloatHi) search->context[hsp->context].query->effective_length;

                   /*hsp->pvalue = BlastKarlinEtoP(hsp->evalue);*/

                    if (hsp->evalue > search->pbp->cutoff_e) /* put in for comp. based stats. */

                        keep = FALSE;

                }

 

                if (keep) {

}