jkOwnLib/gfBlatLib.c File Reference

#include "common.h"
#include "net.h"
#include "linefile.h"
#include "sqlNum.h"
#include "dnaseq.h"
#include "fa.h"
#include "fuzzyFind.h"
#include "supStitch.h"
#include "genoFind.h"
#include "gfInternal.h"
#include "errabort.h"
#include "nib.h"
#include "twoBit.h"
#include "trans3.h"

Include dependency graph for gfBlatLib.c:

Go to the source code of this file.

Functions
void	gfRangeFree (struct gfRange **pEl)
void	gfRangeFreeList (struct gfRange **pList)
static struct gfRange *	gfRangeLoad (char **row)
int	gfRangeCmpTarget (const void *va, const void *vb)
static void	startSeqQuery (int conn, bioSeq *seq, char *type)
static void	gfServerWarn (bioSeq *seq, char *warning)
static struct gfRange *	gfQuerySeq (int conn, struct dnaSeq *seq)
static int	findTileSize (char *line)
gfHit *	getHitsFromServer (int conn, struct lm *lm)
static void	gfQuerySeqTrans (int conn, aaSeq *seq, struct gfClump *clumps[2][3], struct lm *lm, struct gfSeqSource **retSsList, int *retTileSize)
static void	gfQuerySeqTransTrans (int conn, struct dnaSeq *seq, struct gfClump *clumps[2][3][3], struct lm *lm, struct gfSeqSource **retSsList, int *retTileSize)
gfRange *	gfRangesBundle (struct gfRange *exonList, int maxIntron)
static boolean	alignComponents (struct gfRange *combined, struct ssBundle *bun, enum ffStringency stringency)
static int	scoreAli (struct ffAli *ali, boolean isProt, enum ffStringency stringency, struct dnaSeq *tSeq, struct trans3 *t3List)
static void	saveAlignments (char *chromName, int chromSize, int chromOffset, struct ssBundle *bun, struct hash *t3Hash, boolean qIsRc, boolean tIsRc, enum ffStringency stringency, int minMatch, struct gfOutput *out)
hash *	gfFileCacheNew ()
static void	gfFileCacheFreeEl (struct hashEl *el)
void	gfFileCacheFree (struct hash **pCache)
static void	getTargetName (char *tSpec, boolean includeFile, char *targetName)
void	gfAlignStrand (int *pConn, char *tSeqDir, struct dnaSeq *seq, boolean isRc, int minMatch, struct hash *tFileCache, struct gfOutput *out)
char *	clumpTargetName (struct gfClump *clump)
static struct gfRange *	seqClumpToRangeList (struct gfClump *clumpList, int frame)
static struct ssBundle *	gfClumpsToBundles (struct gfClump *clumpList, boolean isRc, struct dnaSeq *seq, int minScore, struct gfRange **retRangeList)
static void	extendHitRight (int qMax, int tMax, char **pEndQ, char **pEndT, int(*scoreMatch)(char a, char b), int maxDown)
static void	extendHitLeft (int qMax, int tMax, char **pStartQ, char **pStartT, int(*scoreMatch)(char a, char b), int maxDown)
static void	clumpToHspRange (struct gfClump *clump, bioSeq *qSeq, int tileSize, int frame, struct trans3 *t3, struct gfRange **pRangeList, boolean isProt, boolean fastMap)
ssFfItem *	gfRangesToFfItem (struct gfRange *rangeList, aaSeq *qSeq)
static struct ssBundle *	fastMapClumpsToBundles (struct genoFind *gf, struct gfClump *clumpList, bioSeq *qSeq)
static void	gfAlignSomeClumps (struct genoFind *gf, struct gfClump *clumpList, bioSeq *seq, boolean isRc, int minMatch, struct gfOutput *out, boolean isProt, enum ffStringency stringency)
void	gfAlignAaClumps (struct genoFind *gf, struct gfClump *clumpList, aaSeq *seq, boolean isRc, int minMatch, struct gfOutput *out)
int	rangeScore (struct gfRange *range, struct dnaSeq *qSeq)
void	gfFindAlignAaTrans (struct genoFind *gfs[3], aaSeq *qSeq, struct hash *t3Hash, boolean tIsRc, int minMatch, struct gfOutput *out)
void	rangeCoorTimes3 (struct gfRange *rangeList)
static void	loadHashT3Ranges (struct gfRange *rangeList, char *tSeqDir, struct hash *tFileCache, int qSeqSize, boolean isRc, struct hash **retT3Hash, struct dnaSeq **retSeqList, struct slRef **retT3RefList)
void	gfAlignTrans (int *pConn, char *tSeqDir, aaSeq *seq, int minMatch, struct hash *tFileCache, struct gfOutput *out)
void	untranslateRangeList (struct gfRange *rangeList, int qFrame, int tFrame, struct hash *t3Hash, struct trans3 *t3, int tOffset)
void	gfAlignTransTrans (int *pConn, char *tSeqDir, struct dnaSeq *qSeq, boolean qIsRc, int minMatch, struct hash *tFileCache, struct gfOutput *out, boolean isRna)
static struct ssBundle *	gfTransTransFindBundles (struct genoFind *gfs[3], struct dnaSeq *qSeq, struct hash *t3Hash, boolean isRc, int minMatch, boolean isRna)
static void	addToBigBundleList (struct ssBundle **pOneList, struct hash *bunHash, struct ssBundle **pBigList, struct dnaSeq *query)
static boolean	jiggleSmallExons (struct ffAli *ali, struct dnaSeq *nSeq, struct dnaSeq *hSeq)
static struct ffAli *	refineSmallExons (struct ffAli *ff, struct dnaSeq *nSeq, struct dnaSeq *hSeq)
static void	refineSmallExonsInBundle (struct ssBundle *bun)
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)
Variables
static char const	rcsid [] = "$Id: gfBlatLib.c,v 1.25 2007/04/20 22:44:11 kent Exp $"
static int	ssAliCount = 16
static int	usualExpansion = 500

---

Function Documentation

static void addToBigBundleList	(	struct ssBundle **	pOneList,
		struct hash *	bunHash,
		struct ssBundle **	pBigList,
		struct dnaSeq *	query
	)			[static]

Definition at line 1323 of file gfBlatLib.c.

References AllocVar, ssBundle::avoidFuzzyFindKludge, ssBundle::ffList, ssBundle::genoSeq, hashAdd(), hashFindVal(), ssBundle::isProt, dnaSeq::name, name, ssBundle::next, slAddHead, slCat(), and ssBundleFreeList().

