include/print.h File Reference

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

Go to the source code of this file.

Functions
char *	print_formatDescription (char *description, int4 firstLineIndent, int4 remainingLinesIndent, int4 maxLineLength)
void	print_gappedAlignmentsFull (char *query, struct PSSMatrix PSSMatrix)
void	print_gappedAlignmentsBrief ()
void	print_singleSequence (unsigned char *sequence, int4 length)
char *	print_eValue2String (double evalue)
void	print_XMLheader (char *query, struct PSSMatrix PSSMatrix)
void	print_XMLfooter ()

---

Function Documentation

char* print_eValue2String

(

double

evalue

)

Definition at line 817 of file print.c.

References print_eValueBuf.

Referenced by print_gappedAlignmentsBrief(), print_gappedExtension(), and print_tabularGappedExtension().

{
        char* eValueBuffer = print_eValueBuf;

        if (evalue < 1.0e-180) {
        sprintf(print_eValueBuf, "0.0");
    } else if (evalue < 1.0e-99) {
        sprintf(print_eValueBuf, "%2.0le", evalue);
        eValueBuffer++; /* Knock off digit. */
    } else if (evalue < 0.0009) {
        sprintf(print_eValueBuf, "%3.0le", evalue);
    } else if (evalue < 0.1) {
        sprintf(print_eValueBuf, "%4.3lf", evalue);
    } else if (evalue < 1.0) {
        sprintf(print_eValueBuf, "%3.2lf", evalue);
    } else if (evalue < 10.0) {
        sprintf(print_eValueBuf, "%2.1lf", evalue);
    } else {
        sprintf(print_eValueBuf, "%5.0lf", evalue);
    }

        return eValueBuffer;
}

Here is the caller graph for this function:

char* print_formatDescription	(	char *	description,
		int4	firstLineIndent,
		int4	remainingLinesIndent,
		int4	maxLineLength
	)

Definition at line 192 of file print.c.

References global_malloc(), and int4.

Referenced by main(), and print_gappedAlignmentsFull().

