inc/genoFind.h File Reference

#include "dnaseq.h"
#include "fuzzyFind.h"
#include "hash.h"
#include "localmem.h"
#include "axt.h"

Include dependency graph for genoFind.h:

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

Go to the source code of this file.

Data Structures
struct	gfSeqSource
struct	gfHit
struct	gfClump
struct	genoFind
struct	gfOutput
Defines
#define	gfVersion   "34"
Enumerations
enum	gfConstants {   gfMinMatch = 2, gfMaxGap = 2, gfTileSize = 11, gfMaxTileUse = 1024,   gfPepMaxTileUse = 30000 }
Functions
void	gfClumpFree (struct gfClump **pClump)
void	gfClumpFreeList (struct gfClump **pList)
void	genoFindFree (struct genoFind **pGenoFind)
gfSeqSource *	gfFindNamedSource (struct genoFind *gf, char *name)
gfOutput *	gfOutputAny (char *format, int goodPpt, boolean qIsProt, boolean tIsProt, boolean noHead, char *databaseName, int databaseSeqCount, double databaseLetters, double minIdentity, FILE *f)
gfOutput *	gfOutputPsl (int goodPpt, boolean qIsProt, boolean tIsProt, FILE *f, boolean saveSeq, boolean noHead)
gfOutput *	gfOutputAxt (int goodPpt, boolean qIsProt, boolean tIsProt, FILE *f)
gfOutput *	gfOutputAxtMem (int goodPpt, boolean qIsProt, boolean tIsProt)
gfOutput *	gfOutputBlast (int goodPpt, boolean qIsProt, boolean tIsProt, char *databaseName, int databaseSeqCount, double databaseLetters, char *blastType, double minIdentity, FILE *f)
void	gfOutputQuery (struct gfOutput *out, FILE *f)
void	gfOutputHead (struct gfOutput *out, FILE *f)
void	gfOutputFree (struct gfOutput **pOut)
void	gfCheckTileSize (int tileSize, boolean isPep)
genoFind *	gfIndexSeq (bioSeq *seqList, int minMatch, int maxGap, int tileSize, int maxPat, char *oocFile, boolean isPep, boolean allowOneMismatch, boolean maskUpper, int stepSize)
genoFind *	gfIndexNibsAndTwoBits (int fileCount, char *fileNames[], int minMatch, int maxGap, int tileSize, int maxPat, char *oocFile, boolean allowOneMismatch, int stepSize)
void	gfIndexTransNibsAndTwoBits (struct genoFind *transGf[2][3], int fileCount, char *fileNames[], int minMatch, int maxGap, int tileSize, int maxPat, char *oocFile, boolean allowOneMismatch, boolean mask, int stepSize)
gfClump *	gfFindClumps (struct genoFind *gf, struct dnaSeq *seq, struct lm *lm, int *retHitCount)
gfClump *	gfFindClumpsWithQmask (struct genoFind *gf, bioSeq *seq, Bits *qMaskBits, int qMaskOffset, struct lm *lm, int *retHitCount)
gfHit *	gfFindHitsInRegion (struct genoFind *gf, bioSeq *seq, Bits *qMaskBits, int qMaskOffset, struct lm *lm, struct gfSeqSource *target, int tMin, int tMax)
void	gfTransFindClumps (struct genoFind *gfs[3], aaSeq *seq, struct gfClump *clumps[3], struct lm *lm, int *retHitCount)
void	gfTransTransFindClumps (struct genoFind *gfs[3], aaSeq *seqs[3], struct gfClump *clumps[3][3], struct lm *lm, int *retHitCount)
void	gfClumpDump (struct genoFind *gf, struct gfClump *clump, FILE *f)
void	gfAlignAaClumps (struct genoFind *gf, struct gfClump *clumpList, aaSeq *seq, boolean isRc, int minMatch, struct gfOutput *out)
void	gfFindAlignAaTrans (struct genoFind *gfs[3], aaSeq *qSeq, struct hash *t3Hash, boolean tIsRc, int minMatch, struct gfOutput *out)
char *	gfSignature ()
void	gfCatchPipes ()
int	gfReadMulti (int sd, void *vBuf, size_t size)
hash *	gfFileCacheNew ()
void	gfFileCacheFree (struct hash **pCache)
void	gfAlignStrand (int *pConn, char *nibDir, struct dnaSeq *seq, boolean isRc, int minMatch, struct hash *tFileCache, struct gfOutput *out)
void	gfAlignTrans (int *pConn, char *nibDir, aaSeq *seq, int minMatch, struct hash *tFileHash, struct gfOutput *out)
void	gfAlignTransTrans (int *pConn, char *nibDir, struct dnaSeq *seq, boolean qIsRc, int minMatch, struct hash *tFileCache, struct gfOutput *out, boolean isRna)
int	gfConnect (char *hostName, char *portName)
void	gfMakeOoc (char *outName, char *files[], int fileCount, int tileSize, bits32 maxPat, enum gfType tType)
void	gfLongDnaInMem (struct dnaSeq *query, struct genoFind *gf, boolean isRc, int minScore, Bits *qMaskBits, struct gfOutput *out, boolean fastMap, boolean band)
void	gfLongTransTransInMem (struct dnaSeq *query, struct genoFind *gfs[3], struct hash *t3Hash, boolean qIsRc, boolean tIsRc, boolean qIsRna, int minScore, struct gfOutput *out)
gfClump *	gfPcrClumps (struct genoFind *gf, char *fPrimer, int fPrimerSize, char *rPrimer, int rPrimerSize, int minDistance, int maxDistance)

---

Define Documentation

#define gfVersion   "34"

Definition at line 377 of file genoFind.h.

Referenced by startServer(), tabBlastOut(), and usage().

---

Enumeration Type Documentation

enum gfConstants

Enumerator:

gfMinMatch
gfMaxGap
gfTileSize
gfMaxTileUse
gfPepMaxTileUse

Definition at line 36 of file genoFind.h.

                 {
    gfMinMatch = 2,
    gfMaxGap = 2,
    gfTileSize = 11,
    gfMaxTileUse = 1024,
    gfPepMaxTileUse = 30000,
};

---

Function Documentation

void genoFindFree

(

struct genoFind **

pGenoFind

)

Definition at line 67 of file genoFind.c.

References genoFind::allocated, bitFree(), freeMem(), freez(), genoFind::lists, genoFind::listSizes, gfSeqSource::maskedBits, genoFind::sourceCount, and genoFind::sources.

Referenced by bigBlat(), genoFindDirect(), genoPcrDirect(), and gfMakeOoc().

