include/bytepackGappedScoring.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
int4	bytepackGappedScoring_score (struct ungappedExtension *ungappedExtension, struct PSSMatrix PSSMatrix, int4 subjectSize, unsigned char *packedSubject, int4 dropoff)
void	bytepackGappedScoring_free ()

---

Function Documentation

void bytepackGappedScoring_free

(

)

Definition at line 736 of file bytepackGappedScoring.c.

References bytepackGappedScoring_bestRows, and bytepackGappedScoring_insertQrow.

Referenced by main().

{
    free(bytepackGappedScoring_bestRows[0]);
    free(bytepackGappedScoring_bestRows[1]);
    free(bytepackGappedScoring_insertQrow);
}

Here is the caller graph for this function:

int4 bytepackGappedScoring_score	(	struct ungappedExtension *	ungappedExtension,
		struct PSSMatrix	PSSMatrix,
		int4	subjectSize,
		unsigned char *	packedSubject,
		int4	dropoff
	)

Definition at line 23 of file bytepackGappedScoring.c.

References dpResults::best, dpResults::bestScore, blast_dloc, blast_numSemiGapped, PSSMatrix::bytePackedCodes, bytepackGappedScoring_dpAfterSeed(), bytepackGappedScoring_dpBeforeSeed(), ungappedExtension::end, fasterBytepackGappedScoring_dpAfterSeed(), fasterBytepackGappedScoring_dpBeforeSeed(), int4, PSSMatrix::length, ungappedExtension::nominalScore, parameters_bytepackDropoffDecrease, parameters_bytepackStartGap, parameters_verboseDloc, PSSMatrix_chop(), PSSMatrix_packedScore, coordinate::queryOffset, ungappedExtension::seed, ungappedExtension::start, PSSMatrix::strandLength, and coordinate::subjectOffset.

Referenced by alignments_findGoodAlignments().

{
    struct coordinate seed;
    unsigned char *choppedSubject;
    struct PSSMatrix choppedPSSMatrix;
    int4 choppedSubjectSize, score, packedSubjectSize;
    struct dpResults beforeDpResults, afterDpResults;
    int4 strandOffset = 0;

    // Increment counter number of HSP's semi-gapped
        blast_numSemiGapped++;

    dropoff -= parameters_bytepackDropoffDecrease;

    // Calculate packed subject size
    packedSubjectSize = (subjectSize + 3) / 4;

    seed = ungappedExtension->seed;
    if (seed.queryOffset > PSSMatrix.strandLength)
    {
            // If query position is in the second strand, remove first strand from PSSM
        strandOffset = PSSMatrix.strandLength;
                seed.queryOffset -= PSSMatrix.strandLength;
                PSSMatrix = PSSMatrix_chop(PSSMatrix, PSSMatrix.strandLength);

        #ifdef VERBOSE
        if (parameters_verboseDloc == blast_dloc)
                        printf("Second stand qLength=%d seed=%d,%d\n", PSSMatrix.length,
                   seed.queryOffset, seed.subjectOffset);
        #endif
    }
    else
    {
        // Otherwise remove second strand
        PSSMatrix.length = PSSMatrix.strandLength;
    }

    // Adjust to point to start of byte
    seed.queryOffset -= 2;
    seed.subjectOffset -= 2;

//    printf("Was %d,%d to %d,%d\n", ungappedExtension->start.queryOffset, ungappedExtension->start.subjectOffset,
//      ungappedExtension->end.queryOffset, ungappedExtension->end.subjectOffset);
//    printf("seed=%d,%d\n", seed.queryOffset, seed.subjectOffset); fflush(stdout);

    // Update the seed to point to byte-packed sequences
        seed.subjectOffset /= 4;

    // Perform dynamic programming for points before the seed
    if (parameters_bytepackStartGap == 0)
    {
        beforeDpResults = fasterBytepackGappedScoring_dpBeforeSeed(packedSubject, PSSMatrix,
                                                                   seed, dropoff);
    }
    else
    {
        beforeDpResults = bytepackGappedScoring_dpBeforeSeed(packedSubject, PSSMatrix,
                                                             seed, dropoff);
        }

        // Adjust starting position to point to non-bytepacked subject
        beforeDpResults.best.subjectOffset *= 4;

    // Chop the start off the query and subject so they begin at the seed
    choppedPSSMatrix = PSSMatrix_chop(PSSMatrix, seed.queryOffset);
    choppedSubject = packedSubject + seed.subjectOffset;
    choppedSubjectSize = packedSubjectSize - seed.subjectOffset;

    // Perform dynamic programming for points after the seed
    if (parameters_bytepackStartGap == 0)
    {
        afterDpResults = fasterBytepackGappedScoring_dpAfterSeed(choppedSubject, choppedPSSMatrix,
                                                                 dropoff, choppedSubjectSize);
        }
    else
    {
        afterDpResults = bytepackGappedScoring_dpAfterSeed(choppedSubject, choppedPSSMatrix,
                                                           dropoff, choppedSubjectSize);
    }

    // Re-adjust result change due to chopping subject/query and strand adjustment
    afterDpResults.best.queryOffset += seed.queryOffset + strandOffset;
    afterDpResults.best.subjectOffset = (afterDpResults.best.subjectOffset + seed.subjectOffset) * 4;
    beforeDpResults.best.queryOffset += strandOffset;

    // Extend out ends slightly
        beforeDpResults.best.queryOffset -= 2;
        beforeDpResults.best.subjectOffset -= 2;
        afterDpResults.best.queryOffset += 6;
        afterDpResults.best.subjectOffset += 6;

    #ifdef VERBOSE
    if (parameters_verboseDloc == blast_dloc)
        printf("bytepacked[%d,%d,%d] (seed=%d,%d)\n", beforeDpResults.bestScore, afterDpResults.bestScore,
        PSSMatrix_packedScore[choppedPSSMatrix.bytePackedCodes[0] ^ choppedSubject[0]], seed.queryOffset,
        seed.subjectOffset * 4);
        #endif

    // Determine score by combining score from the two traces, and the match score at
    // the seed position
    score = beforeDpResults.bestScore + afterDpResults.bestScore +
            PSSMatrix_packedScore[choppedPSSMatrix.bytePackedCodes[0] ^ choppedSubject[0]];

        // Use ungapped alignment score and endpoints if better
    if (ungappedExtension->nominalScore > score)
    {
        score = ungappedExtension->nominalScore;
        }
    else
    {
        // Associate best scoring start and end points with the ungapped extension
        ungappedExtension->start = beforeDpResults.best;
        ungappedExtension->end = afterDpResults.best;
    }

    return score;
}

Here is the call graph for this function:

Here is the caller graph for this function:

---