{
struct ssBundle *oneBun, *bigBun;

for (oneBun = *pOneList; oneBun != NULL; oneBun = oneBun->next)
    {
    char *name = oneBun->genoSeq->name;
    if ((bigBun = hashFindVal(bunHash, name)) == NULL)
        {
        AllocVar(bigBun);
        slAddHead(pBigList, bigBun);
        hashAdd(bunHash, name, bigBun);
        bigBun->qSeq = query;
        bigBun->genoSeq = oneBun->genoSeq;
        bigBun->isProt = oneBun->isProt;
        bigBun->avoidFuzzyFindKludge = oneBun->avoidFuzzyFindKludge;
        }
    bigBun->ffList = slCat(bigBun->ffList, oneBun->ffList);
    oneBun->ffList = NULL;
    }
ssBundleFreeList(pOneList);
}

Here is the call graph for this function:

static boolean alignComponents	(	struct gfRange *	combined,
		struct ssBundle *	bun,
		enum ffStringency	stringency
	)			[static]

Definition at line 399 of file gfBlatLib.c.

References AllocVar, gfRange::components, dnaSeq::dna, FALSE, ffFind(), ssBundle::ffList, ssBundle::genoSeq, gfRange::next, gfRange::qEnd, ssBundle::qSeq, gfRange::qStart, slAddHead, gfRange::tEnd, TRUE, and gfRange::tStart.

Referenced by gfAlignStrand(), and gfClumpsToBundles().

{
struct gfRange *range;
struct dnaSeq *qSeq = bun->qSeq, *tSeq = bun->genoSeq;
struct ssFfItem *ffi;
struct ffAli *ali;
int qStart, qEnd, tStart, tEnd;
int extra = 250;
boolean gotAny = FALSE;

for (range = combined->components; range != NULL; range = range->next)
    {
    /* Expand to include some extra sequence around range. */
    qStart = range->qStart - extra;
    tStart = range->tStart - extra;
    qEnd = range->qEnd + extra;
    tEnd = range->tEnd + extra;
    if (range == combined->components)
        {
        qStart -= extra;
        tStart -= extra;
        }
    if (range->next == NULL)
        {
        qEnd += extra;
        tEnd += extra;
        }
    if (qStart < combined->qStart) qStart = combined->qStart;
    if (tStart < combined->tStart) tStart = combined->tStart;
    if (qEnd > combined->qEnd) qEnd = combined->qEnd;
    if (tEnd > combined->tEnd) tEnd = combined->tEnd;
    ali = ffFind(qSeq->dna + qStart,
                 qSeq->dna + qEnd,
                 tSeq->dna + tStart - combined->tStart,
                 tSeq->dna + tEnd - combined->tStart,
                 stringency);
    if (ali != NULL)
        {
        AllocVar(ffi);
        ffi->ff = ali;
        slAddHead(&bun->ffList, ffi);
        gotAny = TRUE;
        }
    }
return gotAny;
}

Here is the call graph for this function:

Here is the caller graph for this function:

char* clumpTargetName

(

struct gfClump *

clump

)

Definition at line 587 of file gfBlatLib.c.

References gfSeqSource::fileName, internalErr, dnaSeq::name, name, gfSeqSource::seq, and gfClump::target.

Referenced by gfAlignTrans(), gfAlignTransTrans(), and seqClumpToRangeList().

{
struct gfSeqSource *target = clump->target;
char *name;
if (target->seq != NULL)
    name = target->seq->name;
else
    name = target->fileName;
if (name == NULL)
    internalErr();
return name;
}

Here is the caller graph for this function:

static void clumpToHspRange	(	struct gfClump *	clump,
		bioSeq *	qSeq,
		int	tileSize,
		int	frame,
		struct trans3 *	t3,
		struct gfRange **	pRangeList,
		boolean	isProt,
		boolean	fastMap
	)			[static]

Definition at line 718 of file gfBlatLib.c.

References aaScore2(), AllocVar, cloneString(), dnaSeq::dna, dnaScore2(), extendHitLeft(), extendHitRight(), FALSE, gfClump::hitList, internalErr, dnaSeq::name, gfHit::next, gfRange::qEnd, gfHit::qStart, gfSeqSource::seq, dnaSeq::size, slAddHead, gfSeqSource::start, gfRange::t3, gfClump::target, gfRange::tEnd, TRUE, gfRange::tSeq, gfRange::tStart, and gfHit::tStart.

Referenced by fastMapClumpsToBundles(), gfAlignSomeClumps(), gfAlignTrans(), gfAlignTransTrans(), gfFindAlignAaTrans(), and gfTransTransFindBundles().

