include/wildcards.h File Reference

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

Go to the source code of this file.

Data Structures
struct	clusterWildcard
struct	wild
Defines
#define	setbit(i, pos)   (i |= (1 << pos))
#define	getbit(i, pos)   (i & (1 << pos))
#define	wildcards_numClusterWildcards   7
Functions
void	wildcards_initialize ()
void	wildcards_printWildcard (uint4 wildcard)
float	wildcards_scoreCandidates (struct wild *wildCandidates, uint4 numWildCandidates, struct wild *wilds, uint4 numWilds, float defaultWildscore)
wild *	wildcards_getSubset (struct wild wildCandidate, struct wild *wilds, uint4 numWilds, uint4 *sizeWildSubset, uint4 *numOccurences)
float	wildcards_averageResidueWildMatch (struct wild wildCandidate, struct wild *wilds, uint4 numWilds)
float	wildcards_scoreResidueWildMatch (struct wild wildCandidate, struct wild *wilds, uint4 numWilds, uint4 code)
wild *	wildcards_joinSubset (struct wild *set1, uint4 *size1, struct wild *set2, uint4 size2)
void	wildcards_removeSubset (struct wild *set1, uint4 *size1, struct wild *set2, uint4 size2, uint4 *numOccurences)
void	wildcards_outputWildcards (char *filename)
void	wildcards_readWildcards (char *filename)
void	wildcards_initializeCountOccurences (uint4 longestSequenceLength)
void	wildcards_countOccurences (struct child *children, uint4 numChildren, uint4 sequenceLength)
wild *	wildcards_getOccurences (uint4 *numWilds)
Variables
scoreMatrix	wildcards_scoreMatrix
int	wildcards_printWilds
float	wildcards_scoringConstant
int2	wildcards_scoreMatrixRow [encoding_aaStartWildcards]
clusterWildcard	wildcards_clusterWildcards [wildcards_numClusterWildcards]

---

Define Documentation

#define getbit	(	i,
		pos		)	(i & (1 << pos))

Definition at line 19 of file wildcards.h.

Referenced by chooseWilds_printOccurenceMatrix(), cluster_addChild(), cluster_averageWildcodeScore(), cluster_score(), wildcards_countBits(), wildcards_outputWildcards(), wildcards_printWildcard(), and wildcards_scoreResidueWildMatch().

#define setbit	(	i,
		pos		)	(i |= (1 << pos))

Definition at line 18 of file wildcards.h.

Referenced by cluster_addChild(), cluster_score(), main(), wildcards_countOccurences(), and wildcards_initialize().

#define wildcards_numClusterWildcards   7

Definition at line 20 of file wildcards.h.

Referenced by cluster_addChild(), cluster_score(), cluster_writeClusters(), main(), scoreMatrix_load(), wildcards_initialize(), wildcards_outputWildcards(), and wildcards_readWildcards().

---

Function Documentation

float wildcards_averageResidueWildMatch	(	struct wild	wildCandidate,
		struct wild *	wilds,
		uint4	numWilds
	)

Definition at line 267 of file wildcards.c.

References wild::code, encoding_numLetters, Robinson_prob, wildcards_scoreMatrixRow, and wildcards_scoreResidueWildMatch().

Referenced by main(), and wildcards_scoreCandidates().