{
        int4 length, startWord = 0, endWord = 0, startLine = 0, newDescriptionPos = 0;
    int4 maxLengthAfterIndent, count;
    char* newDescription;

    length = strlen(description);

    // Declare memory for formatted description, which will be at most double its length
    newDescription = (char*)global_malloc(sizeof(char) * length * 2);

    startLine = startWord = endWord = 0;

    while (endWord < length)
        {
        // Find the end of the current word
        while (endWord < length && description[endWord] != ' ' &&
               description[endWord] != '\n' && description[endWord] != '\t')
        {
            endWord++;
        }

        if (startLine == 0)
                maxLengthAfterIndent = maxLineLength - firstLineIndent;
                else
                maxLengthAfterIndent = maxLineLength - remainingLinesIndent;

        // If it is too far along
        if (endWord - startLine > maxLengthAfterIndent)
        {
            // If this is the first word of this line, we need to cut the word in half
            if (startLine == startWord)
            {
                // Copy portion of the word
                memcpy(newDescription + newDescriptionPos, description + startLine,
                       sizeof(char) * maxLineLength);
                newDescriptionPos += maxLineLength;

                // Add carriage return
                newDescription[newDescriptionPos] = '\n';
                newDescriptionPos++;

                // Add indent
                count = 0;
                while (count < remainingLinesIndent)
                {
                    newDescription[newDescriptionPos] = ' ';
                    newDescriptionPos++;
                    count++;
                }

                // Set pointers for next line
                startLine += maxLineLength;
                endWord = startWord = startLine;
            }
            // Else exclude this last word and copy the rest of the line over
            else
            {
                // Copy line over
                                memcpy(newDescription + newDescriptionPos, description + startLine,
                       sizeof(char) * (startWord - startLine));
                newDescriptionPos += (startWord - startLine);

                // Add carriage return
                newDescription[newDescriptionPos] = '\n';
                newDescriptionPos++;

                // Add indent
                count = 0;
                while (count < remainingLinesIndent)
                {
                    newDescription[newDescriptionPos] = ' ';
                    newDescriptionPos++;
                    count++;
                }

                // Set pointers for next line
                startLine = endWord = startWord;
            }
        }
        else
        {
                // Advance past current whitespace
            endWord++;

            // This is the start of the next word
            startWord = endWord;
        }
        }

    // Copy the last bit over
    memcpy(newDescription + newDescriptionPos, description + startLine,
           sizeof(char) * (length - startLine));
    newDescriptionPos += (length - startLine);

    // Null terminate
    newDescription[newDescriptionPos] = '\0';

    // Free the unformatted description
    free(description);

    return newDescription;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void print_gappedAlignmentsBrief

(

)

Definition at line 515 of file print.c.

References finalAlignment::alignment, alignments_finalAlignments, finalAlignment::description, alignment::descriptionLocation, gappedExtension::eValue, alignment::gappedExtensions, global_malloc(), global_realloc(), finalAlignment::highestNominalScore, int4, memSingleBlock_getEntry(), gappedExtension::normalizedScore, parameters_getDescriptions, parameters_numDisplayAlignments, print_cafeDescription(), print_eValue2String(), statistics_gappedCalculateEvalue(), and statistics_gappedNominal2normalized().

Referenced by blast_search().

{
        char* line;
        int4 descriptionLength;
        struct alignment* currentAlignment;
    struct finalAlignment* finalAlignment;
        struct gappedExtension* currentExtension;
        int4 count = 0;
        char* description;
    double normalizedScore, eValue;

        printf("                                                                 Score    E\n");
        printf("Sequences producing significant alignments:                      (bits) Value\n\n");

        // For each alignment
        while (count < alignments_finalAlignments->numEntries
        && count < parameters_numDisplayAlignments)
        {
        finalAlignment = memSingleBlock_getEntry(alignments_finalAlignments, count);
                currentAlignment = finalAlignment->alignment;
                currentExtension = currentAlignment->gappedExtensions;

        // Get description of subject
                if (parameters_getDescriptions)
        {
            #ifdef CAFEMODE
            description = print_cafeDescription(currentAlignment->descriptionLocation, 1);
            descriptionLength = strlen(description);
            #else
            descriptionLength = strlen(finalAlignment->description);
                description = (char*)global_malloc(sizeof(char) * (descriptionLength + 1));
            strcpy(description, finalAlignment->description);
                        #endif
        }
        else
        {
                description = (char*)global_malloc(sizeof(char)); strcpy(description, "");
            descriptionLength = 0;
                }

        // Realloc description string to length displayed
        description = (char*)global_realloc(description, sizeof(char) * 67);

        // Construct line with description, normalized score and eValue
        line = (char*)global_malloc(sizeof(char) * 90);

        // If description is more than 63 chars long
        if (descriptionLength > 63)
        {
            // Cut off end and add ...
            description[63] = '\0';
            strcat(description, "...");
        }
        else
        {
            // Otherwise pad out remaining with spaces
            while (descriptionLength < 66)
            {
                description[descriptionLength] = ' ';
                descriptionLength++;
            }
            description[descriptionLength] = '\0';
        }

        // If no gapped extensions have been performed and scored, use the alignment's
        // highest nominal score to calculate normalized score and e-value
                if (currentExtension == NULL)
                {
                normalizedScore = statistics_gappedNominal2normalized(
                              finalAlignment->highestNominalScore);
            eValue = statistics_gappedCalculateEvalue(normalizedScore);

            sprintf(line, "%s  %4.0f  %s\n", description, normalizedScore,
                                print_eValue2String(eValue));
        }
        else
        {
                        sprintf(line, "%s  %4.0f  %s\n", description, currentExtension->normalizedScore,
                                print_eValue2String(currentExtension->eValue));
                }

        printf("%s", line);

        // Free memory used constructing line
        free(line);
        free(description);

                count++;
        }
        printf("\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

void print_gappedAlignmentsFull	(	char *	query,
		struct PSSMatrix	PSSMatrix
	)

Definition at line 363 of file print.c.

References finalAlignment::alignment, alignments_finalAlignments, alignments_numClusters, blast_queryDescription, alignment::cluster, finalAlignment::description, alignment::descriptionLocation, alignment::gappedExtensions, global_malloc(), int4, memSingleBlock_getEntry(), alignment::numUnpackRegions, parameters_allClusterMembers, parameters_getDescriptions, parameters_numDisplayTracebacks, parameters_outputType, parameters_ssearch, parameters_tabular, parameters_xml, print_cafeDescription(), print_encodeGreaterLessThan(), print_formatDescription(), print_gappedExtension(), print_tabularGappedExtension(), print_untilWhitespace(), print_XMLgappedExtension(), alignment::subject, gappedExtension::subjectEnd, alignment::subjectLength, uint4, unpack_selectRegion(), unpackRegion::unpackedSubject, and alignment::unpackRegions.

Referenced by blast_search().

{
        struct alignment* alignment;
    struct finalAlignment* finalAlignment;
        struct gappedExtension* currentExtension;
        char* description, *queryDescription;
    unsigned char* subject;
        int4 count = 0, descriptionLength, hspNum;
    uint4 clusterSizes[alignments_numClusters];
    uint4 queryDescriptionLength;

    queryDescriptionLength = strlen(blast_queryDescription);
    queryDescription = (char*)global_malloc(queryDescriptionLength + 1);
    strcpy(queryDescription, blast_queryDescription);
    queryDescription = print_untilWhitespace(queryDescription);

    // Clear array of cluster sizes
    count = 0;
    while (count < alignments_numClusters)
    {
        clusterSizes[count] = 0;
        count++;
    }

        // For each alignment we are to print the traceback
    count = 0;
        while ((count < parameters_numDisplayTracebacks || parameters_numDisplayTracebacks == 0)
         && count < alignments_finalAlignments->numEntries)
        {
        finalAlignment = memSingleBlock_getEntry(alignments_finalAlignments, count);
                alignment = finalAlignment->alignment;
                if (alignment->cluster > 0)
        {
                        clusterSizes[alignment->cluster]++;
        }
        count++;
        }

    // For each alignment we are to print the traceback
    count = 0;
        while ((count < parameters_numDisplayTracebacks || parameters_numDisplayTracebacks == 0)
         && count < alignments_finalAlignments->numEntries)
        {
        finalAlignment = memSingleBlock_getEntry(alignments_finalAlignments, count);
                alignment = finalAlignment->alignment;

        // If this alignment is to be displayed
        if (parameters_allClusterMembers || alignment->cluster == 0 ||
            clusterSizes[alignment->cluster] > 0)
                {
            // Print description
            if (parameters_getDescriptions)
            {
                // If we are in cafe mode, use cafe function to get the description
                #ifdef CAFEMODE
                description = print_cafeDescription(alignment->descriptionLocation, 0);
                #else
                descriptionLength = strlen(finalAlignment->description);
                description = (char*)global_malloc(sizeof(char) * (descriptionLength + 1));
                strcpy(description, finalAlignment->description);
                #endif

                if (parameters_outputType == parameters_xml)
                {
                                        description = print_encodeGreaterLessThan(description);
                                }
                else if (parameters_outputType == parameters_tabular)
                {
                        description = print_untilWhitespace(description);
                }
                else
                {
                        description = print_formatDescription(description, 0, 11, 68);
                }
            }
            else
            {
                description = (char*)global_malloc(sizeof(char));
                strcpy(description, "");
            }

            if (parameters_outputType == parameters_xml)
            {
                printf("        <Hit>\n");
                printf("          <Hit_num>%d</Hit_num>\n", count + 1);
                printf("          <Hit_id>gnl|BL_ORD_ID|%d</Hit_id>\n", alignment->descriptionLocation);
                printf("          <Hit_def>%s</Hit_def>\n", description);
                printf("          <Hit_accession>%d</Hit_accession>\n", alignment->descriptionLocation);
                printf("          <Hit_len>%d</Hit_len>\n", alignment->subjectLength);
                printf("          <Hit_hsps>\n");
            }
            else if (parameters_outputType == parameters_tabular)
            {
            }
                        else
            {
                printf(">%s\n", description);
                if (!parameters_allClusterMembers && clusterSizes[alignment->cluster] > 1)
                {
                    printf("          [%d near-identical alignment(s) not displayed]\n",
                           clusterSizes[alignment->cluster] - 1);
                    clusterSizes[alignment->cluster] = 0;
                }
//                printf("          Length = %d DescriptionLocation = %d\n\n",
//                       alignment->subjectLength, alignment->descriptionLocation);
                        printf("          Length = %d\n\n", alignment->subjectLength);
                        }

            // Get list of gapped extensions
            currentExtension = alignment->gappedExtensions;
                        hspNum = 0;

            // For each gapped extension
            while (currentExtension != NULL)
            {
                hspNum++;

                if (parameters_ssearch)
                    subject = alignment->subject;
                else
                    // Get the unpacked subject
                    subject = unpack_selectRegion(alignment->unpackRegions, alignment->numUnpackRegions,
                                                  currentExtension->subjectEnd)->unpackedSubject;

                // Print the gapped extension
                if (parameters_outputType == parameters_xml)
                    print_XMLgappedExtension(currentExtension, PSSMatrix, query, subject, hspNum);
                else if (parameters_outputType == parameters_tabular)
                    print_tabularGappedExtension(currentExtension, PSSMatrix, query, subject,
                                                 queryDescription, description);
                else if (parameters_outputType != parameters_tabular)
                        print_gappedExtension(currentExtension, PSSMatrix, query, subject);

                currentExtension = currentExtension->next;
            }

            if (parameters_outputType == parameters_xml)
            {
                printf("          </Hit_hsps>\n");
                printf("        </Hit>\n");
                        }

            free(description);
        }

                count++;
        }

    free(queryDescription);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void print_singleSequence	(	unsigned char *	sequence,
		int4	length
	)

Definition at line 842 of file print.c.

References encoding_getLetter(), and int4.

Referenced by cluster_printCluster(), cluster_printSequence(), main(), rsdb_printCluster(), and rsdb_printSequence().

{
        int4 count = 0;
    while (count < length)
    {
                printf("%c", encoding_getLetter(sequence[count]));
        count++;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void print_XMLfooter

(

)

Definition at line 892 of file print.c.

References statisticalParameters::H, statisticalParameters::K, statisticalParameters::lambda, readdb_numberOfSequences, statistics_databaseSize, statistics_gappedParams, statistics_lengthAdjust, and statistics_searchSpaceSize.

Referenced by blast_search().

{
    printf("      </Iteration_hits>\n");
    printf("      <Iteration_stat>\n");
    printf("        <Statistics>\n");
    printf("          <Statistics_db-num>%d</Statistics_db-num>\n", readdb_numberOfSequences);
    printf("          <Statistics_db-len>%llu</Statistics_db-len>\n", statistics_databaseSize);
    printf("          <Statistics_hsp-len>%d</Statistics_hsp-len>\n", statistics_lengthAdjust);
    printf("          <Statistics_eff-space>%llu</Statistics_eff-space>\n", statistics_searchSpaceSize);
    printf("          <Statistics_kappa>%.3f</Statistics_kappa>\n", statistics_gappedParams.K);
    printf("          <Statistics_lambda>%.3f</Statistics_lambda>\n", statistics_gappedParams.lambda);
    printf("          <Statistics_entropy>%.3f</Statistics_entropy>\n", statistics_gappedParams.H);
    printf("        </Statistics>\n");
    printf("      </Iteration_stat>\n");
    printf("    </Iteration>\n");
    printf("  </BlastOutput_iterations>\n");
    printf("</BlastOutput>\n");
}

Here is the caller graph for this function:

void print_XMLheader	(	char *	query,
		struct PSSMatrix	PSSMatrix
	)

Definition at line 853 of file print.c.

References blast_queryDescription, encoding_alphabetType, encoding_protein, PSSMatrix::length, parameters_cutoff, parameters_extendGap, parameters_filterEnabled, parameters_scoringMatrix, parameters_startGap, and parameters_subjectDatabaseFile.

Referenced by blast_search().

{
        printf("<?xml version=\"1.0\"?>\n");
    printf("<!DOCTYPE BlastOutput PUBLIC \"-//NCBI//NCBI BlastOutput/EN\" \"NCBI_BlastOutput.dtd\">\n");
    printf("<BlastOutput>\n");
    if (encoding_alphabetType == encoding_protein)
                printf("  <BlastOutput_program>blastp</BlastOutput_program>\n");
        else
                printf("  <BlastOutput_program>blastn</BlastOutput_program>\n");
        printf("  <BlastOutput_version>FSA-BLAST 1.03</BlastOutput_version>\n");
    printf("  <BlastOutput_reference>~Reference: Altschul, Stephen F., Thomas L. Madden, Alejandro A. Schaffer, ~Jinghui Zhang, Zheng Zhang, Webb Miller, and David J. Lipman (1997), ~&quot;Gapped BLAST and PSI-BLAST: a new generation of protein database search~programs&quot;,  Nucleic Acids Res. 25:3389-3402.</BlastOutput_reference>\n");
        printf("  <BlastOutput_db>%s</BlastOutput_db>\n", parameters_subjectDatabaseFile);
    printf("  <BlastOutput_query-ID>lcl|QUERY</BlastOutput_query-ID>\n");
    printf("  <BlastOutput_query-def>%s</BlastOutput_query-def>\n", blast_queryDescription);
    printf("  <BlastOutput_query-len>%d</BlastOutput_query-len>\n", PSSMatrix.length);
    printf("  <BlastOutput_param>\n");
    printf("    <Parameters>\n");
    printf("      <Parameters_matrix>%s</Parameters_matrix>\n", parameters_scoringMatrix);
    printf("      <Parameters_expect>%g</Parameters_expect>\n", parameters_cutoff);
    printf("      <Parameters_gap-open>%d</Parameters_gap-open>\n", parameters_startGap);
    printf("      <Parameters_gap-extend>%d</Parameters_gap-extend>\n", parameters_extendGap);
        if (parameters_filterEnabled)
    {
        if (encoding_alphabetType == encoding_protein)
                printf("      <Parameters_filter>S</Parameters_filter>\n");
                else
                printf("      <Parameters_filter>D</Parameters_filter>\n");
    }
    else
    printf("      <Parameters_filter>F</Parameters_filter>\n");
    printf("    </Parameters>\n");
    printf("  </BlastOutput_param>\n");
    printf("  <BlastOutput_iterations>\n");
    printf("    <Iteration>\n");
    printf("      <Iteration_iter-num>1</Iteration_iter-num>\n");
    printf("      <Iteration_hits>\n");
}

Here is the caller graph for this function:

---