lib/chain.c File Reference

#include "common.h"
#include "linefile.h"
#include "hash.h"
#include "dnaseq.h"
#include "dnautil.h"
#include "chain.h"

Include dependency graph for chain.c:

Go to the source code of this file.

Defines
#define	FACTOR   300000000
Functions
void	chainFree (struct chain **pChain)
void	chainFreeList (struct chain **pList)
int	cBlockCmpTarget (const void *va, const void *vb)
int	cBlockCmpBoth (const void *va, const void *vb)
int	cBlockCmpDiagQuery (const void *va, const void *vb)
void	cBlocksAddOffset (struct cBlock *blockList, int qOff, int tOff)
int	chainCmpScore (const void *va, const void *vb)
int	chainCmpScoreDesc (const void *va, const void *vb)
int	chainCmpTarget (const void *va, const void *vb)
int	chainCmpQuery (const void *va, const void *vb)
void	chainIdSet (int id)
void	chainIdReset ()
void	chainIdNext (struct chain *chain)
void	chainWriteHead (struct chain *chain, FILE *f)
void	chainWrite (struct chain *chain, FILE *f)
void	chainWriteAll (struct chain *chainList, FILE *f)
void	chainWriteLong (struct chain *chain, FILE *f)
chain *	chainReadChainLine (struct lineFile *lf)
void	chainReadBlocks (struct lineFile *lf, struct chain *chain)
chain *	chainRead (struct lineFile *lf)
void	chainSwap (struct chain *chain)
hash *	chainReadUsedSwapLf (char *fileName, boolean swapQ, Bits *bits, struct lineFile *lf)
hash *	chainReadUsedSwap (char *fileName, boolean swapQ, Bits *bits)
hash *	chainReadAllSwap (char *fileName, boolean swapQ)
hash *	chainReadAll (char *fileName)
hash *	chainReadAllWithMeta (char *fileName, FILE *f)
chain *	chainLookup (struct hash *hash, int id)
void	chainSubsetOnT (struct chain *chain, int subStart, int subEnd, struct chain **retSubChain, struct chain **retChainToFree)
void	chainFastSubsetOnT (struct chain *chain, struct cBlock *firstBlock, int subStart, int subEnd, struct chain **retSubChain, struct chain **retChainToFree)
void	chainSubsetOnQ (struct chain *chain, int subStart, int subEnd, struct chain **retSubChain, struct chain **retChainToFree)
void	chainRangeQPlusStrand (struct chain *chain, int *retQs, int *retQe)
Variables
static char const	rcsid [] = "$Id: chain.c,v 1.25 2007/02/19 18:29:32 kent Exp $"
static int	nextId = 1

---

Define Documentation

#define FACTOR   300000000

Definition at line 117 of file chain.c.

---

Function Documentation

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

Definition at line 47 of file chain.c.

References cBlock::qStart, and cBlock::tStart.

{
const struct cBlock *a = *((struct cBlock **)va);
const struct cBlock *b = *((struct cBlock **)vb);
int dif;
dif = a->qStart - b->qStart;
if (dif == 0)
    dif = a->tStart - b->tStart;
return dif;
}

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

Definition at line 59 of file chain.c.

References cBlock::qStart, and cBlock::tStart.

{
const struct cBlock *a = *((struct cBlock **)va);
const struct cBlock *b = *((struct cBlock **)vb);
int dif;
dif = (a->tStart - a->qStart) - (b->tStart - b->qStart);
if (dif == 0)
    dif = a->qStart - b->qStart;
return dif;
}

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

Definition at line 39 of file chain.c.

References cBlock::tStart.

{
const struct cBlock *a = *((struct cBlock **)va);
const struct cBlock *b = *((struct cBlock **)vb);
return a->tStart - b->tStart;
}

void cBlocksAddOffset	(	struct cBlock *	blockList,
		int	qOff,
		int	tOff
	)

Definition at line 71 of file chain.c.

References cBlock::next, cBlock::qEnd, cBlock::qStart, cBlock::tEnd, and cBlock::tStart.

{
struct cBlock *block;
for (block = blockList; block != NULL; block = block->next)
    {
    block->tStart += tOff;
    block->tEnd += tOff;
    block->qStart += qOff;
    block->qEnd += qOff;
    }
}

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

Definition at line 119 of file chain.c.