{
        unsigned char code;
        float score, averageScore = 0;

    code = 0;
    while (code < encoding_numLetters)
    {
        // Get score for aligning residue 'code' with wildcard
        score = wildcards_scoreResidueWildMatch(wildCandidate, wilds, numWilds, code);
        averageScore += score * (Robinson_prob[code] / 1000.0);

        wildcards_scoreMatrixRow[code] = ceil(score - 0.5);

        code++;
    }

    return averageScore;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void wildcards_countOccurences	(	struct child *	children,
		uint4	numChildren,
		uint4	sequenceLength
	)

Definition at line 361 of file wildcards.c.

References edit::code, wild::count, child::edits, child::numEdits, edit::position, child::regionStart, setbit, uint4, wildcards_numWilds, wildcards_wildCount, and wildcards_wildPositions.

Referenced by cluster_writeClusters(), and main().

{
        uint4 childNum, count, position;
    struct edit* edits;
    struct child* child;
    uint4 numEdits;

    // For each child
    childNum = 0;
    while (childNum < numChildren)
    {
        child = children + childNum;

        edits = child->edits;
        numEdits = child->numEdits;

        // For each edit
        count = 0;
        while (count < child->numEdits)
        {
            // Set bit for this code appearing at this position
            position = edits->position + child->regionStart;
            setbit(wildcards_wildPositions[position], edits->code);

            edits++;
            count++;
        }

        childNum++;
    }

    // Increment count for each wildcard code and clear position counts
    position = 0;
    while (position < sequenceLength)
    {
        if (wildcards_wildPositions[position])
        {
            if (!wildcards_wildCount[wildcards_wildPositions[position]])
                wildcards_numWilds++;
            wildcards_wildCount[wildcards_wildPositions[position]]++;

            wildcards_wildPositions[position] = 0;
        }
        position++;
    }
}

Here is the caller graph for this function:

struct wild* wildcards_getOccurences

(

uint4 *

numWilds

)

[read]

Definition at line 409 of file wildcards.c.

References wild::code, wild::count, global_malloc(), uint4, wildcards_numWildCodes, wildcards_numWilds, wildcards_wildCount, and wildcards_wildPositions.

Referenced by cluster_writeClusters(), and main().

{
        uint4 count, wildCode;
        struct wild* wilds;

    // Construct list of wilds
    wilds = (struct wild*)global_malloc(sizeof(struct wild) * wildcards_numWilds);
    count = 0; wildCode = 0;
    while (wildCode < wildcards_numWildCodes)
    {
                if (wildcards_wildCount[wildCode])
        {
                        wilds[count].code = wildCode;
                        wilds[count].count = wildcards_wildCount[wildCode];
//                      printf("(%d) %4d: ", count, wilds[count].count);
//            wildcards_printWildcard(wildCode);
            count++;
        }
        wildCode++;
    }

    *numWilds = wildcards_numWilds;

    free(wildcards_wildPositions);
    free(wildcards_wildCount);

    return wilds;
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct wild* wildcards_getSubset	(	struct wild	wildCandidate,
		struct wild *	wilds,
		uint4	numWilds,
		uint4 *	sizeWildSubset,
		uint4 *	numOccurences
	)			[read]

Definition at line 223 of file wildcards.c.

References wild::code, wild::count, global_malloc(), and uint4.

Referenced by main(), and wildcards_scoreCandidates().

{
        struct wild *wildSubset;
        uint4 count = 0;

    // Calculate size of subset
    *sizeWildSubset = 0;
    while (count < numWilds)
    {
        if ((wilds[count].code & wildCandidate.code) == wilds[count].code)
                        (*sizeWildSubset)++;
                count++;
    }

    // Build subset
        wildSubset = (struct wild*)global_malloc(sizeof(struct wild) * (*sizeWildSubset));
        count = 0; *sizeWildSubset = 0;
    while (count < numWilds)
    {
        if ((wilds[count].code & wildCandidate.code) == wilds[count].code)
        {
//                      printf("%4d: ", wilds[count].count);
//                  wildcards_printWildcard(wilds[count].code);

            wildSubset[*sizeWildSubset] = wilds[count];
                        (*sizeWildSubset)++;
                }
        count++;
    }

    // Calculate total number of occurences of wildcard candidate
    count = 0;
    *numOccurences = 0;
    while (count < *sizeWildSubset)
    {
        *numOccurences += wildSubset[count].count;
        count++;
    }

    return wildSubset;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void wildcards_initialize

(

)

Definition at line 28 of file wildcards.c.

References encoding_getCode(), clusterWildcard::letters, setbit, uint4, wildcards_clusterWildcards, wildcards_numClusterWildcards, and clusterWildcard::wildCode.

Referenced by main().

{
        uint4 count, wildCode;
        unsigned char *letters, code;
    struct clusterWildcard *clusterWildcard;

    // For each of the cluster wildcards
    count = 0;
    while (count < wildcards_numClusterWildcards)
    {
        wildCode = 0;
                clusterWildcard = wildcards_clusterWildcards + count;

        // For each code
        letters = clusterWildcard->letters;
        while (*letters != '\0')
        {
                // Set bit in wildcode
                        code = encoding_getCode(*letters);
            setbit(wildCode, code);
                letters++;
        }

        clusterWildcard->wildCode = wildCode;

        count++;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void wildcards_initializeCountOccurences

(

uint4

longestSequenceLength

)

Definition at line 334 of file wildcards.c.

References encoding_numLetters, global_malloc(), uint4, wildcards_numWildCodes, wildcards_numWilds, wildcards_wildCount, and wildcards_wildPositions.

Referenced by cluster_writeClusters(), and main().

{
        uint4 position, wildCode;

    // Initialize array for recording wildcard position edits
    wildcards_wildPositions = (uint4*)global_malloc(sizeof(uint4) * longestSequenceLength);
        position = 0;
    while (position < longestSequenceLength)
    {
        wildcards_wildPositions[position] = 0;
        position++;
    }

    // Initialize array for count wilding occurences
    wildcards_numWildCodes = ceil(pow(2, encoding_numLetters));
    wildcards_wildCount = (uint4*)global_malloc(sizeof(uint4) * wildcards_numWildCodes);
    wildCode = 0;
    while (wildCode < wildcards_numWildCodes)
    {
                wildcards_wildCount[wildCode] = 0;
        wildCode++;
    }

    wildcards_numWilds = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct wild* wildcards_joinSubset	(	struct wild *	set1,
		uint4 *	size1,
		struct wild *	set2,
		uint4	size2
	)			[read]

Definition at line 214 of file wildcards.c.

References global_realloc().

Referenced by wildcards_scoreCandidates().

{
        set1 = (struct wild*)global_realloc(set1, sizeof(struct wild) * (*size1 + size2));
    memcpy(set1 + *size1, set2, size2 * sizeof(struct wild));
        (*size1) += size2;
        return set1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void wildcards_outputWildcards

(

char *

filename

)

Definition at line 494 of file wildcards.c.

References wild::code, wild::count, encoding_aaStartWildcards, encoding_getLetter(), encoding_numLetters, getbit, uint4, wildcards_clusterWildcards, and wildcards_numClusterWildcards.

Referenced by cluster_writeClusters(), and main().

{
        uint4 count = 0;
    unsigned char code = 0;
    FILE* file;

        // Open file for writing
        if ((file = fopen(filename, "w")) == NULL)
        {
                fprintf(stderr, "Error opening file %s for writing\n", filename);
                exit(-1);
        }

    // Sort wildcards in increasing order of average/expected score
//      qsort(wildcards_clusterWildcards, wildcards_numClusterWildcards,
//          sizeof(struct clusterWildcard), wildcards_compareClusterWildcards);

        // For each wildcard in order of average score
    while (count < wildcards_numClusterWildcards)
    {
        // Print letters
        code = 0;
        while (code < encoding_numLetters)
        {
            if (getbit(wildcards_clusterWildcards[count].wildCode, code))
            {
                fprintf(file, "%c", encoding_getLetter(code));
            }
            code++;
        }

        // Print details
                fprintf(file, ",%d,[", wildcards_clusterWildcards[count].wildCode);

        // Print scores
        code = 0;
        while (code < encoding_aaStartWildcards)
        {
                fprintf(file, "%d", wildcards_clusterWildcards[count].scoreMatrixRow[code]);
                code++;

            if (code < encoding_aaStartWildcards)
                fprintf(file, ",");
        }

                fprintf(file, "],%f\n", wildcards_clusterWildcards[count].averageScore);

        count++;
    }

    fclose(file);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void wildcards_printWildcard

(

uint4

wildcard

)

Definition at line 548 of file wildcards.c.

References wild::code, encoding_getLetter(), encoding_numLetters, getbit, and uint4.

Referenced by cluster_addChild(), and main().

{
        uint4 code = 0;

    while (code < encoding_numLetters)
    {
        if (getbit(wildcard, code))
        {
                printf("%c", encoding_getLetter(code));
        }
        code++;
    }
    printf("\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

void wildcards_readWildcards

(

char *

filename

)

Definition at line 439 of file wildcards.c.

References wild::code, wild::count, encoding_aaStartWildcards, global_malloc(), clusterWildcard::letters, uint4, wildcards_clusterWildcards, and wildcards_numClusterWildcards.

Referenced by main(), and readdb_open().

{
    FILE* file;
        uint4 count = 0, letterCount;
    unsigned char code = 0;
    char* letters;

        // Open file for reading
        if ((file = fopen(filename, "r")) == NULL)
        {
                // If this fails, simply return
        return;
        }

    letters = (char*)global_malloc(encoding_aaStartWildcards + 1);

        // For each wildcard in order of average score
    while (count < wildcards_numClusterWildcards)
    {
        // Read letters
        letterCount = 0;
        while (1)
        {
                fscanf(file, "%c", letters + letterCount);
                        if (letters[letterCount] == ',')
                break;
                        letterCount++;
        }
        letters[letterCount] = '\0';
                wildcards_clusterWildcards[count].letters = letters;

        // Read details
                fscanf(file, "%d,[", &(wildcards_clusterWildcards[count].wildCode));

        // Print scores
        code = 0;
        while (code < encoding_aaStartWildcards)
        {
                fscanf(file, "%d", &(wildcards_clusterWildcards[count].scoreMatrixRow[code]));
                code++;

            if (code < encoding_aaStartWildcards)
                fscanf(file, ",");
        }

                fscanf(file, "],%f\n", &(wildcards_clusterWildcards[count].averageScore));

        count++;
    }

    free(letters);
    fclose(file);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void wildcards_removeSubset	(	struct wild *	set1,
		uint4 *	size1,
		struct wild *	set2,
		uint4	size2,
		uint4 *	numOccurences
	)

Definition at line 179 of file wildcards.c.

References wild::count, and uint4.

Referenced by wildcards_scoreCandidates().

{
        uint4 newSize1, count1, count2, match;

    // For each wild in set1
    *numOccurences = 0;
    count1 = 0; newSize1 = 0;
    while (count1 < *size1)
    {
        // Determine if also occurs in set2
        match = 0; count2 = 0;
        while (count2 < size2)
        {
                        if (set1[count1].code == set2[count2].code)
                match = 1;
                count2++;
        }

        // Only keep if does not appear in set2
        if (!match)
        {
                set1[newSize1] = set1[count1];
            newSize1++;

            *numOccurences += set1[count1].count;
        }

        count1++;
    }

    *size1 = newSize1;
}

Here is the caller graph for this function:

float wildcards_scoreCandidates	(	struct wild *	wildCandidates,
		uint4	numWildCandidates,
		struct wild *	wilds,
		uint4	numWilds,
		float	defaultWildscore
	)

Definition at line 99 of file wildcards.c.

References clusterWildcard::averageScore, wild::code, encoding_numLetters, global_malloc(), int2, uint4, wildcards_averageResidueWildMatch(), wildcards_clusterWildcards, wildcards_getSubset(), wildcards_joinSubset(), wildcards_removeSubset(), wildcards_scoreMatrixRow, and clusterWildcard::wildCode.

Referenced by cluster_writeClusters(), and main().

{
        struct wild* wildSubset, wildCandidate, *pastSubsets = NULL, *wildCandidates;
    uint4 sizeWildSubset, sizePastSubsets = 0;
        float score, totalSaving = 0;
    uint4 numOccurences, candidateNum = 0;

    wildCandidates = (struct wild*)global_malloc(sizeof(struct wild) * numWildCandidates);
    memcpy(wildCandidates, originalWildCandidates, sizeof(struct wild) * numWildCandidates);

    // Sort wild candidates
//      qsort(wildCandidates, numWildCandidates, sizeof(struct wild), wildcards_compareWilds);

    // For each wild candidate from shortest to longest
    while (candidateNum < numWildCandidates)
    {
        wildCandidate = wildCandidates[candidateNum];
//        wildcards_printWildcard(wildCandidate.code);

        // Get subset of candidate wildcard
        wildSubset = wildcards_getSubset(wildCandidate, wilds, numWilds, &sizeWildSubset, &numOccurences);

        // Remove already process wildcards from subset
        wildcards_removeSubset(wildSubset, &sizeWildSubset, pastSubsets, sizePastSubsets, &numOccurences);

//        printf("wildSubset=%d\n", sizeWildSubset); fflush(stdout);
        score = wildcards_averageResidueWildMatch(wildCandidate, wildSubset, sizeWildSubset);
//        printf("Average score=%f occurences=%d defScore=%f\n", score, numOccurences, defaultWildscore);
//        printf("Total saving: %f\n", (defaultWildscore - score) * numOccurences);
        totalSaving += (defaultWildscore - score) * numOccurences;

        // Add to past subsets
        pastSubsets = wildcards_joinSubset(pastSubsets, &sizePastSubsets,
                                             wildSubset, sizeWildSubset);

                // Update cluster wildcards
                memcpy(wildcards_clusterWildcards[candidateNum].scoreMatrixRow, wildcards_scoreMatrixRow,
               sizeof(int2) * encoding_numLetters);

                wildcards_clusterWildcards[candidateNum].averageScore = score;
                wildcards_clusterWildcards[candidateNum].wildCode = wildCandidate.code;

        free(wildSubset);

        candidateNum++;
        }

/*    printf("Processed wildcards:\n");
    count = 0;
    while (count < sizePastSubsets)
    {
                wildcards_printWildcard(pastSubsets[count].code);
        count++;
    }*/

    free(pastSubsets);
    free(wildCandidates);

    return totalSaving;
}

Here is the call graph for this function:

Here is the caller graph for this function:

float wildcards_scoreResidueWildMatch	(	struct wild	wildCandidate,
		struct wild *	wilds,
		uint4	numWilds,
		uint4	code
	)

Definition at line 289 of file wildcards.c.

References wild::code, constants_sentinalScore, wild::count, encoding_numLetters, getbit, int4, scoreMatrix::matrix, wildcards_scoreMatrix, and wildcards_scoringConstant.

Referenced by wildcards_averageResidueWildMatch().

{
        int4 wildCount = 0;
    int4 wildResidue, bestScore;
    float averageScore, totalScore = 0, totalCount = 0;

    // For each wild
    while (wildCount < numWilds)
    {
                // Determine the highest scoring matching residue in this wild
        bestScore = constants_sentinalScore;
                wildResidue = 0;
        while (wildResidue < encoding_numLetters)
        {
                        if (getbit(wilds[wildCount].code, wildResidue) &&
                wildcards_scoreMatrix.matrix[code][wildResidue] > bestScore)
            {
                bestScore = wildcards_scoreMatrix.matrix[code][wildResidue];
            }

                wildResidue++;
        }
//              wildcards_printWildcard(wilds[wildCount].code);
//        printf("[%d,%d]\n", wilds[wildCount].count, bestScore);

                totalScore += ((int4)wilds[wildCount].count * bestScore);
        totalCount += wilds[wildCount].count;

        wildCount++;
    }

    averageScore = (float)totalScore / (float)totalCount;

    // If code is included in wildcandidate, adjust score
    if (getbit(wildCandidate.code, code))
    {
        averageScore = wildcards_scoringConstant * wildcards_scoreMatrix.matrix[code][code]
                     + (1 - wildcards_scoringConstant) * averageScore;
    }

    return averageScore;
}

Here is the caller graph for this function:

---

Variable Documentation

struct clusterWildcard wildcards_clusterWildcards[wildcards_numClusterWildcards]

Definition at line 16 of file wildcards.c.

Referenced by cluster_addChild(), cluster_score(), cluster_writeClusters(), scoreMatrix_load(), wildcards_initialize(), wildcards_outputWildcards(), wildcards_readWildcards(), and wildcards_scoreCandidates().

int wildcards_printWilds

Definition at line 11 of file wildcards.c.

struct scoreMatrix wildcards_scoreMatrix

Definition at line 10 of file wildcards.c.

Referenced by cluster_averageWildcodeScore(), main(), and wildcards_scoreResidueWildMatch().

int2 wildcards_scoreMatrixRow[encoding_aaStartWildcards]

Definition at line 13 of file wildcards.c.

Referenced by wildcards_averageResidueWildMatch(), and wildcards_scoreCandidates().

float wildcards_scoringConstant

Definition at line 12 of file wildcards.c.

Referenced by main(), and wildcards_scoreResidueWildMatch().

---