{
struct genoFind *gf = *pGenoFind;
int i;
struct gfSeqSource *sources;
if (gf != NULL)
    {
    freeMem(gf->lists);
    freeMem(gf->listSizes);
    freeMem(gf->allocated);
    if ((sources = gf->sources) != NULL)
        {
        for (i=0; i<gf->sourceCount; ++i)
            bitFree(&sources[i].maskedBits);
        freeMem(sources);
        }
    freez(pGenoFind);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gfAlignAaClumps	(	struct genoFind *	gf,
		struct gfClump *	clumpList,
		aaSeq *	seq,
		boolean	isRc,
		int	minMatch,
		struct gfOutput *	out
	)

Definition at line 913 of file gfBlatLib.c.

References ffTight, gfAlignSomeClumps(), and TRUE.

Referenced by searchOneProt().

{
gfAlignSomeClumps(gf, clumpList, seq, isRc, minMatch, out, TRUE, ffTight);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gfAlignStrand	(	int *	pConn,
		char *	nibDir,
		struct dnaSeq *	seq,
		boolean	isRc,
		int	minMatch,
		struct hash *	tFileCache,
		struct gfOutput *	out
	)

Definition at line 552 of file gfBlatLib.c.

References alignComponents(), AllocVar, FALSE, ffCdna, ffIntronMax, freeDnaSeq(), getTargetName(), gfiExpandAndLoadCached(), gfQuerySeq(), gfRangeCmpTarget(), gfRangeFreeList(), gfRangesBundle(), gfOutput::includeTargetFile, range::next, PATH_LEN, rangeList, saveAlignments(), dnaSeq::size, slSort(), ssAliCount, ssBundleFree(), and ssStitch().

Referenced by doBlat(), and gfClient().

{
struct ssBundle *bun;
struct gfRange *rangeList = NULL, *range;
struct dnaSeq *targetSeq;
char targetName[PATH_LEN];

rangeList = gfQuerySeq(*pConn, seq);
close(*pConn);
*pConn = -1;
slSort(&rangeList, gfRangeCmpTarget);
/* Dump range list to file for debugging. */
rangeList = gfRangesBundle(rangeList, ffIntronMax);
for (range = rangeList; range != NULL; range = range->next)
    {
    getTargetName(range->tName, out->includeTargetFile, targetName);
    targetSeq = gfiExpandAndLoadCached(range, tFileCache, tSeqDir, 
        seq->size, &range->tTotalSize, FALSE, FALSE, usualExpansion);
    AllocVar(bun);
    bun->qSeq = seq;
    bun->genoSeq = targetSeq;
    alignComponents(range, bun, ffCdna);
    ssStitch(bun, ffCdna, minMatch, ssAliCount);
    saveAlignments(targetName, range->tTotalSize, range->tStart, 
        bun, NULL, isRc, FALSE, ffCdna, minMatch, out);
    ssBundleFree(&bun);
    freeDnaSeq(&targetSeq);
    }
gfRangeFreeList(&rangeList);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gfAlignTrans	(	int *	pConn,
		char *	nibDir,
		aaSeq *	seq,
		int	minMatch,
		struct hash *	tFileHash,
		struct gfOutput *	out
	)

Definition at line 1042 of file gfBlatLib.c.

References AllocVar, clumpTargetName(), clumpToHspRange(), trans3::end, FALSE, ffCdna, ffIntronMax, ssBundle::ffList, freeDnaSeqList(), freeHash(), freeMem(), ssBundle::genoSeq, getTargetName(), gfClumpFreeList(), gfQuerySeqTrans(), gfRangeCmpTarget(), gfRangeFreeList(), gfRangesBundle(), gfRangesToFfItem(), hashMustFindVal(), gfOutput::includeTargetFile, ssBundle::isProt, lm, lmCleanup(), lmInit(), loadHashT3Ranges(), gfSeqSource::next, slRef::next, gfClump::next, trans3::nibSize, PATH_LEN, ssBundle::qSeq, rangeCoorTimes3(), rangeList, saveAlignments(), trans3::seq, seqClumpToRangeList(), dnaSeq::size, slCat(), slFreeList(), slReverse(), slSort(), ss, ssAliCount, ssBundleFree(), ssStitch(), trans3::start, ssBundle::t3List, gfClump::target, gfClump::tEnd, tileSize, trans3::trans, trans3Find(), trans3Free(), TRUE, and gfClump::tStart.

Referenced by doBlat(), and gfClient().

{
struct ssBundle *bun;
struct gfClump *clumps[2][3], *clump;
struct gfRange *rangeList = NULL, *range, *rl;
struct dnaSeq *targetSeq, *tSeqList = NULL;
char targetName[PATH_LEN];
int tileSize;
int frame, isRc = 0;
struct hash *t3Hash = NULL;
struct slRef *t3RefList = NULL, *ref;
struct gfSeqSource *ssList = NULL, *ss;
struct trans3 *t3;
struct lm *lm = lmInit(0);

/* Get clumps from server. */
gfQuerySeqTrans(*pConn, seq, clumps, lm, &ssList, &tileSize);
close(*pConn);
*pConn = -1;

for (isRc = 0; isRc <= 1;  ++isRc)
    {
    /* Figure out which parts of sequence we need to load. */
    for (frame = 0; frame < 3; ++frame)
        {
        rl = seqClumpToRangeList(clumps[isRc][frame], frame);
        rangeList = slCat(rangeList, rl);
        }
    /* Convert from amino acid to nucleotide coordinates. */
    rangeCoorTimes3(rangeList);
    slSort(&rangeList, gfRangeCmpTarget);
    rangeList = gfRangesBundle(rangeList, ffIntronMax);
    loadHashT3Ranges(rangeList, tSeqDir, tFileCache, seq->size, 
        isRc, &t3Hash, &tSeqList, &t3RefList);

    /* The old range list was not very precise - it was just to get
     * the DNA loaded.  */
    gfRangeFreeList(&rangeList);


    /* Patch up clump list and associated sequence source to refer
     * to bits of genome loaded into memory.  Create new range list
     * by extending hits in clumps. */
    for (frame = 0; frame < 3; ++frame)
        {
        for (clump = clumps[isRc][frame]; clump != NULL; clump = clump->next)
            {
            struct gfSeqSource *ss = clump->target;
            t3 = trans3Find(t3Hash, clumpTargetName(clump), clump->tStart*3, clump->tEnd*3);
            ss->seq = t3->trans[frame];
            ss->start = t3->start/3;
            ss->end = t3->end/3;
            clumpToHspRange(clump, seq, tileSize, frame, t3, &rangeList, TRUE, FALSE);
            }
        }
    slReverse(&rangeList);
    slSort(&rangeList, gfRangeCmpTarget);
    rangeList = gfRangesBundle(rangeList, ffIntronMax/3);

    /* Do detailed alignment of each of the clustered ranges. */
    for (range = rangeList; range != NULL; range = range->next)
        {
        targetSeq = range->tSeq;
        AllocVar(bun);
        bun->qSeq = seq;
        bun->genoSeq = targetSeq;
        bun->ffList = gfRangesToFfItem(range->components, seq);
        bun->isProt = TRUE;
        t3 = hashMustFindVal(t3Hash, range->tName);
        bun->t3List = t3;
        ssStitch(bun, ffCdna, minMatch, ssAliCount);
        getTargetName(range->tName, out->includeTargetFile, targetName);
        saveAlignments(targetName, t3->nibSize, 0, 
            bun, t3Hash, FALSE, isRc, ffCdna, minMatch, out);
        ssBundleFree(&bun);
        }

    /* Cleanup for this strand of database. */
    gfRangeFreeList(&rangeList);
    freeHash(&t3Hash);
    for (ref = t3RefList; ref != NULL; ref = ref->next)
        {
        struct trans3 *t3 = ref->val;
        trans3Free(&t3);
        }
    slFreeList(&t3RefList);
    freeDnaSeqList(&tSeqList);
    }

/* Final cleanup. */
for (isRc=0; isRc<=1; ++isRc)
    for (frame=0; frame<3; ++frame)
        gfClumpFreeList(&clumps[isRc][frame]);
for (ss = ssList; ss != NULL; ss = ss->next)
    freeMem(ss->fileName);
slFreeList(&ssList);
lmCleanup(&lm);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gfAlignTransTrans	(	int *	pConn,
		char *	nibDir,
		struct dnaSeq *	seq,
		boolean	qIsRc,
		int	minMatch,
		struct hash *	tFileCache,
		struct gfOutput *	out,
		boolean	isRna
	)

Definition at line 1163 of file gfBlatLib.c.

References AllocVar, clumpTargetName(), clumpToHspRange(), FALSE, ffCdna, ffIntronMax, ffLoose, freeDnaSeqList(), freeHash(), freeMem(), getTargetName(), gfQuerySeqTransTrans(), gfRangeCmpTarget(), gfRangeFreeList(), gfRangesBundle(), gfRangesToFfItem(), gfOutput::includeTargetFile, lm, lmCleanup(), lmInit(), loadHashT3Ranges(), gfSeqSource::next, slRef::next, gfClump::next, PATH_LEN, rangeCoorTimes3(), rangeList, saveAlignments(), trans3::seq, seqClumpToRangeList(), dnaSeq::size, slCat(), slFreeList(), slReverse(), slSort(), ss, ssAliCount, ssBundleFree(), ssStitch(), gfClump::target, gfClump::tEnd, tileSize, trans3::trans, trans3Find(), trans3Free(), trans3New(), TRUE, gfClump::tStart, and untranslateRangeList().

Referenced by doBlat(), and gfClient().

{
struct gfClump *clumps[2][3][3], *clump;
char targetName[PATH_LEN];
int qFrame, tFrame, tIsRc;
struct gfSeqSource *ssList = NULL, *ss;
struct lm *lm = lmInit(0);
int tileSize;
struct gfRange *rangeList = NULL, *rl, *range;
struct trans3 *qTrans = trans3New(qSeq), *t3;
struct slRef *t3RefList = NULL, *t3Ref;
struct hash *t3Hash = NULL;
struct dnaSeq *tSeqList = NULL;
enum ffStringency stringency = (isRna ? ffCdna : ffLoose);

/* Query server for clumps. */
gfQuerySeqTransTrans(*pConn, qSeq, clumps, lm, &ssList, &tileSize);
close(*pConn);
*pConn = -1;

for (tIsRc=0; tIsRc <= 1; ++tIsRc)
    {
    /* Figure out which ranges need to be loaded and load them. */
    for (qFrame = 0; qFrame < 3; ++qFrame)
        {
        for (tFrame = 0; tFrame < 3; ++tFrame)
            {
            rl = seqClumpToRangeList(clumps[tIsRc][qFrame][tFrame], tFrame);
            rangeList = slCat(rangeList, rl);
            }
        }
    rangeCoorTimes3(rangeList);
    slSort(&rangeList, gfRangeCmpTarget);
    rangeList = gfRangesBundle(rangeList, ffIntronMax);
    loadHashT3Ranges(rangeList, tSeqDir, tFileCache,
        qSeq->size/3, tIsRc, &t3Hash, &tSeqList, &t3RefList);

    /* The old range list was not very precise - it was just to get
     * the DNA loaded.  */
    gfRangeFreeList(&rangeList);

    /* Patch up clump list and associated sequence source to refer
     * to bits of genome loaded into memory.  Create new range list
     * by extending hits in clumps. */
    for (qFrame = 0; qFrame < 3; ++qFrame)
        {
        for (tFrame = 0; tFrame < 3; ++tFrame)
            {
            for (clump = clumps[tIsRc][qFrame][tFrame]; clump != NULL; clump = clump->next)
                {
                struct gfSeqSource *ss = clump->target;
                struct gfRange *rangeSet = NULL;
                t3 = trans3Find(t3Hash, clumpTargetName(clump), clump->tStart*3, clump->tEnd*3);
                ss->seq = t3->trans[tFrame];
                ss->start = t3->start/3;
                ss->end = t3->end/3;
                clumpToHspRange(clump, qTrans->trans[qFrame], tileSize, tFrame, t3, &rangeSet, TRUE, FALSE);
                untranslateRangeList(rangeSet, qFrame, tFrame, NULL, t3, t3->start);
                rangeList = slCat(rangeSet, rangeList);
                }
            }
        }
    slReverse(&rangeList);
    slSort(&rangeList, gfRangeCmpTarget);
    rangeList = gfRangesBundle(rangeList, ffIntronMax);

    for (range = rangeList; range != NULL; range = range->next)
        {
        struct dnaSeq *targetSeq = range->tSeq;
        struct ssBundle *bun;

        AllocVar(bun);
        bun->qSeq = qSeq;
        bun->genoSeq = targetSeq;
        bun->ffList = gfRangesToFfItem(range->components, qSeq);
        ssStitch(bun, stringency, minMatch, ssAliCount);
        getTargetName(range->tName, out->includeTargetFile, targetName);
        t3 = range->t3;
        saveAlignments(targetName, t3->nibSize, t3->start, 
            bun, NULL, qIsRc, tIsRc, stringency, minMatch, out);
        ssBundleFree(&bun);
        }

    /* Cleanup for this strand of database. */
    gfRangeFreeList(&rangeList);
    freeHash(&t3Hash);
    for (t3Ref = t3RefList; t3Ref != NULL; t3Ref = t3Ref->next)
        {
        struct trans3 *t3 = t3Ref->val;
        trans3Free(&t3);
        }
    slFreeList(&t3RefList);
    freeDnaSeqList(&tSeqList);
    }
trans3Free(&qTrans);
for (ss = ssList; ss != NULL; ss = ss->next)
    freeMem(ss->fileName);
slFreeList(&ssList);
lmCleanup(&lm);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gfCatchPipes

(

)

Definition at line 38 of file genoFind.c.

References gfPipeHandler().

Referenced by main().

{
signal(SIGPIPE, gfPipeHandler);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gfCheckTileSize	(	int	tileSize,
		boolean	isPep
	)

Definition at line 97 of file genoFind.c.

References errAbort().

Referenced by gfNewEmpty(), and main().

{
if (isPep)
    {
    if (tileSize < 3 || tileSize > 8)
        errAbort("protein tileSize must be between 3 and 8");
    }
else
    {
    if (tileSize < 6 || tileSize > 18)
        errAbort("DNA tileSize must be between 6 and 18");
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gfClumpDump	(	struct genoFind *	gf,
		struct gfClump *	clump,
		FILE *	f
	)

Definition at line 973 of file genoFind.c.

References gfClump::hitCount, gfClump::hitList, name, gfHit::next, gfClump::qEnd, gfClump::qStart, ss, gfClump::target, gfClump::tEnd, and gfClump::tStart.

Referenced by genoFindDirect(), and genoPcrDirect().

{
struct gfSeqSource *ss = clump->target;
char *name = ss->fileName;

if (name == NULL) name = ss->seq->name;
fprintf(f, "%u-%u %s %u-%u, hits %d\n", 
        clump->qStart, clump->qEnd, name,
        clump->tStart - ss->start, clump->tEnd - ss->start,
        clump->hitCount);
#ifdef SOMETIMES
for (hit = clump->hitList; hit != NULL; hit = hit->next)
    fprintf(f, "   q %d, t %d, diag %d\n", hit->qStart, hit->tStart, hit->diagonal);
#endif
}

Here is the caller graph for this function:

void gfClumpFree

(

struct gfClump **

pClump

)

Definition at line 951 of file genoFind.c.

References freez().

Referenced by clumpNear(), gfClumpFreeList(), and targetClump().

{
struct gfClump *clump;
if ((clump = *pClump) == NULL)
    return;
freez(pClump);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gfClumpFreeList

(

struct gfClump **

pList

)

Definition at line 960 of file genoFind.c.

References gfClumpFree(), and gfClump::next.

Referenced by dnaQuery(), ffSeedExtInMem(), genoFindDirect(), gfAlignTrans(), gfFindAlignAaTrans(), gfTransTransFindBundles(), pcrQuery(), searchOneProt(), transQuery(), and transTransQuery().

{
struct gfClump *el, *next;

for (el = *pList; el != NULL; el = next)
    {
    next = el->next;
    gfClumpFree(&el);
    }
*pList = NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int gfConnect	(	char *	hostName,
		char *	portName
	)

Definition at line 10 of file gfNet.c.

References errnoAbort(), and netConnect().

Referenced by doBlat(), gfClient(), and gfPcrGetRanges().

{
/* Connect to server. */
int sd = netConnect(hostName, atoi(portName));
if (sd < 0)
    {
    errnoAbort("Sorry, the BLAT/iPCR server seems to be down.  Please try "
               "again later.");
    }
return sd;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gfFileCacheFree

(

struct hash **

pCache

)

Definition at line 526 of file gfBlatLib.c.

References gfFileCacheFreeEl(), hashFree, and hashTraverseEls().

Referenced by gfClient(), and gfPcrViaNet().

{
struct hash *cache = *pCache;
if (cache != NULL)
    {
    hashTraverseEls(cache, gfFileCacheFreeEl);
    hashFree(pCache);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct hash* gfFileCacheNew

(

)

[read]

Definition at line 503 of file gfBlatLib.c.

References hashNew.

Referenced by doBlat(), gfClient(), and gfPcrViaNet().

{
return hashNew(0);
}

Here is the caller graph for this function:

void gfFindAlignAaTrans	(	struct genoFind *	gfs[3],
		aaSeq *	qSeq,
		struct hash *	t3Hash,
		boolean	tIsRc,
		int	minMatch,
		struct gfOutput *	out
	)

Definition at line 938 of file gfBlatLib.c.

References AllocVar, clumpToHspRange(), FALSE, ffCdna, ffIntronMax, ssBundle::ffList, ssBundle::genoSeq, gfClumpFreeList(), gfRangeCmpTarget(), gfRangeFreeList(), gfRangesBundle(), gfRangesToFfItem(), gfTransFindClumps(), hashMustFindVal(), ssBundle::isProt, lm, lmCleanup(), lmInit(), dnaSeq::name, gfClump::next, ssBundle::qSeq, rangeList, saveAlignments(), trans3::seq, dnaSeq::size, slReverse(), slSort(), ssAliCount, ssBundleFree(), ssStitch(), ssBundle::t3List, genoFind::tileSize, tileSize, and TRUE.

Referenced by tripleSearch().

{
struct gfClump *clumps[3];
int frame;
struct gfClump *clump;
struct gfRange *rangeList = NULL, *range;
aaSeq *targetSeq;
struct ssBundle *bun;
int tileSize = gfs[0]->tileSize;
struct trans3 *t3;
int hitCount;
struct lm *lm = lmInit(0);

gfTransFindClumps(gfs, qSeq, clumps, lm, &hitCount);
for (frame=0; frame<3; ++frame)
    {
    for (clump = clumps[frame]; clump != NULL; clump = clump->next)
        {
        clumpToHspRange(clump, qSeq, tileSize, frame, NULL, &rangeList, TRUE, FALSE);
        }
    }
slReverse(&rangeList);
slSort(&rangeList, gfRangeCmpTarget);
rangeList = gfRangesBundle(rangeList, ffIntronMax/3);
for (range = rangeList; range != NULL; range = range->next)
    {
    targetSeq = range->tSeq;
    t3 = hashMustFindVal(t3Hash, targetSeq->name);
    AllocVar(bun);
    bun->qSeq = qSeq;
    bun->genoSeq = targetSeq;
    bun->ffList = gfRangesToFfItem(range->components, qSeq);
    bun->isProt = TRUE;
    bun->t3List = t3;
    ssStitch(bun, ffCdna, minMatch, ssAliCount);
    saveAlignments(targetSeq->name, t3->seq->size, 0, 
        bun, t3Hash, FALSE, tIsRc, ffCdna, minMatch, out);
    ssBundleFree(&bun);
    }
gfRangeFreeList(&rangeList);
for (frame=0; frame<3; ++frame)
    gfClumpFreeList(&clumps[frame]);
lmCleanup(&lm);
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct gfClump* gfFindClumps	(	struct genoFind *	gf,
		struct dnaSeq *	seq,
		struct lm *	lm,
		int *	retHitCount
	)			[read]

Definition at line 1890 of file genoFind.c.

References gfFindClumpsWithQmask(), and lm.

Referenced by dnaQuery(), genoFindDirect(), gfTransFindClumps(), and searchOneProt().

{
return gfFindClumpsWithQmask(gf, seq, NULL, 0, lm, retHitCount);
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct gfClump* gfFindClumpsWithQmask	(	struct genoFind *	gf,
		bioSeq *	seq,
		Bits *	qMaskBits,
		int	qMaskOffset,
		struct lm *	lm,
		int *	retHitCount
	)			[read]

Definition at line 1849 of file genoFind.c.

References clumpHits(), cmpQuerySize, gfFindHitsWithQmask(), lm, genoFind::minMatch, minMatch, dnaSeq::size, and genoFind::tileSize.

Referenced by ffSeedExtInMem(), and gfFindClumps().

{
struct gfClump *clumpList = NULL;
struct gfHit *hitList;
int minMatch = gf->minMatch;

#ifdef OLD      /* stepSize makes this obsolete. */
if (seq->size < gf->tileSize * (gf->minMatch+1))
     minMatch = 1;
#endif /* OLD */

hitList =  gfFindHitsWithQmask(gf, seq, qMaskBits, qMaskOffset, lm,
        retHitCount, NULL, 0, 0);
cmpQuerySize = seq->size;
clumpList = clumpHits(gf, hitList, minMatch);
return clumpList;
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct gfHit* gfFindHitsInRegion	(	struct genoFind *	gf,
		bioSeq *	seq,
		Bits *	qMaskBits,
		int	qMaskOffset,
		struct lm *	lm,
		struct gfSeqSource *	target,
		int	tMin,
		int	tMax
	)			[read]

Definition at line 1870 of file genoFind.c.

References gfFindHitsWithQmask(), lm, gfHit::next, gfSeqSource::start, and gfHit::tStart.

Referenced by scanIndexForSmallExons().

{
int targetStart;
struct gfHit *hitList, *hit;
int hitCount;

targetStart = target->start;
hitList =  gfFindHitsWithQmask(gf, seq, qMaskBits, qMaskOffset, lm,
        &hitCount, target, tMin + targetStart, tMax + targetStart);
for (hit = hitList; hit != NULL; hit = hit->next)
    hit->tStart -= targetStart;
return hitList;
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct gfSeqSource* gfFindNamedSource	(	struct genoFind *	gf,
		char *	name
	)			[read]

Definition at line 2010 of file genoFind.c.

References gfSeqSource::fileName, dnaSeq::name, sameString, gfSeqSource::seq, genoFind::sourceCount, genoFind::sources, and splitPath().

Referenced by refineBundle().

{
struct gfSeqSource *source = gf->sources;
int count = gf->sourceCount;

if (source->seq == NULL)        /* Use first source to see if seq or file. */
    {
    char rootName[256];
    while (--count >= 0)
        {
        splitPath(source->fileName, NULL, rootName, NULL);
        if (sameString(name, rootName))
             return source;
        }
    }
else
    {
    while (--count >= 0)
        {
        if (sameString(source->seq->name, name))
            return source;
        source += 1;
        }
    }
return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct genoFind* gfIndexNibsAndTwoBits	(	int	fileCount,
		char *	fileNames[],
		int	minMatch,
		int	maxGap,
		int	tileSize,
		int	maxPat,
		char *	oocFile,
		boolean	allowOneMismatch,
		int	stepSize
	)			[read]

Definition at line 514 of file genoFind.c.

References AllocArray, baseCount, bits32, cloneString(), dnaSeqFree, errAbort(), FALSE, gfAddSeq(), gfAddTilesInNib(), gfAllocLists(), gfCountTilesInNib(), gfCountTilesInTwoBit(), gfNewEmpty(), gfZeroNonOverused(), gfZeroOverused(), twoBitFile::indexList, maxTotalBases(), twoBitIndex::name, twoBitIndex::next, nibIsFile(), PATH_LEN, safef(), dnaSeq::size, genoFind::sourceCount, genoFind::sources, ss, genoFind::tileSize, genoFind::totalSeqSize, twoBitClose(), twoBitIsFile(), twoBitOpen(), and twoBitReadSeqFragLower().

Referenced by genoFindDirect(), genoPcrDirect(), and startServer().

{
struct genoFind *gf = gfNewEmpty(minMatch, maxGap, tileSize, stepSize,
        maxPat, oocFile, FALSE, allowOneMismatch);
int i;
bits32 offset = 0, nibSize;
char *fileName;
struct gfSeqSource *ss;
long long totalBases = 0, warnAt = maxTotalBases();
int totalSeq = 0;

if (allowOneMismatch)
    errAbort("Don't currently support allowOneMismatch in gfIndexNibsAndTwoBits");
if (stepSize == 0)
    stepSize = gf->tileSize;
for (i=0; i<fileCount; ++i)
    {
    fileName = fileNames[i];
    if (twoBitIsFile(fileName))
        {
        int seqCount;
        long long baseCount;
        gfCountTilesInTwoBit(gf, stepSize, fileName, &seqCount, &baseCount);
        totalBases += baseCount;
        totalSeq += seqCount;
        }
    else if (nibIsFile(fileName))
        {
        totalBases += gfCountTilesInNib(gf, stepSize, fileName);
        totalSeq += 1;
        }
    else
        errAbort("Unrecognized file type %s", fileName);
    /* Warn if they exceed 4 gig. */
    if (totalBases >= warnAt)
        errAbort("Exceeding 4 billion bases, sorry gfServer can't handle that.");
    }
gfAllocLists(gf);
gfZeroNonOverused(gf);
AllocArray(gf->sources, totalSeq);
gf->sourceCount = totalSeq;
ss = gf->sources;
for (i=0; i<fileCount; ++i)
    {
    fileName = fileNames[i];
    if (nibIsFile(fileName))
        {
        nibSize = gfAddTilesInNib(gf, fileName, offset, stepSize);
        ss->fileName = fileName;
        ss->start = offset;
        offset += nibSize;
        ss->end = offset;
        ++ss;
        }
    else
        {
        struct twoBitFile *tbf = twoBitOpen(fileName);
        struct twoBitIndex *index;
        char nameBuf[PATH_LEN+256];
        for (index = tbf->indexList; index != NULL; index = index->next)
            {
            struct dnaSeq *seq = twoBitReadSeqFragLower(tbf, index->name, 0,0);
            gfAddSeq(gf, seq, offset);
            safef(nameBuf, sizeof(nameBuf), "%s:%s", fileName, index->name);
            ss->fileName = cloneString(nameBuf);
            ss->start = offset;
            offset += seq->size;
            ss->end = offset;
            ++ss;
            dnaSeqFree(&seq);
            }
        twoBitClose(&tbf);
        }
    }
gf->totalSeqSize = offset;
gfZeroOverused(gf);
printf("Done adding\n");
return gf;
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct genoFind* gfIndexSeq	(	bioSeq *	seqList,
		int	minMatch,
		int	maxGap,
		int	tileSize,
		int	maxPat,
		char *	oocFile,
		boolean	isPep,
		boolean	allowOneMismatch,
		boolean	maskUpper,
		int	stepSize
	)			[read]

Definition at line 907 of file genoFind.c.

References gfLargeIndexSeq(), gfNewEmpty(), gfSmallIndexSeq(), and genoFind::segSize.

Referenced by bigBlat(), and blat().

{
struct genoFind *gf = gfNewEmpty(minMatch, maxGap, tileSize, stepSize, maxPat, 
                                oocFile, isPep, allowOneMismatch);
if (stepSize == 0)
    stepSize = tileSize;
if (gf->segSize > 0)
    {
    gfLargeIndexSeq(gf, seqList, minMatch, maxGap, tileSize, maxPat, oocFile, isPep, maskUpper);
    }
else
    {
    gfSmallIndexSeq(gf, seqList, minMatch, maxGap, tileSize, maxPat, oocFile, isPep, maskUpper);
    }
return gf;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gfIndexTransNibsAndTwoBits	(	struct genoFind *	transGf[2][3],
		int	fileCount,
		char *	fileNames[],
		int	minMatch,
		int	maxGap,
		int	tileSize,
		int	maxPat,
		char *	oocFile,
		boolean	allowOneMismatch,
		boolean	mask,
		int	stepSize
	)

Definition at line 717 of file genoFind.c.

References AllocArray, bits32, errAbort(), freeDnaSeq(), gfAllocLists(), gfNewEmpty(), gfZeroNonOverused(), gfZeroOverused(), twoBitFile::indexList, maskSimplePepRepeat(), maxTotalBases(), twoBitIndex::name, twoBitIndex::next, nibIsFile(), PATH_LEN, readMaskedNib(), readMaskedTwoBit(), safef(), dnaSeq::size, genoFind::totalSeqSize, transCountBothStrands(), transIndexBothStrands(), TRUE, twoBitCheckTotalSize(), twoBitClose(), twoBitIsFile(), and twoBitOpen().

Referenced by startServer().

{
struct genoFind *gf;
int i,isRc, frame;
bits32 offset[2][3];
char *fileName;
struct dnaSeq *seq;
int sourceCount = 0;
long long totalBases = 0, warnAt = maxTotalBases();

if (allowOneMismatch)
    errAbort("Don't currently support allowOneMismatch in gfIndexTransNibsAndTwoBits");
/* Allocate indices for all reading frames. */
for (isRc=0; isRc <= 1; ++isRc)
    {
    for (frame = 0; frame < 3; ++frame)
        {
        transGf[isRc][frame] = gf = gfNewEmpty(minMatch, maxGap, 
                tileSize, stepSize, maxPat, oocFile, TRUE, allowOneMismatch);
        }
    }

/* Mask simple AA repeats (of period 1 and 2). */
for (isRc = 0; isRc <= 1; ++isRc)
    for (frame = 0; frame < 3; ++frame)
        maskSimplePepRepeat(transGf[isRc][frame]);

/* Scan through .nib and .2bit files once counting tiles. */
for (i=0; i<fileCount; ++i)
    {
    fileName = fileNames[i];
    printf("Counting %s\n", fileName);
    if (nibIsFile(fileName))
        {
        seq = readMaskedNib(fileName, doMask);
        transCountBothStrands(seq, transGf);
        sourceCount += 1;
        totalBases += seq->size;
        freeDnaSeq(&seq);
        }
    else if (twoBitIsFile(fileName))
        {
        struct twoBitFile *tbf = twoBitOpen(fileName);
        struct twoBitIndex *index;
        totalBases += twoBitCheckTotalSize(tbf);

        for (index = tbf->indexList; index != NULL; index = index->next)
            {
            seq = readMaskedTwoBit(tbf, index->name, doMask);
            transCountBothStrands(seq, transGf);
            sourceCount += 1;
            freeDnaSeq(&seq);
            }
        twoBitClose(&tbf);
        }
    else 
        errAbort("Unrecognized file type %s", fileName);
    if (totalBases >= warnAt)
        errAbort("Exceeding 4 billion bases, sorry gfServer can't handle that.");
    }

/* Get space for entries in indexed of all reading frames. */
for (isRc=0; isRc <= 1; ++isRc)
    {
    for (frame = 0; frame < 3; ++frame)
        {
        gf = transGf[isRc][frame];
        gfAllocLists(gf);
        gfZeroNonOverused(gf);
        AllocArray(gf->sources, sourceCount);
        gf->sourceCount = sourceCount;
        offset[isRc][frame] = 0;
        }
    }

/* Scan through nibs a second time building index. */
sourceCount = 0;
for (i=0; i<fileCount; ++i)
    {
    fileName = fileNames[i];
    printf("Indexing %s\n", fileName);
    if (nibIsFile(fileName))
        {
        seq = readMaskedNib(fileName, doMask);
        transIndexBothStrands(seq, transGf, offset, sourceCount, fileName);
        freeDnaSeq(&seq);
        sourceCount += 1;
        }
    else        /* .2bit file */
        {
        struct twoBitFile *tbf = twoBitOpen(fileName);
        struct twoBitIndex *index;
        for (index = tbf->indexList; index != NULL; index = index->next)
            {
            char nameBuf[PATH_LEN+256];
            safef(nameBuf, sizeof(nameBuf), "%s:%s", fileName, index->name);
            seq = readMaskedTwoBit(tbf, index->name, doMask);
            transIndexBothStrands(seq, transGf, offset, sourceCount, nameBuf);
            sourceCount += 1;
            freeDnaSeq(&seq);
            }
        twoBitClose(&tbf);
        }
    }

for (isRc=0; isRc <= 1; ++isRc)
    {
    for (frame = 0; frame < 3; ++frame)
        {
        gf = transGf[isRc][frame];
        gf->totalSeqSize = offset[isRc][frame];
        gfZeroOverused(gf);
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gfLongDnaInMem	(	struct dnaSeq *	query,
		struct genoFind *	gf,
		boolean	isRc,
		int	minScore,
		Bits *	qMaskBits,
		struct gfOutput *	out,
		boolean	fastMap,
		boolean	band
	)

Definition at line 1478 of file gfBlatLib.c.

References lmInit(), newHash(), rangeList, and dnaSeq::size.

Referenced by searchOneStrand().

{
int hitCount;
int maxSize = 5000;
int preferredSize = 4500;
int overlapSize = 250;
struct dnaSeq subQuery = *query;
struct lm *lm = lmInit(0);
int subOffset, subSize, nextOffset;
DNA saveEnd, *endPos;
struct ssBundle *oneBunList = NULL, *bigBunList = NULL, *bun;
struct hash *bunHash = newHash(8);

for (subOffset = 0; subOffset<query->size; subOffset = nextOffset)
    {
    struct gfClump *clumpList;
    struct gfRange *rangeList = NULL;

    /* Figure out size of this piece.  If query is
     * maxSize or less do it all.   Otherwise just
     * do prefered size, and set it up to overlap
     * with surrounding pieces by overlapSize.  */
    if (subOffset == 0 && query->size <= maxSize)
        nextOffset = subSize = query->size;
    else
        {
        subSize = preferredSize;
        if (subSize + subOffset >= query->size)
            {
            subSize = query->size - subOffset;
            nextOffset = query->size;
            }
        else
            {
            nextOffset = subOffset + preferredSize - overlapSize;
            }
        }
    subQuery.dna = query->dna + subOffset;
    subQuery.size = subSize;
    endPos = &subQuery.dna[subSize];
    saveEnd = *endPos;
    *endPos = 0;
    if (band)
        {
        oneBunList = ffSeedExtInMem(gf, &subQuery, qMaskBits, subOffset, lm, minScore, isRc);
        }
    else
        {
        clumpList = gfFindClumpsWithQmask(gf, &subQuery, qMaskBits, subOffset, lm, &hitCount);
        if (fastMap)
            {
            oneBunList = fastMapClumpsToBundles(gf, clumpList, &subQuery);
            }
        else
            {
            oneBunList = gfClumpsToBundles(clumpList, isRc, &subQuery, minScore, &rangeList);
            gfRangeFreeList(&rangeList);
            }
        gfClumpFreeList(&clumpList);
        }
    addToBigBundleList(&oneBunList, bunHash, &bigBunList, query);
    *endPos = saveEnd;
    }
#ifdef DEBUG
dumpBunList(bigBunList);
#endif /* DEBUG */
for (bun = bigBunList; bun != NULL; bun = bun->next)
    {
    ssStitch(bun, ffCdna, minScore, ssAliCount);
    if (!fastMap && !band)
        refineSmallExonsInBundle(bun);
    saveAlignments(bun->genoSeq->name, bun->genoSeq->size, 0, 
        bun, NULL, isRc, FALSE, ffCdna, minScore, out);
    }
ssBundleFreeList(&bigBunList);
freeHash(&bunHash);
lmCleanup(&lm);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gfLongTransTransInMem	(	struct dnaSeq *	query,
		struct genoFind *	gfs[3],
		struct hash *	t3Hash,
		boolean	qIsRc,
		boolean	tIsRc,
		boolean	qIsRna,
		int	minScore,
		struct gfOutput *	out
	)

Definition at line 1562 of file gfBlatLib.c.

References ffCdna, ffLoose, newHash(), and dnaSeq::size.

Referenced by transTripleSearch().

{
enum ffStringency stringency = (qIsRna ? ffCdna : ffLoose);
int maxSize = 1500;
int preferredSize = 1200;       /* PreferredSize - overlapSize might need to be multiple of 3. */
int overlapSize = 270;
struct dnaSeq subQuery = *query;
int subOffset, subSize, nextOffset;
DNA saveEnd, *endPos;
struct ssBundle *oneBunList = NULL, *bigBunList = NULL, *bun;
struct hash *bunHash = newHash(8);

for (subOffset = 0; subOffset<query->size; subOffset = nextOffset)
    {
    /* Figure out size of this piece.  If query is
     * maxSize or less do it all.   Otherwise just
     * do prefered size, and set it up to overlap
     * with surrounding pieces by overlapSize.  */
    if (subOffset == 0 && query->size <= maxSize)
        nextOffset = subSize = query->size;
    else
        {
        subSize = preferredSize;
        if (subSize + subOffset >= query->size)
            {
            subSize = query->size - subOffset;
            nextOffset = query->size;
            }
        else
            {
            nextOffset = subOffset + preferredSize - overlapSize;
            }
        }
    subQuery.dna = query->dna + subOffset;
    subQuery.size = subSize;
    endPos = &subQuery.dna[subSize];
    saveEnd = *endPos;
    *endPos = 0;
    oneBunList = gfTransTransFindBundles(gfs, &subQuery, t3Hash, qIsRc, minScore, qIsRna);
    addToBigBundleList(&oneBunList, bunHash, &bigBunList, query);
    *endPos = saveEnd;
    }
for (bun = bigBunList; bun != NULL; bun = bun->next)
    {
    ssStitch(bun, ffCdna, minScore, ssAliCount);
    saveAlignments(bun->genoSeq->name, bun->genoSeq->size, 0, 
        bun, NULL, qIsRc, tIsRc, stringency, minScore, out);
    }
hashFree(&bunHash);
ssBundleFreeList(&bigBunList);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gfMakeOoc	(	char *	outName,
		char *	files[],
		int	fileCount,
		int	tileSize,
		bits32	maxPat,
		enum gfType	tType
	)

Definition at line 1928 of file genoFind.c.

References bits32, carefulClose(), dnaSeq::dna, errAbort(), FALSE, faReadAllSeq(), freeDnaSeqList(), genoFindFree(), gfCountSeq(), gfMaxGap, gfMinMatch, gfNewEmpty(), gftDnaX, gftProt, gftRnaX, genoFind::listSizes, mustOpen(), dnaSeq::next, nibIsFile(), nibLoadAll(), oocSig, reverseComplement(), genoFind::segSize, dnaSeq::size, genoFind::tileSpaceSize, toLowerN(), trans3Free(), trans3New(), twoBitIsFile(), twoBitLoadAll(), and writeOne.

Referenced by blat().

{
boolean dbIsPep = (tType == gftProt || tType == gftDnaX || tType == gftRnaX);
struct genoFind *gf = gfNewEmpty(gfMinMatch, gfMaxGap, tileSize, tileSize,
        maxPat, NULL, dbIsPep, FALSE);
bits32 *sizes = gf->listSizes;
int tileSpaceSize = gf->tileSpaceSize;
bioSeq *seq, *seqList;
bits32 sig = oocSig, psz = tileSize;
bits32 i;
int oocCount = 0;
char *inName;
FILE *f = mustOpen(outName, "w");

if (gf->segSize > 0)
    errAbort("Don't yet know how to make ooc files for large tile sizes.");
for (i=0; i<fileCount; ++i)
    {
    inName = files[i];
    printf("Loading %s\n", inName);
    if (nibIsFile(inName))
        {
        seqList = nibLoadAll(inName);
        }
    else if (twoBitIsFile(inName))
        {
        seqList = twoBitLoadAll(inName);
        for (seq = seqList; seq != NULL; seq = seq->next)
            toLowerN(seq->dna, seq->size);
        }
    else
        {
        seqList = faReadAllSeq(inName, tType != gftProt);
        }
    printf("Counting %s\n", inName);
    for (seq = seqList; seq != NULL; seq = seq->next)
        {
        int isRc;
        for (isRc = 0; isRc <= 1; ++isRc)
            {
            if (tType == gftDnaX || tType == gftRnaX)
                {
                struct trans3 *t3 = trans3New(seq);
                int frame;
                for (frame=0; frame<3; ++frame)
                    {
                    gfCountSeq(gf, t3->trans[frame]);
                    }
                trans3Free(&t3);
                }
            else
                {
                gfCountSeq(gf, seq);
                }
            if (tType == gftProt || tType == gftRnaX)
                break;
            else 
                {
                reverseComplement(seq->dna, seq->size);
                }
            }
        }
    freeDnaSeqList(&seqList);
    }
printf("Writing %s\n", outName);
writeOne(f, sig);
writeOne(f, psz);
for (i=0; i<tileSpaceSize; ++i)
    {
    if (sizes[i] >= maxPat)
        {
        writeOne(f, i);
        ++oocCount;
        }
    }
carefulClose(&f);
genoFindFree(&gf);
printf("Wrote %d overused %d-mers to %s\n", oocCount, tileSize, outName);
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct gfOutput* gfOutputAny	(	char *	format,
		int	goodPpt,
		boolean	qIsProt,
		boolean	tIsProt,
		boolean	noHead,
		char *	databaseName,
		int	databaseSeqCount,
		double	databaseLetters,
		double	minIdentity,
		FILE *	f
	)			[read]

Definition at line 508 of file gfOut.c.

References ArraySize, errAbort(), FALSE, gfOutputAxt(), gfOutputBlast(), gfOutputMaf(), gfOutputPsl(), gfOutputSim4(), gfOutput::out, sameWord, stringArrayIx(), and TRUE.

Referenced by blat(), and gfClient().

             :
 *    format - either 'psl', 'pslx', 'sim4', 'blast', 'wublast', 'axt', 'xml'
 *    goodPpt - minimum identity of alignments to output in parts per thousand
 *    qIsProt - true if query side is a protein.
 *    tIsProt - true if target (database) side is a protein.
 *    noHead - if true suppress header in psl/pslx output.
 *    databaseName - name of database.  Only used for blast output
 *    databaseSeq - number of sequences in database - only for blast
 *    databaseLetters - number of bases/aas in database - only blast
 *    minIdentity - minimum identity - only blast
 *    FILE *f - file.  
 */
{
struct gfOutput *out = NULL;
static char *blastTypes[] = {"blast", "wublast", "blast8", "blast9", "xml"};

if (format == NULL)
    format = "psl";
if (sameWord(format, "psl"))
    out = gfOutputPsl(goodPpt, qIsProt, tIsProt, f, FALSE, noHead);
else if (sameWord(format, "pslx"))
    out = gfOutputPsl(goodPpt, qIsProt, tIsProt, f, TRUE, noHead);
else if (sameWord(format, "sim4"))
    out = gfOutputSim4(goodPpt, qIsProt, tIsProt, databaseName);
else if (stringArrayIx(format, blastTypes, ArraySize(blastTypes)) >= 0)
    out = gfOutputBlast(goodPpt, qIsProt, tIsProt, 
            databaseName, databaseSeqCount, databaseLetters, format, 
            minIdentity, f);
else if (sameWord(format, "axt"))
    out = gfOutputAxt(goodPpt, qIsProt, tIsProt, f);
else if (sameWord(format, "maf"))
    out = gfOutputMaf(goodPpt, qIsProt, tIsProt, f);
else
    errAbort("Unrecognized output format '%s'", format);
return out;
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct gfOutput* gfOutputAxt	(	int	goodPpt,
		boolean	qIsProt,
		boolean	tIsProt,
		FILE *	f
	)			[read]

Definition at line 459 of file gfOut.c.

References axtQueryOut(), gfOutputAxtMem(), and gfOutput::out.

Referenced by gfOutputAny().

{
struct gfOutput *out = gfOutputAxtMem(goodPpt, qIsProt, tIsProt);
out->queryOut = axtQueryOut;
return out;
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct gfOutput* gfOutputAxtMem	(	int	goodPpt,
		boolean	qIsProt,
		boolean	tIsProt
	)			[read]

Definition at line 447 of file gfOut.c.

References AllocVar, gfOutput::data, gfOutputInit(), gfOutput::out, and saveAxtBundle().

Referenced by gfOutputAxt(), gfOutputBlast(), gfOutputMaf(), and gfOutputSim4().

{
struct gfOutput *out = gfOutputInit(goodPpt, qIsProt, tIsProt);
struct axtData *ad;
AllocVar(ad);
out->out = saveAxtBundle;
out->data = ad;
return out;
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct gfOutput* gfOutputBlast	(	int	goodPpt,
		boolean	qIsProt,
		boolean	tIsProt,
		char *	databaseName,
		int	databaseSeqCount,
		double	databaseLetters,
		char *	blastType,
		double	minIdentity,
		FILE *	f
	)			[read]

Definition at line 491 of file gfOut.c.

References blastQueryOut(), axtData::blastType, gfOutput::data, axtData::databaseLetters, axtData::databaseName, axtData::databaseSeqCount, gfOutputAxtMem(), axtData::minIdentity, gfOutput::out, and gfOutput::queryOut.

Referenced by gfOutputAny().

{
struct gfOutput *out = gfOutputAxtMem(goodPpt, qIsProt, tIsProt);
struct axtData *ad = out->data;
ad->databaseName = databaseName;
ad->databaseSeqCount = databaseSeqCount;
ad->databaseLetters = databaseLetters;
ad->blastType = blastType;
ad->minIdentity = minIdentity;
out->queryOut = blastQueryOut;
return out;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gfOutputFree

(

struct gfOutput **

pOut

)

Definition at line 567 of file gfOut.c.

References freeMem(), freez(), and gfOutput::out.

{
struct gfOutput *out = *pOut;
if (out != NULL)
    {
    freeMem(out->data);
    freez(pOut);
    }
}

Here is the call graph for this function:

void gfOutputHead	(	struct gfOutput *	out,
		FILE *	f
	)

Definition at line 560 of file gfOut.c.

References gfOutput::out.

Referenced by gfClient(), and searchOneIndex().

{
if (out->fileHead != NULL)
    out->fileHead(out, f);
}

Here is the caller graph for this function:

struct gfOutput* gfOutputPsl	(	int	goodPpt,
		boolean	qIsProt,
		boolean	tIsProt,
		FILE *	f,
		boolean	saveSeq,
		boolean	noHead
	)			[read]

Definition at line 429 of file gfOut.c.

References AllocVar, gfOutput::data, pslxData::f, gfOutput::fileHead, gfOutputInit(), gfOutput::out, pslHead(), pslOut(), and pslxData::saveSeq.

Referenced by doBlat(), and gfOutputAny().

{
struct gfOutput *out = gfOutputInit(goodPpt, qIsProt, tIsProt);
struct pslxData *pslData;

AllocVar(pslData);
pslData->saveSeq = saveSeq;
pslData->f = f;
out->out = pslOut;
out->data = pslData;
if (!noHead)
    out->fileHead = pslHead;
return out;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gfOutputQuery	(	struct gfOutput *	out,
		FILE *	f
	)

Definition at line 552 of file gfOut.c.

References gfOutput::out.

Referenced by bigBlat(), doBlat(), gfClient(), and searchOne().

{
++out->queryIx;
if (out->queryOut != NULL)
    out->queryOut(out, f);
}

Here is the caller graph for this function:

struct gfClump* gfPcrClumps	(	struct genoFind *	gf,
		char *	fPrimer,
		int	fPrimerSize,
		char *	rPrimer,
		int	rPrimerSize,
		int	minDistance,
		int	maxDistance
	)			[read]

Definition at line 2155 of file genoFind.c.

References errAbort(), genoFind::isPep, pcrClumps(), reverseComplement(), genoFind::segSize, and tolowers().

Referenced by genoPcrDirect(), and pcrQuery().

{
struct gfClump *clumpList;
if (gf->segSize > 0)
    errAbort("Can't do PCR on large tile sizes");
if (gf->isPep)
    errAbort("Can't do PCR on protein/translated index");
tolowers(fPrimer);
tolowers(rPrimer);
reverseComplement(rPrimer, rPrimerSize);
clumpList = pcrClumps(gf, fPrimer, fPrimerSize, rPrimer, rPrimerSize, 
        minDistance, maxDistance);
reverseComplement(rPrimer, rPrimerSize);
return clumpList;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int gfReadMulti	(	int	sd,
		void *	vBuf,
		size_t	size
	)

Definition at line 44 of file genoFind.c.

Referenced by startServer().

{
char *buf = vBuf;
size_t totalRead = 0;
int oneRead;

while (totalRead < size)
    {
    oneRead = read(sd, buf + totalRead, size - totalRead);
    if (oneRead < 0)
        {
        perror("Couldn't finish large read");
        return oneRead;
        }
    else if (oneRead == 0)
    /* Avoid an infinite loop when the client closed the socket. */
        break;
    totalRead += oneRead;
    }
return totalRead;
}

Here is the caller graph for this function:

char* gfSignature

(

)

Definition at line 22 of file genoFind.c.

Referenced by getFileList(), gfPcrGetRanges(), pcrServer(), queryServer(), startSeqQuery(), startServer(), statusServer(), and stopServer().

{
static char signature[] = "0ddf270562684f29";
return signature;
}

Here is the caller graph for this function:

void gfTransFindClumps	(	struct genoFind *	gfs[3],
		aaSeq *	seq,
		struct gfClump *	clumps[3],
		struct lm *	lm,
		int *	retHitCount
	)

Definition at line 1897 of file genoFind.c.

References gfFindClumps(), gfClump::hitCount, and lm.

Referenced by gfFindAlignAaTrans(), gfTransTransFindClumps(), and transQuery().

{
int frame;
int oneHit;
int hitCount = 0;
for (frame = 0; frame < 3; ++frame)
    {
    clumps[frame] = gfFindClumps(gfs[frame], seq, lm, &oneHit);
    hitCount += oneHit;
    }
*retHitCount = hitCount;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gfTransTransFindClumps	(	struct genoFind *	gfs[3],
		aaSeq *	seqs[3],
		struct gfClump *	clumps[3][3],
		struct lm *	lm,
		int *	retHitCount
	)

Definition at line 1911 of file genoFind.c.

References gfTransFindClumps(), gfClump::hitCount, and lm.

Referenced by gfTransTransFindBundles(), and transTransQuery().

{
int qFrame;
int oneHit;
int hitCount = 0;

for (qFrame = 0; qFrame<3; ++qFrame)
    {
    gfTransFindClumps(gfs, seqs[qFrame], clumps[qFrame], lm, &oneHit);
    hitCount += oneHit;
    }
*retHitCount = hitCount;
}

Here is the call graph for this function:

Here is the caller graph for this function:

---