inc/chainConnect.h File Reference

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

Go to the source code of this file.

Data Structures
struct	chainConnect
Functions
int	chainConnectCost (struct cBlock *a, struct cBlock *b, struct chainConnect *cc)
int	chainConnectGapCost (int dq, int dt, struct chainConnect *cc)
void	chainRemovePartialOverlaps (struct chain *chain, struct dnaSeq *qSeq, struct dnaSeq *tSeq, int matrix[256][256])
void	chainMergeAbutting (struct chain *chain)
double	chainScoreBlock (char *q, char *t, int size, int matrix[256][256])
double	chainCalcScore (struct chain *chain, struct axtScoreScheme *ss, struct gapCalc *gapCalc, struct dnaSeq *query, struct dnaSeq *target)
double	chainCalcScoreSubChain (struct chain *chain, struct axtScoreScheme *ss, struct gapCalc *gapCalc, struct dnaSeq *query, struct dnaSeq *target)
void	chainCalcBounds (struct chain *chain)
void	cBlockFindCrossover (struct cBlock *left, struct cBlock *right, struct dnaSeq *qSeq, struct dnaSeq *tSeq, int overlap, int matrix[256][256], int *retPos, int *retScoreAdjustment)

---

Function Documentation

void cBlockFindCrossover	(	struct cBlock *	left,
		struct cBlock *	right,
		struct dnaSeq *	qSeq,
		struct dnaSeq *	tSeq,
		int	overlap,
		int	matrix[256][256],
		int *	retPos,
		int *	retScoreAdjustment
	)

Definition at line 59 of file chainConnect.c.

References chainScoreBlock(), dnaSeq::dna, errAbort(), cBlock::qEnd, cBlock::qStart, dnaSeq::size, cBlock::tEnd, and cBlock::tStart.

Referenced by chainConnectCost(), and chainRemovePartialOverlaps().

