inc/supStitch.h File Reference

#include "dnaseq.h"
#include "fuzzyFind.h"
#include "patSpace.h"

Include dependency graph for supStitch.h:

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

Go to the source code of this file.

Data Structures
struct	ssFfItem
struct	ssBundle
Functions
void	ssFfItemFree (struct ssFfItem **pEl)
void	ssFfItemFreeList (struct ssFfItem **pList)
void	ssBundleFree (struct ssBundle **pEl)
void	ssBundleFreeList (struct ssBundle **pList)
void	ssStitch (struct ssBundle *bundle, enum ffStringency stringency, int minScore, int maxToReturn)
ssBundle *	ssFindBundles (struct patSpace *ps, struct dnaSeq *cSeq, char *cName, enum ffStringency stringency, boolean avoidSelfSelf)

---

Function Documentation

void ssBundleFree

(

struct ssBundle **

pEl

)

Definition at line 47 of file supStitch.c.

References ssBundle::ffList, freez(), and ssFfItemFreeList().

Referenced by foldInExtras(), gfAlignSomeClumps(), gfAlignStrand(), gfAlignTrans(), gfAlignTransTrans(), gfFindAlignAaTrans(), and ssBundleFreeList().

{
struct ssBundle *el;
if ((el = *pEl) != NULL)
    {
    ssFfItemFreeList(&el->ffList);
    freez(pEl);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ssBundleFreeList

(

struct ssBundle **

pList

)

Definition at line 58 of file supStitch.c.

References ssBundle::next, and ssBundleFree().

Referenced by addToBigBundleList().

{
struct ssBundle *el, *next;
for (el = *pList; el != NULL; el = next)
    {
    next = el->next;
    ssBundleFree(&el);
    }
*pList = NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ssFfItemFree

(

struct ssFfItem **

pEl

)

Definition at line 24 of file supStitch.c.

References ssFfItem::ff, ffFreeAli(), and freez().

Referenced by ssFfItemFreeList().

{
struct ssFfItem *el;
if ((el = *pEl) != NULL)
    {
    ffFreeAli(&el->ff);
    freez(pEl);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ssFfItemFreeList

(

struct ssFfItem **

pList

)

Definition at line 35 of file supStitch.c.

References ssFfItem::next, and ssFfItemFree().

Referenced by ssBundleFree().

{
struct ssFfItem *el, *next;
for (el = *pList; el != NULL; el = next)
    {
    next = el->next;
    ssFfItemFree(&el);
    }
*pList = NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct ssBundle* ssFindBundles	(	struct patSpace *	ps,
		struct dnaSeq *	cSeq,
		char *	cName,
		enum ffStringency	stringency,
		boolean	avoidSelfSelf
	)			[read]

Definition at line 843 of file supStitch.c.

References AllocVar, patClump::bacIx, dnaSeq::dna, ssFfItem::ff, ffFind(), findBundle(), dnaSeq::name, patClump::next, patSpaceFindOne(), sameString, patClump::seq, patClump::seqIx, patClump::size, dnaSeq::size, slAddHead, slFreeList(), and patClump::start.

{
struct patClump *clumpList, *clump;
struct ssBundle *bundleList = NULL, *bun = NULL;
DNA *cdna = cSeq->dna;
int totalCdnaSize = cSeq->size;
DNA *endCdna = cdna+totalCdnaSize;
struct ssFfItem *ffl;
struct dnaSeq *lastSeq = NULL;
int maxSize = 700;
int preferredSize = 500;
int overlapSize = 250;

for (;;)
    {
    int cSize = endCdna - cdna;
    if (cSize > maxSize)
        cSize = preferredSize;
    clumpList = patSpaceFindOne(ps, cdna, cSize);
    for (clump = clumpList; clump != NULL; clump = clump->next)
        {
        struct ffAli *ff;
        struct dnaSeq *seq = clump->seq;
        DNA *tStart = seq->dna + clump->start;
        if (!avoidSelfSelf || !sameString(seq->name, cSeq->name))
            {
            ff = ffFind(cdna, cdna+cSize, tStart, tStart + clump->size, stringency);
            if (ff != NULL)
                {
                if (lastSeq != seq)
                    {
                    lastSeq = seq;
                    if ((bun = findBundle(bundleList, seq)) == NULL)
                        {
                        AllocVar(bun);
                        bun->qSeq = cSeq;
                        bun->genoSeq = seq;
                        bun->genoIx = clump->bacIx;
                        bun->genoContigIx = clump->seqIx;
                        slAddHead(&bundleList, bun);
                        }
                    }
                AllocVar(ffl);
                ffl->ff = ff;
                slAddHead(&bun->ffList, ffl);
                }
            }
        }
    cdna += cSize;
    if (cdna >= endCdna)
        break;
    cdna -= overlapSize;
    slFreeList(&clumpList);
    }
slReverse(&bundleList);
cdna = cSeq->dna;

for (bun = bundleList; bun != NULL; bun = bun->next)
    {
    ssStitch(bun, stringency, 20, 16);
    }
return bundleList;
}

Here is the call graph for this function:

void ssStitch	(	struct ssBundle *	bundle,
		enum ffStringency	stringency,
		int	minScore,
		int	maxToReturn
	)

Definition at line 748 of file supStitch.c.

References AllocVar, ssBundle::avoidFuzzyFindKludge, cutAtBigIntrons(), dnaSeq::dna, FALSE, ssFfItem::ff, ffAliSort(), ffCat(), ffCdna, ffCmpHitsNeedleFirst(), ffFreeAli(), ffIntronMax, ffIntronMaxDefault, ssBundle::ffList, ffMergeClose(), ffMergeHayOverlaps(), ffMergeNeedleAlis(), ffRemoveEmptyAlis(), ffSlideIntrons(), forceMonotonic(), ssBundle::genoSeq, ssBundle::isProt, ssFfItem::next, ssBundle::qSeq, slAddHead, slFreeList(), slReverse(), smallMiddleExons(), ssFindBest(), ssBundle::t3List, and TRUE.

Referenced by ffSeedExtInMem(), foldInExtras(), gfAlignSomeClumps(), gfAlignStrand(), gfAlignTrans(), gfAlignTransTrans(), gfClumpsToBundles(), gfFindAlignAaTrans(), gfTransTransFindBundles(), and refineBundle().

{
struct dnaSeq *qSeq =  bundle->qSeq;
struct dnaSeq *genoSeq = bundle->genoSeq;
struct ffAli *ffList = NULL;
struct ssFfItem *ffl;
struct ffAli *bestPath;
int score;
boolean firstTime = TRUE;

if (bundle->ffList == NULL)
    return;

/* The score may improve when we stitch together more alignments,
 * so don't let minScore be too harsh at this stage. */
if (minScore > 20)
    minScore = 20;

/* Create ffAlis for all in bundle and move to one big list. */
for (ffl = bundle->ffList; ffl != NULL; ffl = ffl->next)
    {
    ffCat(&ffList, &ffl->ff);
    }
slFreeList(&bundle->ffList);

ffAliSort(&ffList, ffCmpHitsNeedleFirst);
ffList = ffMergeClose(ffList, qSeq->dna, genoSeq->dna);

while (ffList != NULL)
    {
    ssFindBest(ffList, qSeq, genoSeq, stringency, 
        bundle->isProt, bundle->t3List,
        &bestPath, &score, &ffList);

    bestPath = ffMergeNeedleAlis(bestPath, TRUE);
    bestPath = ffRemoveEmptyAlis(bestPath, TRUE);
    bestPath = ffMergeHayOverlaps(bestPath);
    bestPath = ffRemoveEmptyAlis(bestPath, TRUE);
    bestPath = forceMonotonic(bestPath, qSeq, genoSeq, stringency,
        bundle->isProt, bundle->t3List);

    if (firstTime && stringency == ffCdna && bundle->avoidFuzzyFindKludge == FALSE)
        {
        /* Only look for middle exons the first time.  Next times
         * this might regenerate most of the first alignment... */
        bestPath = smallMiddleExons(bestPath, bundle, stringency);
        }
    bestPath = ffMergeNeedleAlis(bestPath, TRUE);
    if (ffIntronMax != ffIntronMaxDefault)
        {
        bestPath = cutAtBigIntrons(bestPath, ffIntronMax, &score, stringency,
                &ffList);
        }
    if (!bundle->isProt)
        ffSlideIntrons(bestPath);
    bestPath = ffRemoveEmptyAlis(bestPath, TRUE);
    if (score >= minScore)
        {
        AllocVar(ffl);
        ffl->ff = bestPath;
        slAddHead(&bundle->ffList, ffl);
        }
    else
        {
        ffFreeAli(&bestPath);
        ffFreeAli(&ffList);
        break;
        }
    firstTime = FALSE;
    if (--maxToReturn <= 0)
        {
        ffFreeAli(&ffList);
        break;
        }
    }
slReverse(&bundle->ffList);
return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

---