References chain::qName, and chain::qStart.

{
const struct chain *a = *((struct chain **)va);
const struct chain *b = *((struct chain **)vb);
int dif;                                                                        

dif = strcmp(a->qName, b->qName);                                               
if (dif == 0)                                                                   
    dif = a->qStart - b->qStart;                                                
return dif;                       
}

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

Definition at line 84 of file chain.c.

References chain::score.

Referenced by chainBlocks().

{
const struct chain *a = *((struct chain **)va);
const struct chain *b = *((struct chain **)vb);
double diff = b->score - a->score;
if (diff < 0.0) return -1;
else if (diff > 0.0) return 1;
else return 0;
}

Here is the caller graph for this function:

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

Definition at line 95 of file chain.c.

References chain::score.

{
const struct chain *a = *((struct chain **)va);
const struct chain *b = *((struct chain **)vb);
double diff = a->score - b->score;
if (diff < 0.0) return -1;
else if (diff > 0.0) return 1;
else return 0;
}

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

Definition at line 106 of file chain.c.

References chain::tName, and chain::tStart.

{
const struct chain *a = *((struct chain **)va);
const struct chain *b = *((struct chain **)vb);
int dif = strcmp(a->tName, b->tName);
if (dif == 0)
    dif = a->tStart - b->tStart;
return dif;
}

void chainFastSubsetOnT	(	struct chain *	chain,
		struct cBlock *	firstBlock,
		int	subStart,
		int	subEnd,
		struct chain **	retSubChain,
		struct chain **	retChainToFree
	)

Definition at line 432 of file chain.c.

References BIGNUM, CloneVar, cBlock::next, cBlock::qEnd, cBlock::qStart, chain::tEnd, cBlock::tEnd, and cBlock::tStart.

Referenced by chainSubsetOnT().

{
struct chain *sub = NULL;
struct cBlock *oldB, *b, *bList = NULL;
int qStart = BIGNUM, qEnd = -BIGNUM;
int tStart = BIGNUM, tEnd = -BIGNUM;

/* Check for easy case. */
if (subStart <= chain->tStart && subEnd >= chain->tEnd)
    {
    *retSubChain = chain;
    *retChainToFree = NULL;
    return;
    }
/* Build new block list and calculate bounds. */
for (oldB = firstBlock; oldB != NULL; oldB = oldB->next)
    {
    if (oldB->tStart >= subEnd)
        break;
    b = CloneVar(oldB);
    if (b->tStart < subStart)
        {
        b->qStart += subStart - b->tStart;
        b->tStart = subStart;
        }
    if (b->tEnd > subEnd)
        {
        b->qEnd -= b->tEnd - subEnd;
        b->tEnd = subEnd;
        }
    slAddHead(&bList, b);
    if (qStart > b->qStart)
        qStart = b->qStart;
    if (qEnd < b->qEnd)
        qEnd = b->qEnd;
    if (tStart > b->tStart)
        tStart = b->tStart;
    if (tEnd < b->tEnd)
        tEnd = b->tEnd;
    }
slReverse(&bList);

/* Make new chain based on old. */
if (bList != NULL)
    {
    double sizeRatio;
    AllocVar(sub);
    sub->blockList = bList;
    sub->qName = cloneString(chain->qName);
    sub->qSize = chain->qSize;
    sub->qStrand = chain->qStrand;
    sub->qStart = qStart;
    sub->qEnd = qEnd;
    sub->tName = cloneString(chain->tName);
    sub->tSize = chain->tSize;
    sub->tStart = tStart;
    sub->tEnd = tEnd;
    sub->id = chain->id;

    /* Fake new score. */
    sizeRatio = (sub->tEnd - sub->tStart);
    sizeRatio /= (chain->tEnd - chain->tStart);
    sub->score = sizeRatio * chain->score;
    }
*retSubChain = *retChainToFree = sub;
}

Here is the caller graph for this function:

void chainFree

(

struct chain **

pChain

)

Definition at line 13 of file chain.c.

References chain::blockList, freeMem(), freez(), chain::qName, slFreeList(), and chain::tName.

Referenced by chainFreeList(), and chainReadUsedSwapLf().