{
int bestPos = 0;
char *rqStart = qSeq->dna + right->qStart;
char *lqStart = qSeq->dna + left->qEnd - overlap;
char *rtStart = tSeq->dna + right->tStart;
char *ltStart = tSeq->dna + left->tEnd - overlap;
int i;
double score, bestScore, rScore, lScore;

/* Make sure overlap is not larger than either block size: */
if (overlap > (left->tEnd - left->tStart) ||
    overlap > (right->tEnd - right->tStart))
    errAbort("overlap is %d -- too large for one of these:\n"
             "qSize=%d  tSize=%d\n"
             "left: qStart=%d qEnd=%d (%d) tStart=%d tEnd=%d (%d)\n"
             "right: qStart=%d qEnd=%d (%d) tStart=%d tEnd=%d (%d)\n",
             overlap, qSeq->size, tSeq->size,
             left->qStart, left->qEnd, left->qEnd - left->qStart,
             left->tStart, left->tEnd, left->tEnd - left->tStart,
             right->qStart, right->qEnd, right->qEnd - right->qStart, 
             right->tStart, right->tEnd, right->tEnd - right->tStart);

score = bestScore = rScore = chainScoreBlock(rqStart, rtStart, overlap, matrix);
lScore = chainScoreBlock(lqStart, ltStart, overlap, matrix);
for (i=0; i<overlap; ++i)
    {
    score += matrix[(int)lqStart[i]][(int)ltStart[i]];
    score -= matrix[(int)rqStart[i]][(int)rtStart[i]];
    if (score > bestScore)
        {
        bestScore = score;
        bestPos = i+1;
        }
    }
*retPos = bestPos;
*retScoreAdjustment = rScore + lScore - bestScore;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void chainCalcBounds

(

struct chain *

chain

)

Definition at line 199 of file chainConnect.c.

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

Referenced by removeNegativeBlocks().

{
struct cBlock *b = chain->blockList;
if (chain->blockList == NULL)
    return;
chain->qStart = b->qStart;
chain->tStart = b->tStart;
b = slLastEl(chain->blockList);
chain->qEnd = b->qEnd;
chain->tEnd = b->tEnd;
}

Here is the call graph for this function:

Here is the caller graph for this function:

double chainCalcScore	(	struct chain *	chain,
		struct axtScoreScheme *	ss,
		struct gapCalc *	gapCalc,
		struct dnaSeq *	query,
		struct dnaSeq *	target
	)

Definition at line 22 of file chainConnect.c.

References b1, chain::blockList, chainScoreBlock(), dnaSeq::dna, gapCalcCost(), cBlock::qStart, ss, and cBlock::tStart.

{
struct cBlock *b1, *b2;
double score = 0;
for (b1 = chain->blockList; b1 != NULL; b1 = b2)
    {
    score += chainScoreBlock(query->dna + b1->qStart, 
        target->dna + b1->tStart, b1->tEnd - b1->tStart, ss->matrix);
    b2 = b1->next;
    if (b2 != NULL)
        score -=  gapCalcCost(gapCalc, b2->qStart - b1->qEnd, 
                              b2->tStart - b1->tEnd);
    }
return score;
}

Here is the call graph for this function:

double chainCalcScoreSubChain	(	struct chain *	chain,
		struct axtScoreScheme *	ss,
		struct gapCalc *	gapCalc,
		struct dnaSeq *	query,
		struct dnaSeq *	target
	)

Definition at line 40 of file chainConnect.c.

References b1, chain::blockList, chainScoreBlock(), dnaSeq::dna, gapCalcCost(), chain::qStart, cBlock::qStart, ss, chain::tStart, and cBlock::tStart.

{
struct cBlock *b1, *b2;
double score = 0;
for (b1 = chain->blockList; b1 != NULL; b1 = b2)
    {
    score += chainScoreBlock(query->dna + (b1->qStart) - chain->qStart, 
        target->dna + (b1->tStart) - chain->tStart, b1->tEnd - b1->tStart, ss->matrix);
    b2 = b1->next;
    if (b2 != NULL)
        score -=  gapCalcCost(gapCalc, b2->qStart - b1->qEnd, 
                              b2->tStart - b1->tEnd);
    }
return score;
}

Here is the call graph for this function:

int chainConnectCost	(	struct cBlock *	a,
		struct cBlock *	b,
		struct chainConnect *	cc
	)

Definition at line 112 of file chainConnect.c.

References cBlockFindCrossover(), errAbort(), chainConnect::gapCalc, gapCalcCost(), axtScoreScheme::matrix, min, cBlock::qEnd, cBlock::qStart, chainConnect::query, chainConnect::ss, chainConnect::target, cBlock::tEnd, and cBlock::tStart.

{
int dq = b->qStart - a->qEnd;
int dt = b->tStart - a->tEnd;
int overlapAdjustment = 0;

if (a->qStart >= b->qStart || a->tStart >= b->tStart)
    {
    errAbort("a (%d %d) not strictly before b (%d %d)",
        a->qStart, a->tStart, b->qStart, b->tStart);
    }
if (dq < 0 || dt < 0)
   {
   int bSize = b->qEnd - b->qStart;
   int aSize = a->qEnd - a->qStart;
   int overlap = -min(dq, dt);
   int crossover;
   if (overlap >= bSize || overlap >= aSize) 
       {
       /* One of the blocks is enclosed completely on one dimension
        * or other by the other.  Discourage this overlap. */
       overlapAdjustment = 100000000;
       }
   else
       {
       cBlockFindCrossover(a, b, cc->query, cc->target, overlap, 
                cc->ss->matrix, &crossover, &overlapAdjustment);
       dq += overlap;
       dt += overlap;
       }
   }
return overlapAdjustment + gapCalcCost(cc->gapCalc, dq, dt);
}

Here is the call graph for this function:

int chainConnectGapCost	(	int	dq,
		int	dt,
		struct chainConnect *	cc
	)

Definition at line 106 of file chainConnect.c.

References chainConnect::gapCalc, and gapCalcCost().

{
return gapCalcCost(cc->gapCalc, dq, dt);
}

Here is the call graph for this function:

void chainMergeAbutting

(

struct chain *

chain

)

Definition at line 344 of file chainConnect.c.

References chain::blockList, freeMem(), cBlock::next, slAddHead, and slReverse().

{
struct cBlock *newList = NULL, *b, *last = NULL, *next;
for (b = chain->blockList; b != NULL; b = next)
    {
    next = b->next;
    if (last == NULL || last->qEnd != b->qStart || last->tEnd != b->tStart)
        {
        slAddHead(&newList, b);
        last = b;
        }
    else
        {
        last->qEnd = b->qEnd;
        last->tEnd = b->tEnd;
        freeMem(b);
        }
    }
slReverse(&newList);
chain->blockList = newList;
}

Here is the call graph for this function:

void chainRemovePartialOverlaps	(	struct chain *	chain,
		struct dnaSeq *	qSeq,
		struct dnaSeq *	tSeq,
		int	matrix[256][256]
	)

Definition at line 253 of file chainConnect.c.

References chain::blockList, cBlockFindCrossover(), checkChainGaps(), checkChainIncreases(), checkStartBeforeEnd(), FALSE, freez(), min, cBlock::next, cBlock::qEnd, cBlock::qStart, removeNegativeBlocks(), setChainBounds(), cBlock::tEnd, TRUE, and cBlock::tStart.

{
struct cBlock *a, *b;
boolean totalTrimA, totalTrimB;

assert(chain->blockList != NULL);

/* Do an internal sanity check to make sure that things
 * really are sorted by both qStart and tStart. */
checkChainIncreases(chain, "before removePartialOverlaps");

/* Remove overlapping portion of blocks.  In some
 * tricky repeating regions this can result in 
 * complete blocks being removed.  This complicates
 * the loop below in some cases, forcing us to essentially
 * start over when the first of the two blocks we
 * are examining gets trimmed out completely. */
for (;;)
    {
    totalTrimA = totalTrimB = FALSE;
    a = chain->blockList;
    b = a->next;
    for (;;)
        {
        int dq, dt;
        if (b == NULL)
            break;
        dq = b->qStart - a->qEnd;
        dt = b->tStart - a->tEnd;
        if (dq < 0 || dt < 0)
           {
           int overlap = -min(dq, dt);
           int aSize = a->qEnd - a->qStart;
           int bSize = b->qEnd - b->qStart;
           int crossover, invCross, overlapAdjustment;
           if (overlap >= aSize || overlap >= bSize)
               {
               totalTrimB = TRUE;
               }
           else
               {
               cBlockFindCrossover(a, b, qSeq, tSeq, overlap, matrix, 
                             &crossover, &overlapAdjustment);
               b->qStart += crossover;
               b->tStart += crossover;
               invCross = overlap - crossover;
               a->qEnd -= invCross;
               a->tEnd -= invCross;
               if (b->qEnd <= b->qStart)
                   {
                   totalTrimB = TRUE;
                   }
               else if (a->qEnd <= a->qStart)
                   {
                   totalTrimA = TRUE;
                   }
               }
           }
        if (totalTrimA == TRUE)
            {
            removeNegativeBlocks(chain);
            break;
            }
        else if (totalTrimB == TRUE)
            {
            b = b->next;
            freez(&a->next);
            a->next = b;
            totalTrimB = FALSE;
            }
        else
            {
            a = b;
            b = b->next;
            }
        }
    if (!totalTrimA)
        break;
    }

/* Reset chain bounds - may have clipped them in this
 * process. */
setChainBounds(chain);

/* Do internal sanity checks. */
checkChainGaps(chain, "after removePartialOverlaps");
checkStartBeforeEnd(chain, "after removePartialOverlaps");
}

Here is the call graph for this function:

double chainScoreBlock	(	char *	q,
		char *	t,
		int	size,
		int	matrix[256][256]
	)

Definition at line 12 of file chainConnect.c.

Referenced by cBlockFindCrossover(), chainCalcScore(), and chainCalcScoreSubChain().

{
double score = 0;
int i;
for (i=0; i<size; ++i)
    score += matrix[(int)q[i]][(int)t[i]];
return score;
}

Here is the caller graph for this function:

---