inc/patSpace.h File Reference

#include "dnaseq.h"

Include dependency graph for patSpace.h:

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

Go to the source code of this file.

Data Structures
struct	patClump
Functions
patSpace *	makePatSpace (struct dnaSeq **seqArray, int seqArrayCount, int seedSize, char *oocFileName, int minMatch, int maxGap)
void	freePatSpace (struct patSpace **pPatSpace)
patClump *	patSpaceFindOne (struct patSpace *ps, DNA *dna, int dnaSize)

---

Function Documentation

void freePatSpace

(

struct patSpace **

pPatSpace

)

Definition at line 68 of file patSpace.c.

References patSpace::allocated, freeMem(), and freez().

{
struct patSpace *ps = *pPatSpace;
if (ps != NULL)
    {
    freeMem(ps->allocated);
    freez(pPatSpace);
    }
}

Here is the call graph for this function:

struct patSpace* makePatSpace	(	struct dnaSeq **	seqArray,
		int	seqArrayCount,
		int	seedSize,
		char *	oocFileName,
		int	minMatch,
		int	maxGap
	)			[read]

Definition at line 247 of file patSpace.c.

References addToPatSpace(), allocPatSpaceLists(), patSpace::blocksUsed, countPatSpace(), patSpace::listSizes, maxBlockCount, patSpace::maxPat, maxPatCount, newPatSpace(), dnaSeq::next, oocMaskCounts(), oocMaskSimpleRepeats(), psBits, patSpace::seedSize, patSpace::seedSpaceSize, dnaSeq::size, and tooManyBlocks().

{
struct patSpace *ps = newPatSpace(minMatch, maxGap,seedSize);
int i;
int startIx = 0;
int total = 0;
struct dnaSeq *seq;
psBits maxPat;
psBits *listSizes;
int seedSpaceSize = ps->seedSpaceSize;

maxPat = ps->maxPat = maxPatCount;
for (i=0; i<seqArrayCount; ++i)
    {
    for (seq = seqArray[i]; seq != NULL; seq = seq->next)
        {
        total += seq->size;
        countPatSpace(ps, seq);
        }
    }

listSizes = ps->listSizes;

/* Scan through over-popular patterns and set their count to value 
 * where they won't be added to pat space. */
oocMaskCounts(oocFileName, listSizes, ps->seedSize, maxPat);

/* Get rid of simple repeats as well. */
oocMaskSimpleRepeats(listSizes, ps->seedSize, maxPat);


allocPatSpaceLists(ps);

/* Zero out pattern counts that aren't oversubscribed. */
for (i=0; i<ps->seedSpaceSize; ++i)
    {
    if (listSizes[i] < maxPat)
        listSizes[i] = 0;
    }
for (i=0; i<seqArrayCount; ++i)
    {
        int j;
    for (seq = seqArray[i], j=0; seq != NULL; seq = seq->next, ++j)
        {
        startIx = addToPatSpace(ps, i, j, seq, startIx);
        if (startIx >= maxBlockCount)
            tooManyBlocks();
        }
    }
ps->blocksUsed = startIx;

/* Zero local over-popular patterns. */
for (i=0; i<seedSpaceSize; ++i)
    {
    if (listSizes[i] >= maxPat)
        listSizes[i] = 0;
    }

return ps;
}

Here is the call graph for this function:

struct patClump* patSpaceFindOne	(	struct patSpace *	ps,
		DNA *	dna,
		int	dnaSize
	)			[read]

Definition at line 392 of file patSpace.c.

References patSpace::blocksUsed, patSpace::hitBlocks, patSpace::lists, patSpace::listSizes, patSpace::minMatch, minMatch, ntValNoN, patSpace::posBuf, psBits, and patSpace::seedSize.

Referenced by ssFindBundles().

{
int lastStart = dnaSize - ps->seedSize;
int i,j;
int pat;
int hitBlockCount = 0;
int totalSigHits = 0;
DNA *tile = dna;
int blocksUsed = ps->blocksUsed;
int *posBuf = ps->posBuf;
int *hitBlocks = ps->hitBlocks;
int minMatch = ps->minMatch;

memset(ps->posBuf, 0, sizeof(ps->posBuf[0]) * blocksUsed);
for (i=0; i<=lastStart; i += ps->seedSize)
    {
    psBits *list;
    psBits count;

    pat = 0;
    for (j=0; j<ps->seedSize; ++j)
        {
        int bVal = ntValNoN[(int)tile[j]];
        pat <<= 2;
        pat += bVal;
        }
    list = ps->lists[pat];
    if ((count = ps->listSizes[pat]) > 0)
        {
        for (j=0; j<count; ++j)
            posBuf[list[j]] += 1;            
        }
    tile += ps->seedSize;
    }

/* Scan through array that records counts of hits at positions. */
for (i=0; i<blocksUsed-1; ++i)
    {
    /* Save significant hits in a more compact array */
    int a = posBuf[i], b = posBuf[i+1];
    int sum = a + b;
    if (sum >= minMatch)
        {
        if (a > 0)
            {
            if (hitBlockCount == 0 || hitBlocks[hitBlockCount-1] != i)
                {
                hitBlocks[hitBlockCount++] = i;
                totalSigHits += a;
                }
            }
        if (b > 0)
            {
            hitBlocks[hitBlockCount++] = i+1;
            totalSigHits += b;
            }
        }
    }

/* Output data with significant hits. */
if (hitBlockCount > 0 && totalSigHits*ps->seedSize*8 > dnaSize)
    {
    return clumpHits(ps, hitBlocks, hitBlockCount, posBuf, dna, 
        dnaSize);
    }        
else
    return NULL;
}

Here is the caller graph for this function:

---