{
struct chain *chain = *pChain;
if (chain != NULL)
    {
    slFreeList(&chain->blockList);
    freeMem(chain->qName);
    freeMem(chain->tName);
    freez(pChain);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void chainFreeList

(

struct chain **

pList

)

Definition at line 26 of file chain.c.

References chainFree(), and chain::next.

Referenced by ssFindBestBig().

{
struct chain *el, *next;

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

Here is the call graph for this function:

Here is the caller graph for this function:

void chainIdNext

(

struct chain *

chain

)

Definition at line 146 of file chain.c.

References chain::id, and nextId.

Referenced by chainReadChainLine(), and chainWriteHead().

{
chain->id = nextId++;
}

Here is the caller graph for this function:

void chainIdReset

(

)

Definition at line 140 of file chain.c.

References chainIdSet().

{
chainIdSet(1);
}

Here is the call graph for this function:

void chainIdSet

(

int

id

)

Definition at line 134 of file chain.c.

References nextId.

Referenced by chainIdReset().

{
nextId = id;
}

Here is the caller graph for this function:

struct chain* chainLookup	(	struct hash *	hash,
		int	id
	)			[read]

Definition at line 405 of file chain.c.

References hashMustFindVal(), and safef().

{
char nameBuf[16];
safef(nameBuf, sizeof(nameBuf), "%x", id);
return hashMustFindVal(hash, nameBuf);
}

Here is the call graph for this function:

void chainRangeQPlusStrand	(	struct chain *	chain,
		int *	retQs,
		int *	retQe
	)

Definition at line 572 of file chain.c.

References errAbort(), chain::qEnd, chain::qSize, chain::qStart, and chain::qStrand.

{
if (chain == NULL)
    errAbort("chain::chainRangeQPlusStrand() - Can't find range in null query chain.");
if (chain->qStrand == '-')
    {
    *retQs = chain->qSize - chain->qEnd;
    *retQe = chain->qSize - chain->qStart;
    }
else
    {
    *retQs = chain->qStart;
    *retQe = chain->qEnd;
    }
}

Here is the call graph for this function:

struct chain* chainRead

(

struct lineFile *

lf

)

[read]

Definition at line 289 of file chain.c.

References chainReadBlocks(), and chainReadChainLine().

Referenced by chainReadUsedSwapLf().

{
struct chain *chain = chainReadChainLine(lf);
if (chain != NULL)
    chainReadBlocks(lf, chain);
return chain;
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct hash* chainReadAll

(

char *

fileName

)

[read]

Definition at line 389 of file chain.c.

References chainReadAllSwap(), and FALSE.

{
return chainReadAllSwap(fileName, FALSE);
}

Here is the call graph for this function:

struct hash* chainReadAllSwap	(	char *	fileName,
		boolean	swapQ
	)			[read]

Definition at line 383 of file chain.c.

References chainReadUsedSwap().

Referenced by chainReadAll().

{
return chainReadUsedSwap(fileName, swapQ, NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct hash* chainReadAllWithMeta	(	char *	fileName,
		FILE *	f
	)			[read]

Definition at line 395 of file chain.c.

References chainReadUsedSwapLf(), FALSE, lineFileClose(), lineFileOpen(), lineFileSetMetaDataOutput(), and TRUE.

{
struct lineFile *lf = lineFileOpen(fileName, TRUE);
struct hash *hash = NULL;
lineFileSetMetaDataOutput(lf, f);
hash = chainReadUsedSwapLf(fileName, FALSE, NULL, lf);
lineFileClose(&lf);
return hash;
}

Here is the call graph for this function:

void chainReadBlocks	(	struct lineFile *	lf,
		struct chain *	chain
	)

Definition at line 250 of file chain.c.

References AllocVar, chain::blockList, errAbort(), lineFile::fileName, lineFileChop, lineFileNeedNum(), lineFile::lineIx, chain::qEnd, cBlock::qEnd, cBlock::qStart, chain::qStart, slAddHead, slReverse(), chain::tEnd, cBlock::tEnd, cBlock::tStart, and chain::tStart.

Referenced by chainRead().

{
char *row[3];
int q,t;

/* Now read in block list. */
q = chain->qStart;
t = chain->tStart;
for (;;)
    {
    int wordCount = lineFileChop(lf, row);
    int size = lineFileNeedNum(lf, row, 0);
    struct cBlock *b;
    AllocVar(b);
    slAddHead(&chain->blockList, b);
    b->qStart = q;
    b->tStart = t;
    q += size;
    t += size;
    b->qEnd = q;
    b->tEnd = t;
    if (wordCount == 1)
        break;
    else if (wordCount < 3)
        errAbort("Expecting 1 or 3 words line %d of %s\n", 
                lf->lineIx, lf->fileName);
    t += lineFileNeedNum(lf, row, 1);
    q += lineFileNeedNum(lf, row, 2);
    }
if (q != chain->qEnd)
    errAbort("q end mismatch %d vs %d line %d of %s\n", 
        q, chain->qEnd, lf->lineIx, lf->fileName);
if (t != chain->tEnd)
    errAbort("t end mismatch %d vs %d line %d of %s\n", 
        t, chain->tEnd, lf->lineIx, lf->fileName);
slReverse(&chain->blockList);
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct chain* chainReadChainLine

(

struct lineFile *

lf

)

[read]

Definition at line 208 of file chain.c.

References AllocVar, chainIdNext(), cloneString(), errAbort(), lineFile::fileName, chain::id, lineFileChop, lineFileNeedNum(), lineFile::lineIx, chain::qEnd, chain::qName, chain::qSize, chain::qStart, chain::qStrand, sameString, chain::score, chain::tEnd, chain::tName, chain::tSize, and chain::tStart.

Referenced by chainRead().

{
char *row[13];
int wordCount;
struct chain *chain;

wordCount = lineFileChop(lf, row);
if (wordCount == 0)
    return NULL;
if (wordCount < 12)
    errAbort("Expecting at least 12 words line %d of %s", 
        lf->lineIx, lf->fileName);
if (!sameString(row[0], "chain"))
    errAbort("Expecting 'chain' line %d of %s", lf->lineIx, lf->fileName);
AllocVar(chain);
chain->score = atof(row[1]);
chain->tName = cloneString(row[2]);
chain->tSize = lineFileNeedNum(lf, row, 3);
if (wordCount >= 13)
    chain->id = lineFileNeedNum(lf, row, 12);
else
    chainIdNext(chain);

/* skip tStrand for now, always implicitly + */
chain->tStart = lineFileNeedNum(lf, row, 5);
chain->tEnd = lineFileNeedNum(lf, row, 6);
chain->qName = cloneString(row[7]);
chain->qSize = lineFileNeedNum(lf, row, 8);
chain->qStrand = row[9][0];
chain->qStart = lineFileNeedNum(lf, row, 10);
chain->qEnd = lineFileNeedNum(lf, row, 11);
if (chain->qStart >= chain->qEnd || chain->tStart >= chain->tEnd)
    errAbort("End before start line %d of %s", lf->lineIx, lf->fileName);
if (chain->qStart < 0 || chain->tStart < 0)
    errAbort("Start before zero line %d of %s", lf->lineIx, lf->fileName);
if (chain->qEnd > chain->qSize || chain->tEnd > chain->tSize)
    errAbort("Past end of sequence line %d of %s", lf->lineIx, lf->fileName);
return chain;
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct hash* chainReadUsedSwap	(	char *	fileName,
		boolean	swapQ,
		Bits *	bits
	)			[read]

Definition at line 373 of file chain.c.

References chainReadUsedSwapLf(), lineFileClose(), lineFileOpen(), and TRUE.

Referenced by chainReadAllSwap().

{
struct lineFile *lf = lineFileOpen(fileName, TRUE);
struct hash *hash = chainReadUsedSwapLf(fileName, swapQ, NULL, lf);
lineFileClose(&lf);
return hash;
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct hash* chainReadUsedSwapLf	(	char *	fileName,
		boolean	swapQ,
		Bits *	bits,
		struct lineFile *	lf
	)			[read]

Definition at line 344 of file chain.c.

References bitReadOne(), chainFree(), chainRead(), chainSwap(), errAbort(), lineFile::fileName, hashAdd(), hashLookup(), hashNew, chain::id, lineFile::lineIx, and safef().

Referenced by chainReadAllWithMeta(), and chainReadUsedSwap().

{
char nameBuf[16];
struct hash *hash = hashNew(18);
struct chain *chain;
int usedCount = 0, count = 0;

while ((chain = chainRead(lf)) != NULL)
    {
    ++count;
    if (bits != NULL && !bitReadOne(bits, chain->id))
        {
        chainFree(&chain);
        continue;
        }
    safef(nameBuf, sizeof(nameBuf), "%x", chain->id);
    if (hashLookup(hash, nameBuf))
        errAbort("Duplicate chain %d ending line %d of %s", 
                chain->id, lf->lineIx, lf->fileName);
    if (swapQ)
        chainSwap(chain);
    hashAdd(hash, nameBuf, chain);
    ++usedCount;
    }
return hash;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void chainSubsetOnQ	(	struct chain *	chain,
		int	subStart,
		int	subEnd,
		struct chain **	retSubChain,
		struct chain **	retChainToFree
	)

Definition at line 502 of file chain.c.

References AllocVar, BIGNUM, chain::blockList, cloneString(), CloneVar, chain::id, cBlock::next, cBlock::qEnd, chain::qEnd, chain::qName, chain::qSize, cBlock::qStart, chain::qStrand, slAddHead, slReverse(), cBlock::tEnd, chain::tName, chain::tSize, and cBlock::tStart.

{
struct chain *sub = NULL;
struct cBlock *oldB, *b, *bList = NULL;
int qStart = BIGNUM, qEnd = -BIGNUM;
int tStart = BIGNUM, tEnd = -BIGNUM;

/* Check for easy case. */
if (subStart <= chain->qStart && subEnd >= chain->qEnd)
    {
    *retSubChain = chain;
    *retChainToFree = NULL;
    return;
    }
/* Build new block list and calculate bounds. */
for (oldB = chain->blockList; oldB != NULL; oldB = oldB->next)
    {
    if (oldB->qEnd <= subStart)
        continue;
    if (oldB->qStart >= subEnd)
        break;
    b = CloneVar(oldB);
    if (b->qStart < subStart)
        {
        b->tStart += subStart - b->qStart;
        b->qStart = subStart;
        }
    if (b->qEnd > subEnd)
        {
        b->tEnd -= b->qEnd - subEnd;
        b->qEnd = subEnd;
        }
    slAddHead(&bList, b);
    if (tStart > b->tStart)
        tStart = b->tStart;
    if (tEnd < b->tEnd)
        tEnd = b->tEnd;
    if (qStart > b->qStart)
        qStart = b->qStart;
    if (qEnd < b->qEnd)
        qEnd = b->qEnd;
    }
slReverse(&bList);

/* Make new chain based on old. */
if (bList != NULL)
    {
    AllocVar(sub);
    sub->blockList = bList;
    sub->qName = cloneString(chain->qName);
    sub->qSize = chain->qSize;
    sub->qStrand = chain->qStrand;
    sub->qStart = qStart;
    sub->qEnd = qEnd;
    sub->tName = cloneString(chain->tName);
    sub->tSize = chain->tSize;
    sub->tStart = tStart;
    sub->tEnd = tEnd;
    sub->id = chain->id;
    }
*retSubChain = *retChainToFree = sub;
}

Here is the call graph for this function:

void chainSubsetOnT	(	struct chain *	chain,
		int	subStart,
		int	subEnd,
		struct chain **	retSubChain,
		struct chain **	retChainToFree
	)

Definition at line 413 of file chain.c.

References chain::blockList, chainFastSubsetOnT(), cBlock::next, and cBlock::tEnd.

{
/* Find first relevant block. */
struct cBlock *firstBlock;
for (firstBlock = chain->blockList; firstBlock != NULL; firstBlock = firstBlock->next)
    {
    if (firstBlock->tEnd > subStart)
        break;
    }
chainFastSubsetOnT(chain, firstBlock, subStart, subEnd, retSubChain, retChainToFree);
}

Here is the call graph for this function:

void chainSwap

(

struct chain *

chain

)

Definition at line 300 of file chain.c.

References chain::blockList, cBlock::next, cBlock::qEnd, chain::qEnd, chain::qName, chain::qSize, cBlock::qStart, chain::qStart, chain::qStrand, reverseIntRange(), slReverse(), cBlock::tEnd, chain::tEnd, chain::tName, chain::tSize, cBlock::tStart, and chain::tStart.

Referenced by chainReadUsedSwapLf().

{
struct chain old = *chain;
struct cBlock *b;

/* Copy basic stuff swapping t and q. */
chain->qName = old.tName;
chain->tName = old.qName;
chain->qStart = old.tStart;
chain->qEnd = old.tEnd;
chain->tStart = old.qStart;
chain->tEnd = old.qEnd;
chain->qSize = old.tSize;
chain->tSize = old.qSize;

/* Swap t and q in blocks. */
for (b = chain->blockList; b != NULL; b = b->next)
    {
    struct cBlock old = *b;
    b->qStart = old.tStart;
    b->qEnd = old.tEnd;
    b->tStart = old.qStart;
    b->tEnd = old.qEnd;
    }

/* Cope with the minus strand. */
if (chain->qStrand == '-')
    {
    /* chain's are really set up so that the target is on the
     * + strand and the query is on the minus strand.
     * Therefore we need to reverse complement both 
     * strands while swapping to preserve this. */
    for (b = chain->blockList; b != NULL; b = b->next)
        {
        reverseIntRange(&b->tStart, &b->tEnd, chain->tSize);
        reverseIntRange(&b->qStart, &b->qEnd, chain->qSize);
        }
    reverseIntRange(&chain->tStart, &chain->tEnd, chain->tSize);
    reverseIntRange(&chain->qStart, &chain->qEnd, chain->qSize);
    slReverse(&chain->blockList);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void chainWrite	(	struct chain *	chain,
		FILE *	f
	)

Definition at line 163 of file chain.c.

References chain::blockList, chainWriteHead(), cBlock::next, cBlock::qEnd, cBlock::qStart, cBlock::tEnd, and cBlock::tStart.

Referenced by chainWriteAll().

{
struct cBlock *b, *nextB;

chainWriteHead(chain, f);
for (b = chain->blockList; b != NULL; b = nextB)
    {
    nextB = b->next;
    fprintf(f, "%d", b->qEnd - b->qStart);
    if (nextB != NULL)
        fprintf(f, "\t%d\t%d", 
                nextB->tStart - b->tEnd, nextB->qStart - b->qEnd);
    fputc('\n', f);
    }
fputc('\n', f);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void chainWriteAll	(	struct chain *	chainList,
		FILE *	f
	)

Definition at line 181 of file chain.c.

References chainWrite(), and chain::next.

{
struct chain *chain;
for (chain = chainList; chain != NULL; chain = chain->next)
    chainWrite(chain, f);
}

Here is the call graph for this function:

void chainWriteHead	(	struct chain *	chain,
		FILE *	f
	)

Definition at line 152 of file chain.c.

References chainIdNext(), chain::id, chain::qEnd, chain::qName, chain::qSize, chain::qStart, chain::qStrand, chain::score, chain::tEnd, chain::tName, chain::tSize, and chain::tStart.

Referenced by chainWrite(), chainWriteLong(), and peelChains().

{
if (chain->id == 0)
    chainIdNext(chain);
fprintf(f, "chain %1.0f %s %d + %d %d %s %d %c %d %d %d\n", chain->score,
    chain->tName, chain->tSize, chain->tStart, chain->tEnd,
    chain->qName, chain->qSize, chain->qStrand, chain->qStart, chain->qEnd,
    chain->id);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void chainWriteLong	(	struct chain *	chain,
		FILE *	f
	)

Definition at line 189 of file chain.c.

References chain::blockList, chainWriteHead(), cBlock::next, cBlock::qEnd, cBlock::qStart, cBlock::tEnd, and cBlock::tStart.

{
struct cBlock *b, *nextB;

chainWriteHead(chain, f);
for (b = chain->blockList; b != NULL; b = nextB)
    {
    nextB = b->next;
    fprintf(f, "%d\t%d\t", b->tStart, b->qStart);
    fprintf(f, "%d", b->qEnd - b->qStart);
    if (nextB != NULL)
        fprintf(f, "\t%d\t%d", 
                nextB->tStart - b->tEnd, nextB->qStart - b->qEnd);
    fputc('\n', f);
    }
fputc('\n', f);
}

Here is the call graph for this function:

---

Variable Documentation

int nextId = 1 [static]

Definition at line 132 of file chain.c.

Referenced by chainIdNext(), and chainIdSet().

char const rcsid[] = "$Id: chain.c,v 1.25 2007/02/19 18:29:32 kent Exp $" [static]

Definition at line 11 of file chain.c.

---