{
struct gfSeqSource *target = clump->target;
aaSeq *tSeq = target->seq;
BIOPOL *qs, *ts, *qe, *te;
struct gfHit *hit;
int qStart = 0, tStart = 0, qEnd = 0, tEnd = 0, newQ = 0, newT = 0;
boolean outOfIt = TRUE;         /* Logically outside of a clump. */
struct gfRange *range;
BIOPOL *lastQs = NULL, *lastQe = NULL, *lastTs = NULL, *lastTe = NULL;
int (*scoreMatch)(char a, char b) = (isProt ? aaScore2 : dnaScore2);
int maxDown, minSpan;

if (fastMap)
    {
    maxDown = 1;
    minSpan = 50;
    }
else
    {
    maxDown = 10;
    minSpan = 0;
    }


if (tSeq == NULL)
    internalErr();

/* The termination condition of this loop is a little complicated.
 * We want to output something either when the next hit can't be
 * merged into the previous, or at the end of the list.  To avoid
 * duplicating the output code we're forced to complicate the loop
 * termination logic.  Hence the check for hit == NULL to break
 * the loop is not until near the end of the loop. */
for (hit = clump->hitList; ; hit = hit->next)
    {
    if (hit != NULL)
        {
        newQ = hit->qStart;
        newT = hit->tStart - target->start;
        }

    /* See if it's time to output merged (diagonally adjacent) hits. */
    if (!outOfIt)       /* Not first time through. */
        {
        /* As a micro-optimization handle strings of adjacent hits
         * specially.  Don't do the extensions until we've merged
         * all adjacent hits. */
        if (hit == NULL || newQ != qEnd || newT != tEnd)
            {
            qs = qSeq->dna + qStart;
            ts = tSeq->dna + tStart;
            qe = qSeq->dna + qEnd;
            te = tSeq->dna + tEnd;
            extendHitRight(qSeq->size - qEnd, tSeq->size - tEnd,
                &qe, &te, scoreMatch, maxDown);
            extendHitLeft(qStart, tStart, &qs, &ts, scoreMatch, maxDown);
            if (qs != lastQs || ts != lastTs || qe != lastQe || qs !=  lastQs)
                {
                lastQs = qs;
                lastTs = ts;
                lastQe = qe;
                lastTe = te;
                if (qe - qs >= minSpan)
                    {
                    AllocVar(range);
                    range->qStart = qs - qSeq->dna;
                    range->qEnd = qe - qSeq->dna;
                    range->tName = cloneString(tSeq->name);
                    range->tSeq = tSeq;
                    range->tStart = ts - tSeq->dna;
                    range->tEnd = te - tSeq->dna;
                    range->hitCount = qe - qs;
                    range->frame = frame;
                    range->t3 = t3;
                    assert(range->tEnd <= tSeq->size);
                    slAddHead(pRangeList, range);
                    }
                }
            outOfIt = TRUE;
            }
        }
    if (hit == NULL)
        break;

    if (outOfIt)
        {
        qStart = newQ;
        qEnd = qStart + tileSize;
        tStart = newT;
        tEnd = tStart + tileSize;
        outOfIt = FALSE;
        }
    else
        {
        qEnd = newQ + tileSize;
        tEnd = newT + tileSize;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void extendHitLeft	(	int	qMax,
		int	tMax,
		char **	pStartQ,
		char **	pStartT,
		int(*)(char a, char b)	scoreMatch,
		int	maxDown
	)			[static]

Definition at line 688 of file gfBlatLib.c.

References min.

Referenced by clumpToHspRange().

{
int maxScore = 0;
int score = 0;
int maxPos = 0;
int last = -min(qMax, tMax);
int i;
char *q = *pStartQ, *t = *pStartT;

for (i=-1; i>=last; --i)
    {
    score += scoreMatch(q[i], t[i]);
    if (score > maxScore)
         {
         maxScore = score;
         maxPos = i;
         }
    else if (i < maxPos - maxDown)
         {
         break;
         }
    }
*pStartQ = q+maxPos;
*pStartT = t+maxPos;
}

Here is the caller graph for this function:

static void extendHitRight	(	int	qMax,
		int	tMax,
		char **	pEndQ,
		char **	pEndT,
		int(*)(char a, char b)	scoreMatch,
		int	maxDown
	)			[static]

Definition at line 659 of file gfBlatLib.c.

References min.

Referenced by clumpToHspRange().

{
int maxScore = 0;
int score = 0;
int maxPos = -1;
int last = min(qMax, tMax);
int i;
char *q = *pEndQ, *t = *pEndT;

for (i=0; i<last; ++i)
    {
    score += scoreMatch(q[i], t[i]);
    if (score > maxScore)
         {
         maxScore = score;
         maxPos = i;
         }
    else if (i > maxPos + maxDown)
         {
         break;
         }
    }
*pEndQ = q+maxPos+1;
*pEndT = t+maxPos+1;
}

Here is the caller graph for this function:

static struct ssBundle* fastMapClumpsToBundles	(	struct genoFind *	gf,
		struct gfClump *	clumpList,
		bioSeq *	qSeq
	)			[static, read]

Definition at line 849 of file gfBlatLib.c.

References AllocVar, clumpToHspRange(), FALSE, gfRangeCmpTarget(), gfRangeFreeList(), gfRangesBundle(), gfRangesToFfItem(), gfClump::next, ssBundle::qSeq, rangeList, slAddHead, slReverse(), slSort(), genoFind::tileSize, and TRUE.

{
struct gfClump *clump;
struct gfRange *rangeList = NULL, *range;
bioSeq *targetSeq;
struct ssBundle *bunList = NULL, *bun;

for (clump = clumpList; clump != NULL; clump = clump->next)
    clumpToHspRange(clump, qSeq, gf->tileSize, 0, NULL, &rangeList, FALSE, TRUE);
slReverse(&rangeList);
slSort(&rangeList, gfRangeCmpTarget);
rangeList = gfRangesBundle(rangeList, 256);
for (range = rangeList; range != NULL; range = range->next)
    {
    targetSeq = range->tSeq;
    AllocVar(bun);
    bun->qSeq = qSeq;
    bun->genoSeq = targetSeq;
    bun->ffList = gfRangesToFfItem(range->components, qSeq);
    bun->isProt = FALSE;
    slAddHead(&bunList, bun);
    }
gfRangeFreeList(&rangeList);
return bunList;
}

Here is the call graph for this function:

static int findTileSize

(

char *

line

)

[static]

Definition at line 162 of file gfBlatLib.c.

References internalErr, nextWord(), sameString, and tileSize.

Referenced by gfQuerySeqTrans(), and gfQuerySeqTransTrans().

{
char *var, *val;
int tileSize = 4;
for (;;)
    {
    var = nextWord(&line);
    if (var == NULL)
         break;
    val = nextWord(&line);
    if (val == NULL)
         {
         internalErr();
         break;
         }
    if (sameString("tileSize", var))
         {
         tileSize = atoi(val);
         if (tileSize <= 0)
             internalErr();
         }
    }
return tileSize;
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct gfHit* getHitsFromServer	(	int	conn,
		struct lm *	lm
	)			[read]

Definition at line 188 of file gfBlatLib.c.

References freez(), internalErr, lm, lmAllocVar, netRecieveLongString(), nextWord(), slAddHead, slReverse(), and sqlUnsigned().

Referenced by gfQuerySeqTrans(), and gfQuerySeqTransTrans().

{
char *s, *line, *q, *t;
struct gfHit *hitList = NULL, *hit;
s = line = netRecieveLongString(conn);
for (;;)
    {
    if ((q = nextWord(&line)) == NULL)
         break;
    if ((t = nextWord(&line)) == NULL)
         internalErr();
    lmAllocVar(lm, hit);
    hit->qStart = sqlUnsigned(q);
    hit->tStart = sqlUnsigned(t);
    slAddHead(&hitList, hit);
    }
freez(&s);
slReverse(&hitList);
return hitList;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void getTargetName	(	char *	tSpec,
		boolean	includeFile,
		char *	targetName
	)			[static]

Definition at line 537 of file gfBlatLib.c.

References gfiGetSeqName(), PATH_LEN, and safef().

Referenced by gfAlignStrand(), gfAlignTrans(), and gfAlignTransTrans().

                                                 : in targetName. */
{
if (includeFile)
    {
    char seqName[128];
    char fileName[PATH_LEN];
    gfiGetSeqName(tSpec, seqName, fileName);
    safef(targetName, PATH_LEN, "%s:%s", fileName, seqName);
    }
else
    gfiGetSeqName(tSpec, targetName, NULL);
}

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:

static void gfAlignSomeClumps	(	struct genoFind *	gf,
		struct gfClump *	clumpList,
		bioSeq *	seq,
		boolean	isRc,
		int	minMatch,
		struct gfOutput *	out,
		boolean	isProt,
		enum ffStringency	stringency
	)			[static]

Definition at line 876 of file gfBlatLib.c.

References AllocVar, clumpToHspRange(), FALSE, ffIntronMax, ssBundle::ffList, ssBundle::genoSeq, gfRangeCmpTarget(), gfRangeFreeList(), gfRangesBundle(), gfRangesToFfItem(), ssBundle::isProt, dnaSeq::name, gfClump::next, ssBundle::qSeq, rangeList, saveAlignments(), dnaSeq::size, slReverse(), slSort(), ssAliCount, ssBundleFree(), ssStitch(), and genoFind::tileSize.

Referenced by gfAlignAaClumps().

{
struct gfClump *clump;
struct gfRange *rangeList = NULL, *range;
bioSeq *targetSeq;
struct ssBundle *bun;
int intronMax = ffIntronMax;

if (isProt)
    intronMax /= 3;
for (clump = clumpList; clump != NULL; clump = clump->next)
    {
    clumpToHspRange(clump, seq, gf->tileSize, 0, NULL, &rangeList, isProt, FALSE);
    }
slReverse(&rangeList);
slSort(&rangeList, gfRangeCmpTarget);
rangeList = gfRangesBundle(rangeList, intronMax);
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 = isProt;
    ssStitch(bun, stringency, minMatch, ssAliCount);
    saveAlignments(targetSeq->name, targetSeq->size, 0, 
        bun, NULL, isRc, FALSE, stringency, minMatch, out);
    ssBundleFree(&bun);
    }
gfRangeFreeList(&rangeList);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gfAlignStrand	(	int *	pConn,
		char *	tSeqDir,
		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 *	tSeqDir,
		aaSeq *	seq,
		int	minMatch,
		struct hash *	tFileCache,
		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(), gfClump::next, slRef::next, gfSeqSource::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 *	tSeqDir,
		struct dnaSeq *	qSeq,
		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(), gfClump::next, slRef::next, gfSeqSource::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:

static struct ssBundle* gfClumpsToBundles	(	struct gfClump *	clumpList,
		boolean	isRc,
		struct dnaSeq *	seq,
		int	minScore,
		struct gfRange **	retRangeList
	)			[static, read]

Definition at line 627 of file gfBlatLib.c.

References alignComponents(), AllocVar, FALSE, ffCdna, ssBundle::genoSeq, gfiExpandRange(), gfRangeCmpTarget(), gfRangesBundle(), range::next, ssBundle::qSeq, rangeList, seqClumpToRangeList(), dnaSeq::size, slAddHead, slReverse(), slSort(), ssAliCount, and ssStitch().

{
struct ssBundle *bun, *bunList = NULL;
struct gfRange *rangeList = NULL, *range;
struct dnaSeq *targetSeq;

rangeList = seqClumpToRangeList(clumpList, 0);
slSort(&rangeList, gfRangeCmpTarget);
rangeList = gfRangesBundle(rangeList, 2000);
for (range = rangeList; range != NULL; range = range->next)
    {
    targetSeq = range->tSeq;
    gfiExpandRange(range, seq->size, targetSeq->size, FALSE, isRc, 
        usualExpansion);
    range->tStart = 0;
    range->tEnd = targetSeq->size;
    AllocVar(bun);
    bun->qSeq = seq;
    bun->genoSeq = targetSeq;
    alignComponents(range, bun, ffCdna);
    ssStitch(bun, ffCdna, minScore, ssAliCount);
    slAddHead(&bunList, bun);
    }
slReverse(&bunList);
*retRangeList = rangeList;
return bunList;
}

Here is the call 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:

static void gfFileCacheFreeEl

(

struct hashEl *

el

)

[static]

Definition at line 509 of file gfBlatLib.c.

References hashEl::name, name, nibInfoFree(), nibIsFile(), twoBitClose(), and hashEl::val.

Referenced by gfFileCacheFree().

{
char *name = el->name;
if (nibIsFile(name))
    {
    struct nibInfo *nib = el->val;
    nibInfoFree(&nib);
    }
else
    {
    struct twoBitFile *tbf = el->val;
    twoBitClose(&tbf);
    }
el->val = NULL;
}

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, tileSize, genoFind::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:

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:

static struct gfRange* gfQuerySeq	(	int	conn,
		struct dnaSeq *	seq
	)			[static, read]

Definition at line 127 of file gfBlatLib.c.

References chopLine, errAbort(), gfRangeLoad(), gfServerWarn(), netRecieveString(), rangeList, sameString, slAddHead, slReverse(), startSeqQuery(), and startsWith().

Referenced by gfAlignStrand().

{
struct gfRange *rangeList = NULL, *range;
char buf[256], *row[6];
int rowSize;

startSeqQuery(conn, seq, "query");

/* Read results line by line and save in list, and return. */
for (;;)
    {
    netRecieveString(conn, buf);
    if (sameString(buf, "end"))
        {
        break;
        }
    else if (startsWith("Error:", buf))
        {
        gfServerWarn(seq, buf);
        break;
        }
    else
        {
        rowSize = chopLine(buf, row);
        if (rowSize < 6)
            errAbort("Expecting 6 words from server got %d", rowSize);
        range = gfRangeLoad(row);
        slAddHead(&rangeList, range);
        }
    }
slReverse(&rangeList);
return rangeList;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void gfQuerySeqTrans	(	int	conn,
		aaSeq *	seq,
		struct gfClump *	clumps[2][3],
		struct lm *	lm,
		struct gfSeqSource **	retSsList,
		int *	retTileSize
	)			[static]

Definition at line 210 of file gfBlatLib.c.

References AllocVar, chopLine, cloneString(), errAbort(), findTileSize(), getHitsFromServer(), gfServerWarn(), gfClump::hitCount, gfClump::hitList, lm, netRecieveString(), gfClump::qEnd, gfClump::qStart, sameString, gfSeqSource::seq, slAddHead, slCount(), slReverse(), sqlUnsigned(), ss, startSeqQuery(), startsWith(), gfClump::target, gfClump::tEnd, tileSize, and gfClump::tStart.

Referenced by gfAlignTrans().

{
int frame, isRc, rowSize;
struct gfClump *clump;
int tileSize = 0;
char *line;
char buf[256], *row[12];
struct gfSeqSource *ssList = NULL, *ss;

for (isRc = 0; isRc <= 1; ++isRc)
    for (frame = 0; frame<3; ++frame)
        clumps[isRc][frame] = NULL;

/* Send sequence to server. */
startSeqQuery(conn, seq, "protQuery");
line = netRecieveString(conn, buf);
if (!startsWith("Error:", line))
    {
    tileSize = findTileSize(line);

    /* Read results line by line and save in memory. */
    for (;;)
        {
        /* Read and parse first line that describes clump overall. */
        netRecieveString(conn, buf);
        if (sameString(buf, "end"))
            {
            break;
            }
        else if (startsWith("Error:", buf))
            {
            gfServerWarn(seq, buf);
            break;
            }
        rowSize = chopLine(buf, row);
        if (rowSize < 8)
            errAbort("Expecting 8 words from server got %d", rowSize);
        AllocVar(clump);
        clump->qStart = sqlUnsigned(row[0]);
        clump->qEnd = sqlUnsigned(row[1]);
        AllocVar(ss);
        ss->fileName = cloneString(row[2]);
        slAddHead(&ssList, ss);
        clump->target = ss;
        clump->tStart = sqlUnsigned(row[3]);
        clump->tEnd = sqlUnsigned(row[4]);
        clump->hitCount = sqlUnsigned(row[5]);
        isRc = ((row[6][0] == '-') ? 1 : 0);
        frame = sqlUnsigned(row[7]);
        slAddHead(&clumps[isRc][frame], clump);

        /* Read and parse next (long) line that describes hits. */
        clump->hitList = getHitsFromServer(conn, lm);
        assert(slCount(clump->hitList) == clump->hitCount);
        }
    for (isRc = 0; isRc <= 1; ++isRc)
        for (frame = 0; frame<3; ++frame)
            slReverse(&clumps[isRc][frame]);
    }
else
    {
    gfServerWarn(seq, line);
    }
*retSsList = ssList;
*retTileSize = tileSize;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void gfQuerySeqTransTrans	(	int	conn,
		struct dnaSeq *	seq,
		struct gfClump *	clumps[2][3][3],
		struct lm *	lm,
		struct gfSeqSource **	retSsList,
		int *	retTileSize
	)			[static]

Definition at line 279 of file gfBlatLib.c.

References AllocVar, chopLine, cloneString(), errAbort(), findTileSize(), getHitsFromServer(), gfServerWarn(), gfClump::hitCount, gfClump::hitList, lm, netRecieveString(), gfClump::qEnd, gfClump::qStart, sameString, gfSeqSource::seq, slAddHead, slCount(), slReverse(), sqlUnsigned(), ss, startSeqQuery(), startsWith(), gfClump::target, gfClump::tEnd, tileSize, and gfClump::tStart.

Referenced by gfAlignTransTrans().

{
int qFrame, tFrame, isRc, rowSize;
struct gfClump *clump;
int tileSize = 0;
char *line;
char buf[256], *row[12];
struct gfSeqSource *ssList = NULL, *ss;

for (isRc = 0; isRc <= 1; ++isRc)
    for (qFrame = 0; qFrame<3; ++qFrame)
        for (tFrame = 0; tFrame<3; ++tFrame)
            clumps[isRc][qFrame][tFrame] = NULL;

/* Send sequence to server. */
startSeqQuery(conn, seq, "transQuery");
line = netRecieveString(conn, buf);
if (!startsWith("Error:", line))
    {
    tileSize = findTileSize(line);

    /* Read results line by line and save in memory. */
    for (;;)
        {
        /* Read and parse first line that describes clump overall. */
        netRecieveString(conn, buf);
        if (sameString(buf, "end"))
            {
            break;
            }
        else if (startsWith("Error:", buf))
            {
            gfServerWarn(seq, buf);
            break;
            }
        rowSize = chopLine(buf, row);
        if (rowSize < 9)
            errAbort("Expecting 9 words from server got %d", rowSize);
        AllocVar(clump);
        clump->qStart = sqlUnsigned(row[0]);
        clump->qEnd = sqlUnsigned(row[1]);
        AllocVar(ss);
        ss->fileName = cloneString(row[2]);
        slAddHead(&ssList, ss);
        clump->target = ss;
        clump->tStart = sqlUnsigned(row[3]);
        clump->tEnd = sqlUnsigned(row[4]);
        clump->hitCount = sqlUnsigned(row[5]);
        isRc = ((row[6][0] == '-') ? 1 : 0);
        qFrame = sqlUnsigned(row[7]);
        tFrame = sqlUnsigned(row[8]);
        slAddHead(&clumps[isRc][qFrame][tFrame], clump);

        /* Read and parse next (long) line that describes hits. */
        clump->hitList = getHitsFromServer(conn, lm);
        assert(slCount(clump->hitList) == clump->hitCount);
        }
    for (isRc = 0; isRc <= 1; ++isRc)
        for (qFrame = 0; qFrame<3; ++qFrame)
            for (tFrame = 0; tFrame<3; ++tFrame)
                slReverse(&clumps[isRc][qFrame][tFrame]);
    }
else
    {
    gfServerWarn(seq, buf);
    }
*retSsList = ssList;
*retTileSize = tileSize;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int gfRangeCmpTarget	(	const void *	va,
		const void *	vb
	)

Definition at line 83 of file gfBlatLib.c.

References gfRange::t3, gfRange::tName, and gfRange::tStart.

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

{
const struct gfRange *a = *((struct gfRange **)va);
const struct gfRange *b = *((struct gfRange **)vb);
int diff;

diff = strcmp(a->tName, b->tName);
if (diff == 0)
    {
    long lDiff = a->t3 - b->t3;
    if (lDiff < 0)
       diff = -1;
    else if (lDiff > 0)
       diff = 1;
    else
       diff = 0;
#ifdef SOLARIS_WORKAROUND_COMPILER_BUG_BUT_FAILS_IN_64_BIT
    diff = (unsigned long)(a->t3) - (unsigned long)(b->t3);     /* Casts needed for Solaris.  Thanks Darren Platt! */
#endif /* SOLARIS_WORKAROUND_COMPILER_BUG_BUT_FAILS_IN_64_BIT */
    }
if (diff == 0)
    diff = a->tStart - b->tStart;
return diff;
}

Here is the caller graph for this function:

void gfRangeFree

(

struct gfRange **

pEl

)

Definition at line 41 of file gfBlatLib.c.

References gfRange::components, freeMem(), freez(), gfRangeFreeList(), and gfRange::tName.

Referenced by gfRangeFreeList().

{
struct gfRange *el;

if ((el = *pEl) == NULL) return;
freeMem(el->tName);
if (el->components != NULL)
    gfRangeFreeList(&el->components);
freez(pEl);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gfRangeFreeList

(

struct gfRange **

pList

)

Definition at line 54 of file gfBlatLib.c.

References gfRangeFree(), and gfRange::next.

Referenced by fastMapClumpsToBundles(), ffSeedExtInMem(), gfAlignSomeClumps(), gfAlignStrand(), gfAlignTrans(), gfAlignTransTrans(), gfFindAlignAaTrans(), gfPcrOneViaNet(), gfRangeFree(), and gfTransTransFindBundles().

{
struct gfRange *el, *next;

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

Here is the call graph for this function:

Here is the caller graph for this function:

static struct gfRange* gfRangeLoad

(

char **

row

)

[static, read]

Definition at line 67 of file gfBlatLib.c.

References AllocVar, cloneString(), gfRange::hitCount, gfRange::qEnd, gfRange::qStart, gfRange::tEnd, gfRange::tName, and gfRange::tStart.

Referenced by gfQuerySeq().

{
struct gfRange *ret;

AllocVar(ret);
ret->qStart = atoi(row[0]);
ret->qEnd = atoi(row[1]);
ret->tName = cloneString(row[2]);
ret->tStart = atoi(row[3]);
ret->tEnd = atoi(row[4]);
ret->hitCount = atoi(row[5]);
return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct gfRange* gfRangesBundle	(	struct gfRange *	exonList,
		int	maxIntron
	)			[read]

Definition at line 355 of file gfBlatLib.c.

References AllocVar, cloneString(), gfRange::next, sameString, slAddHead, and slAddTail().

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

{
struct gfRange *geneList = NULL, *gene = NULL, *lastExon = NULL, *exon, *nextExon;

for (exon = exonList; exon != NULL; exon = nextExon)
    {
    nextExon = exon->next;
    if (lastExon == NULL || !sameString(lastExon->tName, exon->tName) 
        || exon->t3  != lastExon->t3
        || exon->tStart - lastExon->tEnd > maxIntron)
        {
        AllocVar(gene);
        gene->tStart = exon->tStart;
        gene->tEnd = exon->tEnd;
        gene->tName = cloneString(exon->tName);
        gene->tSeq = exon->tSeq;
        gene->qStart = exon->qStart;
        gene->qEnd = exon->qEnd;
        gene->hitCount = exon->hitCount;
        gene->t3 = exon->t3;
        slAddHead(&gene->components, exon);
        slAddHead(&geneList, gene);
        }
    else
        {
        if (exon->qStart < gene->qStart) gene->qStart = exon->qStart;
        if (exon->qEnd > gene->qEnd) gene->qEnd = exon->qEnd;
        if (exon->tStart < gene->tStart) gene->tStart = exon->tStart;
        if (exon->tEnd > gene->tEnd) gene->tEnd = exon->tEnd;
        gene->hitCount += exon->hitCount;
        slAddTail(&gene->components, exon);
        }
    lastExon = exon;
    }
slReverse(&geneList);
return geneList;
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct ssFfItem* gfRangesToFfItem	(	struct gfRange *	rangeList,
		aaSeq *	qSeq
	)			[read]

Definition at line 824 of file gfBlatLib.c.

References AllocVar, dnaSeq::dna, ssFfItem::ff, ffMakeRightLinks(), gfRange::next, gfRange::qEnd, gfRange::qStart, rangeList, gfRange::tEnd, gfRange::tSeq, and gfRange::tStart.

Referenced by fastMapClumpsToBundles(), ffSeedExtInMem(), gfAlignSomeClumps(), gfAlignTrans(), gfAlignTransTrans(), gfFindAlignAaTrans(), and gfTransTransFindBundles().

{
AA *q = qSeq->dna;
struct ffAli *ffList = NULL, *ff;
struct gfRange *range;
struct ssFfItem *ffi;

for (range = rangeList; range != NULL; range = range->next)
    {
    aaSeq *tSeq = range->tSeq;
    AA *t = tSeq->dna;
    AllocVar(ff);
    ff->nStart = q + range->qStart;
    ff->nEnd = q + range->qEnd;
    ff->hStart = t + range->tStart;
    ff->hEnd = t + range->tEnd;
    ff->left = ffList;
    ffList = ff;
    }
AllocVar(ffi);
ffi->ff = ffMakeRightLinks(ffList);
return ffi;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void gfServerWarn	(	bioSeq *	seq,
		char *	warning
	)			[static]

Definition at line 121 of file gfBlatLib.c.

References dnaSeq::name, and warn().

Referenced by gfQuerySeq(), gfQuerySeqTrans(), and gfQuerySeqTransTrans().

{
warn("couldn't process %s: %s", seq->name, warning);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct ssBundle* gfTransTransFindBundles	(	struct genoFind *	gfs[3],
		struct dnaSeq *	qSeq,
		struct hash *	t3Hash,
		boolean	isRc,
		int	minMatch,
		boolean	isRna
	)			[static, read]

Definition at line 1271 of file gfBlatLib.c.

References AllocVar, clumpToHspRange(), FALSE, ffCdna, ssBundle::ffList, ffLoose, ssBundle::genoSeq, gfClumpFreeList(), gfRangeCmpTarget(), gfRangeFreeList(), gfRangesBundle(), gfRangesToFfItem(), gfTransTransFindClumps(), lm, lmCleanup(), lmInit(), range::next, gfClump::next, ssBundle::qSeq, rangeList, slAddHead, slCat(), slReverse(), slSort(), ssAliCount, ssStitch(), genoFind::tileSize, tileSize, trans3::trans, trans3Free(), trans3New(), TRUE, and untranslateRangeList().

{
struct trans3 *qTrans = trans3New(qSeq);
int qFrame, tFrame;
struct gfClump *clumps[3][3], *clump;
struct gfRange *rangeList = NULL, *range;
int tileSize = gfs[0]->tileSize;
bioSeq *targetSeq;
struct ssBundle *bun, *bunList = NULL;
int hitCount;
struct lm *lm = lmInit(0);
enum ffStringency stringency = (isRna ? ffCdna : ffLoose);

gfTransTransFindClumps(gfs, qTrans->trans, clumps, lm, &hitCount);
for (qFrame = 0; qFrame<3; ++qFrame)
    {
    for (tFrame=0; tFrame<3; ++tFrame)
        {
        for (clump = clumps[qFrame][tFrame]; clump != NULL; clump = clump->next)
            {
            struct gfRange *rangeSet = NULL;
            clumpToHspRange(clump, qTrans->trans[qFrame], tileSize, tFrame, NULL, &rangeSet, TRUE, FALSE);
            untranslateRangeList(rangeSet, qFrame, tFrame, t3Hash, NULL, 0);
            rangeList = slCat(rangeSet, rangeList);
            }
        }
    }
slSort(&rangeList, gfRangeCmpTarget);
rangeList = gfRangesBundle(rangeList, 2000);
for (range = rangeList; range != NULL; range = range->next)
    {
    targetSeq = range->tSeq;
    AllocVar(bun);
    bun->qSeq = qSeq;
    bun->genoSeq = targetSeq;
    bun->ffList = gfRangesToFfItem(range->components, qSeq);
    ssStitch(bun, stringency, minMatch, ssAliCount);
    slAddHead(&bunList, bun);
    }
for (qFrame = 0; qFrame<3; ++qFrame)
    for (tFrame=0; tFrame<3; ++tFrame)
        gfClumpFreeList(&clumps[qFrame][tFrame]);
gfRangeFreeList(&rangeList);
trans3Free(&qTrans);
lmCleanup(&lm);
slReverse(&bunList);
return bunList;
}

Here is the call graph for this function:

static boolean jiggleSmallExons	(	struct ffAli *	ali,
		struct dnaSeq *	nSeq,
		struct dnaSeq *	hSeq
	)			[static]

Definition at line 1349 of file gfBlatLib.c.

References FALSE, ffAliCount(), ffIntronOrientation(), ffSlideIntrons(), ffAli::hEnd, ffAli::hStart, ffAli::left, memMatch(), ffAli::nEnd, ffAli::nStart, ffAli::right, and TRUE.

Referenced by refineSmallExons().

{
struct ffAli *left, *mid, *right;
int orient;
boolean creeped = FALSE;

if (ffAliCount(ali) < 3)
    return FALSE;
orient = ffIntronOrientation(ali);
left = ali;
mid = left->right;
right = mid->right;
while (right != NULL)
    {
    int midSizeN = mid->nEnd - mid->nStart;
    if (midSizeN < 10 && mid->hStart - left->hEnd > 1 && right->hStart - mid->hEnd > 1)
        {
        DNA *spLeft, *spRight;  /* Splice sites on either side of exon. */
        DNA exonX[10+2+2];    /* Storage for exon with splice sites. */
        DNA *match;
        static int creeps[4][2] = { {2, 2}, {2, 1}, {1, 2}, {1, 1},};
        int creepIx, creepL, creepR;
        DNA *hs = mid->hStart, *he = mid->hEnd;
        DNA *hMin = left->hEnd,  *hMax = right->hStart;
        if (orient >= 0)
            {
            spLeft = "ag";
            spRight = "gt";
            }
        else
            {
            spLeft = "ac";
            spRight = "ct";
            }
        for (creepIx=0; creepIx<4; ++creepIx)
            {
            creepL = creeps[creepIx][0];
            creepR = creeps[creepIx][1];
            /* Check to see if we already match consensus, and if so just bail. */
            if (hs[-1] == spLeft[1] && he[0] == spRight[0])
                {
                if ((creepL == 1 || hs[-2] == spLeft[0]) 
                        && (creepR == 1 || he[1] == spRight[1]))
                    {
                    break;
                    }
                }
            memcpy(exonX, spLeft + 2 - creepL, creepL);
            memcpy(exonX + creepL, mid->nStart, midSizeN);
            memcpy(exonX + creepL + midSizeN, spRight, creepR);
            match = memMatch(exonX, midSizeN + creepR + creepL, hMin, hMax - hMin);
            if (match != NULL)
                {
                mid->hStart = match + creepL;
                mid->hEnd = mid->hStart + (he - hs);
                creeped = TRUE;
                break;
                }
            }
        }
    left = mid;
    mid = right;
    right = right->right;
    }
if (creeped)
    ffSlideIntrons(ali);
return creeped;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void loadHashT3Ranges	(	struct gfRange *	rangeList,
		char *	tSeqDir,
		struct hash *	tFileCache,
		int	qSeqSize,
		boolean	isRc,
		struct hash **	retT3Hash,
		struct dnaSeq **	retSeqList,
		struct slRef **	retT3RefList
	)			[static]

Definition at line 1000 of file gfBlatLib.c.

References cloneString(), trans3::end, freez(), gfiExpandAndLoadCached(), hashAdd(), hashFindVal(), trans3::isRc, dnaSeq::name, newHash(), gfRange::next, trans3::nibSize, rangeList, refAdd(), slAddHead, slAddTail(), trans3::start, gfRange::t3, gfRange::tEnd, gfRange::tName, trans3New(), TRUE, gfRange::tStart, and gfRange::tTotalSize.

Referenced by gfAlignTrans(), and gfAlignTransTrans().

{
struct hash *t3Hash = newHash(10);
struct dnaSeq *targetSeq, *tSeqList = NULL;
struct slRef *t3RefList = NULL;
struct gfRange *range;

for (range = rangeList; range != NULL; range = range->next)
    {
    struct trans3 *t3, *oldT3;

    targetSeq = gfiExpandAndLoadCached(range, tFileCache,
        tSeqDir, qSeqSize*3, &range->tTotalSize, TRUE, isRc, usualExpansion);
    slAddHead(&tSeqList, targetSeq);
    freez(&targetSeq->name);
    targetSeq->name = cloneString(range->tName);
    t3 = trans3New(targetSeq);
    refAdd(&t3RefList, t3);
    t3->start = range->tStart;
    t3->end = range->tEnd;
    t3->nibSize = range->tTotalSize;
    t3->isRc = isRc;
    if ((oldT3 = hashFindVal(t3Hash, range->tName)) != NULL)
        {
        slAddTail(&oldT3->next, t3);
        }
    else
        {
        hashAdd(t3Hash, range->tName, t3);
        }
    }
*retT3Hash = t3Hash;
*retSeqList = tSeqList;
*retT3RefList = t3RefList;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void rangeCoorTimes3

(

struct gfRange *

rangeList

)

Definition at line 986 of file gfBlatLib.c.

References gfRange::next, gfRange::qEnd, gfRange::qStart, rangeList, gfRange::tEnd, and gfRange::tStart.

Referenced by gfAlignTrans(), and gfAlignTransTrans().

{
struct gfRange *range;
for (range = rangeList; range != NULL; range = range->next)
    {
    range->qStart *= 3;
    range->qEnd *= 3;
    range->tStart = range->tStart*3;
    range->tEnd = range->tEnd*3;
    }
}

Here is the caller graph for this function:

int rangeScore	(	struct gfRange *	range,
		struct dnaSeq *	qSeq
	)

Definition at line 920 of file gfBlatLib.c.

References gfRange::components, dnaSeq::dna, dnaScoreMatch(), gfRange::next, gfRange::qStart, gfRange::tEnd, gfRange::tSeq, and gfRange::tStart.

{
struct gfRange *comp;
struct dnaSeq *tSeq;
int score = 0;
for (comp = range->components; comp != NULL; comp = comp->next)
    {
    tSeq = comp->tSeq;
    score += dnaScoreMatch(tSeq->dna + range->tStart, qSeq->dna + range->qStart, 
        range->tEnd - range->tStart);
    if (comp->next != NULL)
        score -= 4;
    }
return score;
}

Here is the call graph for this function:

static struct ffAli* refineSmallExons	(	struct ffAli *	ff,
		struct dnaSeq *	nSeq,
		struct dnaSeq *	hSeq
	)			[static, read]

Definition at line 1420 of file gfBlatLib.c.

References ffRemoveEmptyAlis(), jiggleSmallExons(), and TRUE.

Referenced by refineSmallExonsInBundle().

{
if (jiggleSmallExons(ff, nSeq, hSeq))
    ff = ffRemoveEmptyAlis(ff, TRUE);
return ff;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void refineSmallExonsInBundle

(

struct ssBundle *

bun

)

[static]

Definition at line 1431 of file gfBlatLib.c.

References ssFfItem::ff, ssBundle::ffList, ssBundle::genoSeq, ssFfItem::next, ssBundle::qSeq, and refineSmallExons().

{
struct ssFfItem *fi;    /* Item list - memory owned by bundle. */

for (fi = bun->ffList; fi != NULL; fi = fi->next)
    {
    fi->ff = refineSmallExons(fi->ff, bun->qSeq, bun->genoSeq);
    }
}

Here is the call graph for this function:

static void saveAlignments	(	char *	chromName,
		int	chromSize,
		int	chromOffset,
		struct ssBundle *	bun,
		struct hash *	t3Hash,
		boolean	qIsRc,
		boolean	tIsRc,
		enum ffStringency	stringency,
		int	minMatch,
		struct gfOutput *	out
	)			[static]

Definition at line 477 of file gfBlatLib.c.

References ssFfItem::ff, ssBundle::ffList, ssBundle::genoSeq, hashMustFindVal(), ssBundle::isProt, dnaSeq::name, ssFfItem::next, gfOutput::out, ssBundle::qSeq, scoreAli(), and dnaSeq::size.

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

{
struct dnaSeq *tSeq = bun->genoSeq, *qSeq = bun->qSeq;
struct ssFfItem *ffi;
if (minMatch > qSeq->size/2) minMatch = qSeq->size/2;
if (minMatch < 1) minMatch = 1;
for (ffi = bun->ffList; ffi != NULL; ffi = ffi->next)
    {
    struct ffAli *ff = ffi->ff;
    struct trans3 *t3List = NULL;
    int score;
    if (t3Hash != NULL)
        t3List = hashMustFindVal(t3Hash, tSeq->name);
    score = scoreAli(ff, bun->isProt, stringency, tSeq, t3List);
    if (score >= minMatch)
        {
        out->out(chromName, chromSize, chromOffset, ff, tSeq, t3Hash, qSeq, 
            qIsRc, tIsRc, stringency, minMatch, out);
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int scoreAli	(	struct ffAli *	ali,
		boolean	isProt,
		enum ffStringency	stringency,
		struct dnaSeq *	tSeq,
		struct trans3 *	t3List
	)			[static]

Definition at line 449 of file gfBlatLib.c.

References aaScoreMatch(), dnaScoreMatch(), FALSE, ffCalcGapPenalty(), ffAli::hEnd, ffAli::hStart, ffAli::nEnd, ffAli::nStart, ffAli::right, trans3GenoPos(), and TRUE.

Referenced by saveAlignments().

{
int (*scoreFunc)(char *a, char *b, int size);
struct ffAli *ff, *nextFf;
int score = 0;
if (isProt) 
    scoreFunc = aaScoreMatch;
else
    scoreFunc = dnaScoreMatch;
for (ff = ali; ff != NULL; ff = nextFf)
    {
    nextFf = ff->right;
    score += scoreFunc(ff->nStart, ff->hStart, ff->nEnd-ff->nStart);
    if (nextFf != NULL)
        {
        int nhStart = trans3GenoPos(nextFf->hStart, tSeq, t3List, FALSE);
        int ohEnd = trans3GenoPos(ff->hEnd, tSeq, t3List, TRUE);
        int hGap = nhStart - ohEnd;
        int nGap = nextFf->nStart - ff->nEnd;
        score -= ffCalcGapPenalty(hGap, nGap, stringency);
        }
    }
return score;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct gfRange* seqClumpToRangeList	(	struct gfClump *	clumpList,
		int	frame
	)			[static, read]

Definition at line 601 of file gfBlatLib.c.

References AllocVar, cloneString(), clumpTargetName(), name, gfClump::next, gfClump::qEnd, gfClump::qStart, rangeList, gfSeqSource::seq, slAddHead, slReverse(), gfSeqSource::start, gfClump::target, gfClump::tEnd, and gfClump::tStart.

Referenced by gfAlignTrans(), gfAlignTransTrans(), and gfClumpsToBundles().

{
struct gfRange *rangeList = NULL, *range;
struct gfClump *clump;
char *name;
int tOff;

for (clump = clumpList; clump != NULL; clump = clump->next)
    {
    tOff = clump->target->start;
    AllocVar(range);
    range->qStart = clump->qStart;
    range->qEnd = clump->qEnd;
    name = clumpTargetName(clump);
    range->tName = cloneString(name);
    range->tStart = clump->tStart - tOff;
    range->tEnd = clump->tEnd - tOff;
    range->tSeq = clump->target->seq;
    range->frame = frame;
    slAddHead(&rangeList, range);
    }
slReverse(&rangeList);
return rangeList;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void startSeqQuery	(	int	conn,
		bioSeq *	seq,
		char *	type
	)			[static]

Definition at line 109 of file gfBlatLib.c.

References dnaSeq::dna, errAbort(), gfSignature(), and dnaSeq::size.

Referenced by gfQuerySeq(), gfQuerySeqTrans(), and gfQuerySeqTransTrans().

{
char buf[256];
sprintf(buf, "%s%s %d", gfSignature(), type, seq->size);
write(conn, buf, strlen(buf));
read(conn, buf, 1);
if (buf[0] != 'Y')
    errAbort("Expecting 'Y' from server, got %c", buf[0]);
write(conn, seq->dna, seq->size);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void untranslateRangeList	(	struct gfRange *	rangeList,
		int	qFrame,
		int	tFrame,
		struct hash *	t3Hash,
		struct trans3 *	t3,
		int	tOffset
	)

Definition at line 1145 of file gfBlatLib.c.

References dnaSeq::name, gfRange::next, gfRange::qEnd, gfRange::qStart, rangeList, trans3::seq, gfRange::t3, gfRange::tEnd, trans3Find(), gfRange::tSeq, and gfRange::tStart.

Referenced by gfAlignTransTrans(), and gfTransTransFindBundles().

{
struct gfRange *range;
for (range = rangeList; range != NULL; range = range->next)
    {
    range->qStart = 3*range->qStart + qFrame;
    range->qEnd = 3*range->qEnd + qFrame;
    range->tStart = 3*range->tStart + tFrame;
    range->tEnd = 3*range->tEnd + tFrame;
    if (t3Hash)
        t3 = trans3Find(t3Hash, range->tSeq->name, range->tStart + tOffset, range->tEnd + tOffset);
    range->tSeq = t3->seq;
    range->t3 = t3;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

Variable Documentation

char const rcsid[] = "$Id: gfBlatLib.c,v 1.25 2007/04/20 22:44:11 kent Exp $" [static]

Definition at line 21 of file gfBlatLib.c.

int ssAliCount = 16 [static]

Definition at line 23 of file gfBlatLib.c.

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

int usualExpansion = 500 [static]

Definition at line 397 of file gfBlatLib.c.

---