inc/axt.h File Reference

#include "linefile.h"
#include "dnaseq.h"
#include "chain.h"

Include dependency graph for axt.h:

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

Go to the source code of this file.

Data Structures
struct	axt
struct	axtScoreScheme
struct	axtBundle
Functions
void	axtFree (struct axt **pEl)
void	axtFreeList (struct axt **pList)
axt *	axtRead (struct lineFile *lf)
axt *	axtReadWithPos (struct lineFile *lf, off_t *retOffset)
boolean	axtCheck (struct axt *axt, struct lineFile *lf)
void	axtWrite (struct axt *axt, FILE *f)
int	axtCmpQuery (const void *va, const void *vb)
int	axtCmpTarget (const void *va, const void *vb)
int	axtCmpScore (const void *va, const void *vb)
int	axtCmpTargetScoreDesc (const void *va, const void *vb)
void	axtScoreSchemeFree (struct axtScoreScheme **pObj)
axtScoreScheme *	axtScoreSchemeDefault ()
axtScoreScheme *	axtScoreSchemeSimpleDna (int match, int misMatch, int gapOpen, int gapExtend)
axtScoreScheme *	axtScoreSchemeRnaDefault ()
axtScoreScheme *	axtScoreSchemeFromBlastzMatrix (char *text, int gapOpen, int gapExtend)
axtScoreScheme *	axtScoreSchemeRnaFill ()
axtScoreScheme *	axtScoreSchemeProteinDefault ()
axtScoreScheme *	axtScoreSchemeProteinRead (char *fileName)
axtScoreScheme *	axtScoreSchemeRead (char *fileName)
axtScoreScheme *	axtScoreSchemeReadLf (struct lineFile *lf)
void	axtScoreSchemeDnaWrite (struct axtScoreScheme *ss, FILE *f, char *name)
int	axtScoreSym (struct axtScoreScheme *ss, int symCount, char *qSym, char *tSym)
int	axtScore (struct axt *axt, struct axtScoreScheme *ss)
int	axtScoreFilterRepeats (struct axt *axt, struct axtScoreScheme *ss)
int	axtScoreUngapped (struct axtScoreScheme *ss, char *q, char *t, int size)
int	axtScoreDnaDefault (struct axt *axt)
int	axtScoreProteinDefault (struct axt *axt)
void	axtSubsetOnT (struct axt *axt, int newStart, int newEnd, struct axtScoreScheme *ss, FILE *f)
int	axtTransPosToQ (struct axt *axt, int tPos)
void	axtSwap (struct axt *axt, int tSize, int qSize)
void	axtBundleFree (struct axtBundle **pObj)
void	axtBundleFreeList (struct axtBundle **pList)
void	axtBlastOut (struct axtBundle *abList, int queryIx, boolean isProt, FILE *f, char *databaseName, int databaseSeqCount, double databaseLetterCount, char *blastType, char *ourId, double minIdentity)
axt *	axtAffine (bioSeq *query, bioSeq *target, struct axtScoreScheme *ss)
boolean	axtAffineSmallEnough (double querySize, double targetSize)
axt *	axtAffine2Level (bioSeq *query, bioSeq *target, struct axtScoreScheme *ss)
void	axtAddBlocksToBoxInList (struct cBlock **pList, struct axt *axt)
void	axtPrintTraditional (struct axt *axt, int maxLine, struct axtScoreScheme *ss, FILE *f)
double	axtIdWithGaps (struct axt *axt)
double	axtCoverage (struct axt *axt, int qSize, int tSize)

---

Function Documentation

void axtAddBlocksToBoxInList	(	struct cBlock **	pList,
		struct axt *	axt
	)

Definition at line 820 of file axt.c.

References AllocVar, FALSE, cBlock::qEnd, axt::qStart, cBlock::qStart, axt::qSym, slAddHead, axt::symCount, cBlock::tEnd, axt::tStart, cBlock::tStart, and axt::tSym.

       : list will be in reverse order of axt blocks. */
{
boolean thisIn, lastIn = FALSE;
int qPos = axt->qStart, tPos = axt->tStart;
int qStart = 0, tStart = 0;
int i;

for (i=0; i<=axt->symCount; ++i)
    {
    int advanceQ = (isalpha(axt->qSym[i]) ? 1 : 0);
    int advanceT = (isalpha(axt->tSym[i]) ? 1 : 0);
    thisIn = (advanceQ && advanceT);
    if (thisIn)
        {
        if (!lastIn)
            {
            qStart = qPos;
            tStart = tPos;
            }
        }
    else
        {
        if (lastIn)
            {
            int size = qPos - qStart;
            assert(size == tPos - tStart);
            if (size > 0)
                {
                struct cBlock *b;
                AllocVar(b);
                b->qStart = qStart;
                b->qEnd = qPos;
                b->tStart = tStart;
                b->tEnd = tPos;
                slAddHead(pList, b);
                }
            }
        }
    lastIn = thisIn;
    qPos += advanceQ;
    tPos += advanceT;
    }
}

struct axt* axtAffine	(	bioSeq *	query,
		bioSeq *	target,
		struct axtScoreScheme *	ss
	)			[read]

Definition at line 193 of file axtAffine.c.

References affineAlign(), dnaSeq::dna, dnaSeq::name, phhmTraceToAxt(), phmmMatrixFree(), dnaSeq::size, slFreeList(), and ss.

{
struct axt *axt;
int score;
struct phmmMatrix *matrix;
struct phmmAliPair *pairList;

affineAlign(query->dna, query->size, target->dna, target->size, ss,
        &matrix, &pairList, &score);
axt = phhmTraceToAxt(matrix, pairList, score, query->name, target->name);
phmmMatrixFree(&matrix);
slFreeList(&pairList);
return axt;
}

Here is the call graph for this function:

struct axt* axtAffine2Level	(	bioSeq *	query,
		bioSeq *	target,
		struct axtScoreScheme *	ss
	)			[read]

Definition at line 462 of file axtAffine.c.

References cell2L::backd, cell2L::backi, cell2L::backm, cell2L::bestd, cell2L::besti, cell2L::bestm, cloneString(), dnaSeq::dna, errAbort(), freez(), kForwardAffine(), dnaSeq::name, needLargeMem(), needMem(), reverseBytes(), dnaSeq::size, ss, and WORST.

        :
   Double-gap cost is equal to gap-extend cost, but gap-open would also work.
   On very large target, score integer may overflow.
   Input sequences not checked for invalid chars.
   Input not checked but query should be shorter than target.
   
*/
{
struct axt *axt=needMem(sizeof(struct axt));

char *q = query->dna;
char *t = target->dna;

int Q= query->size;
int T=target->size;
int lv=Q+1;                    /* Q+1 is used so often let's call it lv for q-width */
int lw=T+1;                    /* T+1 is used so often let's call it lw for t-height */


int r = 0;                                 /* row matrix index */
int c = 0;                                 /* col matrix index */
char dir=' ';                              /* dir for bt */
int bestbest = WORST;                      /* best score in entire mtx */

int k=0;                                   /* save every kth row (k decreasing) */
int ksize = 0;                             /* T+1 saved rows as ksize, ksize-1,...,1*/
int arrsize = 0;                           /* dynprg array size, +1 for 0 sentinel col. */
struct cell2L *cells = NULL;               /* best score dyn prog array */
int ki = 0;                                /* base offset into array */
int cmost = Q;                             /* track right edge shrinkage during backtrace */
int kmax = 0;                              /* rows range from ki to kmax */
int rr = 0;                                /* maps ki base to actual target seq */
int nrows = 0;                             /* num rows to do, usually k or less */
int bestr = 0;                             /* remember best r,c,dir for local ali */
int bestc = 0;           
char bestdir = 0;
int temp = 0;


char *btq=NULL;      /* temp pointers to track ends of string while accumulating */
char *btt=NULL;

ksize = (int) (-1 + sqrt(8*lw+1))/2;    
if (((ksize*(ksize+1))/2) < lw) 
    {ksize++;}
arrsize = (ksize+1) * lv;                 /* dynprg array size, +1 for lastrow that moves back up. */
cells = needLargeMem(arrsize * sizeof(struct cell2L));   /* best score dyn prog array */

#ifdef DEBUG
printf("\n k=%d \n ksize=%d \n arrsize=%d \n Q,lv=%d,%d T=%d \n \n",k,ksize,arrsize,Q,lv,T);
#endif

axt->next = NULL;
axt->qName = cloneString(query->name);
axt->tName = cloneString(target->name);
axt->qStrand ='+';
axt->tStrand ='+';
axt->frame = 0;
axt->score=0;
axt->qStart=0;
axt->tStart=0;
axt->qEnd=0;
axt->tEnd=0;
axt->symCount=0;
axt->qSym=NULL;
axt->tSym=NULL;

if ((Q==0) || (T==0))
    {
    axt->qSym=cloneString("");
    axt->tSym=cloneString("");
    freez(&cells);
    return axt; 
    }



/* initialize origin corner */
    cells[0].bestm=0;
    cells[0].bestd=WORST;
    cells[0].besti=WORST;                 
    cells[0].backm='x';
    cells[0].backd='x';
    cells[0].backi='x';
#ifdef DEBUG
    dump2L(cells); 
#endif

/* initialize row 0 col 1 */
    cells[1].bestm=WORST;
    cells[1].bestd=WORST;
    cells[1].besti=-ss->gapOpen;
    cells[1].backm='x';
    cells[1].backd='x';
    cells[1].backi='m';
#ifdef DEBUG
    dump2L(cells+1); 
#endif

/* initialize first row of sentinels */
for (c=2;c<lv;c++)
    {
    cells[c].bestm=WORST;
    cells[c].bestd=WORST;
    cells[c].besti=cells[c-1].besti-ss->gapExtend;
    cells[c].backm='x';
    cells[c].backd='x';
    cells[c].backi='i';
#ifdef DEBUG
    dump2L(cells+c); 
#endif
    }
#ifdef DEBUG
printf("\n");
printf("\n");
#endif

k=ksize;

ki++;  /* advance to next row */

r=1;   /* r is really the rows all done */
while(1)
    {
    nrows = k;  /* do k rows at a time, save every kth row on 1st pass */
    if (nrows > (lw-r)) {nrows=lw-r;}  /* may get less than k on last set */
    kmax = ki+nrows-1;

    kForwardAffine(cells, ki, kmax, r-ki, cmost, lv, q, t, ss, &bestbest, &bestr, &bestc, &bestdir);
#ifdef DEBUG
printf("\n");
#endif

    r += nrows;

    if (nrows == k)   /* got full set of k rows */
        {
        /* compress, save every kth row */     
        /* optimize as a mem-copy */
        memcpy(cells+ki*lv,cells+kmax*lv,sizeof(struct cell2L) *lv);    
        }

    if (r >= lw){break;} /* we are done */
    
    ki++;
    k--;        /* decreasing k is "moving boundary" */
}

#ifdef DEBUG
printf("\nFWD PASS DONE. bestbest=%d bestr=%d bestc=%d bestdir=%c \n\n",bestbest,bestr,bestc,bestdir);
#endif

/* start doing backtrace */
    
/* adjust for reverse pass */

/* for local we automatically skip to bestr, bestc to begin tb */

if (bestbest <= 0)  /* null alignment */
    {
    bestr=0;
    bestc=0;
    /* bestdir won't matter */
    }

r = bestr;
c = bestc;
dir = bestdir;
cmost = c;

axt->qEnd=bestc;
axt->tEnd=bestr;

temp = (2*ksize)+1;
ki = (int)(temp-sqrt((temp*temp)-(8*r)))/2;
rr = ((2*ksize*ki)+ki-(ki*ki))/2;
kmax = ki+(r-rr);
k = ksize - ki;


/* now that we jumped back into saved start-points,
   let's fill the array forward and start backtrace from there.
*/

#ifdef DEBUG
printf("bestr=%d, bestc=%d, bestdir=%c k=%d, ki=%d, kmax=%d\n",bestr,bestc,bestdir,k,ki,kmax);
#endif

kForwardAffine(cells, ki+1, kmax, rr-ki, cmost, lv, q, t, ss, &bestbest, &bestr, &bestc, &bestdir);
   
#ifdef DEBUG
printf("\n(initial)BKWD PASS DONE. cmost=%d r=%d c=%d dir=%c \n\n",cmost,r,c,dir);
#endif


/* backtrace */   

/* handling for resulting ali'd strings when very long */

axt->symCount=0;
axt->qSym = needLargeMem((Q+T+1)*sizeof(char));
axt->tSym = needLargeMem((Q+T+1)*sizeof(char));
btq=axt->qSym;
btt=axt->tSym;
while(1)
    {
    while(1)
        {
#ifdef DEBUG
        printf("bt: r=%d, c=%d, dir=%c \n",r,c,dir);
#endif

        
        if ((r==0) && (c==0)){break;} /* hit origin, done */
        if (r<rr){break;} /* ran out of targ seq, backup and reload */
        if (dir=='x'){errAbort("unexpected error backtracing");} /* x only at origin */
        if (dir=='s'){break;}   /* hit start, local ali */
        if (dir=='m') /* match */
            {
            *btq++=q[c-1];  /* accumulate alignment output strings */
            *btt++=t[r-1];  /* accumulate alignment output strings */
            axt->symCount++; 
            dir = cells[lv*(ki+r-rr)+c].backm;  /* follow backtrace */
            r--;            /* adjust coords to move in dir spec'd by back ptr */
            c--;
            cmost--;        /* decreases as query seq is aligned, so saves on unused areas */
            }
        else
            {
            if (dir=='d')  /* delete in query (gap) */
                {
                *btq++='-';     /* accumulate alignment output strings */
                *btt++=t[r-1];  /* accumulate alignment output strings */
                axt->symCount++; 
                dir = cells[lv*(ki+r-rr)+c].backd;  /* follow backtrace */
                r--;            /* adjust coords to move in dir spec'd by back ptr */
                }
            else    /* insert in query (gap) */
                {
                *btq++=q[c-1];  /* accumulate alignment output strings */
                *btt++='-';     /* accumulate alignment output strings */
                axt->symCount++; 
                dir = cells[lv*(ki+r-rr)+c].backi;  /* follow backtrace */
                c--;
                cmost--;        /* decreases as query seq is aligned, so saves on unused areas */
                }
            }
        
        }

    /* back up and do it again */
    ki--;
    k++;   /* k grows as we move back up */ 
    rr-=k;
    kmax = ki+k-1;

    /* check for various termination conditions to stop main loop */
    if (ki < 0) {break;}
    if ((r==0)&&(c==0)) {break;}
    if (dir=='s') {break;}

    /* re-calculate array from previous saved kth row going back
       this is how we save memory, but have to regenerate half on average
       we are re-using the same call 
     */

#ifdef DEBUG
printf("bestr=%d, bestc=%d, bestdir=%c k=%d, ki=%d, kmax=%d\n",bestr,bestc,bestdir,k,ki,kmax);
#endif


    kForwardAffine(cells, ki+1, kmax, rr-ki, cmost, lv, q, t, ss, &bestbest, &bestr, &bestc, &bestdir);

#ifdef DEBUG
    printf("\nBKWD PASS DONE. cmost=%d r=%d c=%d\n\n",cmost,r,c);
#endif

    }

axt->qStart=c;
axt->tStart=r;

/* reverse backwards trace and zero-terminate strings */

reverseBytes(axt->qSym,axt->symCount);
reverseBytes(axt->tSym,axt->symCount);
axt->qSym[axt->symCount]=0;
axt->tSym[axt->symCount]=0;

axt->score=bestbest;


/* 
should I test stringsize and if massively smaller, realloc string to save ram? 
*/

freez(&cells);

return axt;
}

Here is the call graph for this function:

boolean axtAffineSmallEnough	(	double	querySize,
		double	targetSize
	)

Definition at line 13 of file axtAffine.c.

Referenced by affineAlign().

{
return targetSize * querySize <= 1.0E8;
}

Here is the caller graph for this function:

void axtBlastOut	(	struct axtBundle *	abList,
		int	queryIx,
		boolean	isProt,
		FILE *	f,
		char *	databaseName,
		int	databaseSeqCount,
		double	databaseLetterCount,
		char *	blastType,
		char *	ourId,
		double	minIdentity
	)

Definition at line 782 of file blastOut.c.

References errAbort(), FALSE, ncbiBlastOut(), sameWord, tabBlastOut(), TRUE, wuBlastOut(), and xmlBlastOut().

Referenced by blastQueryOut().

                               :
 *   ab - the list of bundles of axt's. 
 *   f  - output file handle
 *   databaseSeqCount - number of sequences in database
 *   databaseLetterCount - number of bases or aa's in database
 *   blastType - blast/wublast/blast8/blast9/xml
 *   ourId - optional (may be NULL) thing to put in header
 */
{
if (abList == NULL)
    return;
if (sameWord(blastType, "wublast"))
    wuBlastOut(abList, queryIx, isProt, f, databaseName,
        databaseSeqCount, databaseLetterCount, ourId);
else if (sameWord(blastType, "xml"))
    xmlBlastOut(abList, queryIx, isProt, f, databaseName,
        databaseSeqCount, databaseLetterCount, ourId);
else if (sameWord(blastType, "blast"))
    ncbiBlastOut(abList, queryIx, isProt, f, databaseName,
        databaseSeqCount, databaseLetterCount, ourId, minIdentity);
else if (sameWord(blastType, "blast8"))
    tabBlastOut(abList, queryIx, isProt, f, databaseName,
        databaseSeqCount, databaseLetterCount, ourId, FALSE);
else if (sameWord(blastType, "blast9"))
    tabBlastOut(abList, queryIx, isProt, f, databaseName,
        databaseSeqCount, databaseLetterCount, ourId, TRUE);
else
    errAbort("Unrecognized blastType %s in axtBlastOut", blastType);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void axtBundleFree

(

struct axtBundle **

pObj

)

Definition at line 796 of file axt.c.

References axtFreeList(), axtBundle::axtList, and freez().

Referenced by axtBundleFreeList().

{
struct axtBundle *obj = *pObj;
if (obj != NULL)
    {
    axtFreeList(&obj->axtList);
    freez(pObj);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void axtBundleFreeList

(

struct axtBundle **

pList

)

Definition at line 807 of file axt.c.

References axtBundleFree(), and axtBundle::next.

Referenced by axtQueryOut(), blastQueryOut(), mafQueryOut(), and sim4QueryOut().

{
struct axtBundle *el, *next;

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

Here is the call graph for this function:

Here is the caller graph for this function:

boolean axtCheck	(	struct axt *	axt,
		struct lineFile *	lf
	)

Definition at line 167 of file axt.c.

References countNonDash(), FALSE, lineFile::fileName, lineFile::lineIx, axt::qEnd, axt::qStart, axt::qSym, axt::symCount, axt::tEnd, TRUE, axt::tStart, axt::tSym, and warn().

{
int tSize = countNonDash(axt->tSym, axt->symCount);
int qSize = countNonDash(axt->qSym, axt->symCount);
if (tSize != axt->tEnd - axt->tStart)
    {
    warn("%d non-dashes, but %d bases to cover at line %d of %s", 
        tSize, axt->tEnd - axt->tStart, lf->lineIx, lf->fileName);
    return FALSE;
    }
if (qSize != axt->qEnd - axt->qStart)
    {
    warn("%d non-dashes, but %d bases to cover at line %d of %s", 
        tSize, axt->qEnd - axt->qStart, lf->lineIx, lf->fileName);
    return FALSE;
    }
return TRUE;
}

Here is the call graph for this function:

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

Definition at line 123 of file axt.c.

References axt::qName, and axt::qStart.

{
const struct axt *a = *((struct axt **)va);
const struct axt *b = *((struct axt **)vb);
int dif;
dif = strcmp(a->qName, b->qName);
if (dif == 0)
    dif = a->qStart - b->qStart;
return dif;
}

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

Definition at line 147 of file axt.c.

References axt::score.

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

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

Definition at line 135 of file axt.c.

References axt::tName, and axt::tStart.

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

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

Definition at line 155 of file axt.c.

References axt::score, and axt::tName.

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

double axtCoverage	(	struct axt *	axt,
		int	qSize,
		int	tSize
	)

Definition at line 940 of file axt.c.

References axt::qEnd, axt::qStart, axt::tEnd, and axt::tStart.

{
double cov = axt->tEnd - axt->tStart + axt->qEnd - axt->qStart;
return cov/(qSize+tSize);
}

void axtFree

(

struct axt **

pEl

)

Definition at line 25 of file axt.c.

References freeMem(), freez(), axt::qName, axt::qSym, axt::tName, and axt::tSym.

Referenced by axtFreeList().

{
struct axt *el = *pEl;
if (el != NULL)
    {
    freeMem(el->qName);
    freeMem(el->tName);
    freeMem(el->qSym);
    freeMem(el->tSym);
    freez(pEl);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void axtFreeList

(

struct axt **

pList

)

Definition at line 39 of file axt.c.

References axtFree(), and axt::next.

Referenced by axtBundleFree().

{
struct axt *el, *next;

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

Here is the call graph for this function:

Here is the caller graph for this function:

double axtIdWithGaps

(

struct axt *

axt

)

Definition at line 927 of file axt.c.

References axt::qSym, axt::symCount, and axt::tSym.

{
int i;
int matchCount = 0;
for (i=0; i<axt->symCount; ++i)
    {
    if (toupper(axt->qSym[i]) == toupper(axt->tSym[i]))
        ++matchCount;
    }
return (double)matchCount/axt->symCount;
}

void axtPrintTraditional	(	struct axt *	axt,
		int	maxLine,
		struct axtScoreScheme *	ss,
		FILE *	f
	)

Definition at line 866 of file axt.c.

References digitsBaseTen(), max, axt::qEnd, axt::qStart, axt::qSym, spaceOut(), ss, axt::symCount, axt::tEnd, axt::tStart, and axt::tSym.

{
int qPos = axt->qStart;
int tPos = axt->tStart;
int symPos;
int aDigits = digitsBaseTen(axt->qEnd);
int bDigits = digitsBaseTen(axt->tEnd);
int digits = max(aDigits, bDigits);

for (symPos = 0; symPos < axt->symCount; symPos += maxLine)
    {
    /* Figure out which part of axt to use for this line. */
    int lineSize = axt->symCount - symPos;
    int lineEnd, i;
    if (lineSize > maxLine)
        lineSize = maxLine;
    lineEnd = symPos + lineSize;

    /* Draw query line including numbers. */
    fprintf(f, "%0*d ", digits, qPos+1);
    for (i=symPos; i<lineEnd; ++i)
        {
        char c = axt->qSym[i];
        fputc(c, f);
        if (c != '.' && c != '-')
            ++qPos;
        }
    fprintf(f, " %0*d\n", digits, qPos);

    /* Draw line with match/mismatch symbols. */
    spaceOut(f, digits+1);
    for (i=symPos; i<lineEnd; ++i)
        {
        char q = axt->qSym[i];
        char t = axt->tSym[i];
        char out = ' ';
        if (q == t)
            out = '|';
        else if (ss != NULL && ss->matrix[(int)q][(int)t] > 0)
            out = '+';
        fputc(out, f);
        }
    fputc('\n', f);

    /* Draw target line including numbers. */
    fprintf(f, "%0*d ", digits, tPos+1);
    for (i=symPos; i<lineEnd; ++i)
        {
        char c = axt->tSym[i];
        fputc(c, f);
        if (c != '.' && c != '-')
            ++tPos;
        }
    fprintf(f, " %0*d\n", digits, tPos);

    /* Draw extra empty line. */
    fputc('\n', f);
    }
}

Here is the call graph for this function:

struct axt* axtRead

(

struct lineFile *

lf

)

[read]

Definition at line 95 of file axt.c.

References axtReadWithPos().

{
return axtReadWithPos(lf, NULL);
}

Here is the call graph for this function:

struct axt* axtReadWithPos	(	struct lineFile *	lf,
		off_t *	retOffset
	)			[read]

Definition at line 53 of file axt.c.

References AllocVar, cloneMem(), cloneString(), errAbort(), lineFile::fileName, lineFileChop, lineFileNeedNext(), lineFileNeedNum(), lineFileNext(), lineFileTell, lineFile::lineIx, axt::qEnd, axt::qName, axt::qStart, axt::qStrand, axt::qSym, axt::score, axt::symCount, axt::tEnd, axt::tName, axt::tStart, axt::tStrand, and axt::tSym.

Referenced by axtRead().

{
char *words[10], *line;
int wordCount, symCount;
struct axt *axt;

wordCount = lineFileChop(lf, words);
if (retOffset != NULL)
    *retOffset = lineFileTell(lf);
if (wordCount <= 0)
    return NULL;
if (wordCount < 8)
    {
    errAbort("Expecting at least 8 words line %d of %s got %d\n", lf->lineIx, lf->fileName,
        wordCount);
    }
AllocVar(axt);

axt->qName = cloneString(words[4]);
axt->qStart = lineFileNeedNum(lf, words, 5) - 1;
axt->qEnd = lineFileNeedNum(lf, words, 6);
axt->qStrand = words[7][0];
axt->tName = cloneString(words[1]);
axt->tStart = lineFileNeedNum(lf, words, 2) - 1;
axt->tEnd = lineFileNeedNum(lf, words, 3);
axt->tStrand = '+';
if (wordCount > 8)
    axt->score = lineFileNeedNum(lf, words, 8);
lineFileNeedNext(lf, &line, NULL);
axt->symCount = symCount = strlen(line);
axt->tSym = cloneMem(line, symCount+1);
lineFileNeedNext(lf, &line, NULL);
if (strlen(line) != symCount)
    errAbort("Symbol count %d != %d inconsistent between sequences line %d and prev line of %s",
        symCount, (int)strlen(line), lf->lineIx, lf->fileName);
axt->qSym = cloneMem(line, symCount+1);
lineFileNext(lf, &line, NULL);  /* Skip blank line */
return axt;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int axtScore	(	struct axt *	axt,
		struct axtScoreScheme *	ss
	)

Definition at line 286 of file axt.c.

References axtScoreSym(), axt::qSym, ss, axt::symCount, and axt::tSym.

Referenced by axtScoreDnaDefault(), axtScoreProteinDefault(), and axtSubsetOnT().

{
return axtScoreSym(ss, axt->symCount, axt->qSym, axt->tSym);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int axtScoreDnaDefault

(

struct axt *

axt

)

Definition at line 292 of file axt.c.

References axtScore(), axtScoreSchemeDefault(), and ss.

Referenced by axtFromBlocks(), and saveAxtBundle().

{
static struct axtScoreScheme *ss;
if (ss == NULL)
    ss = axtScoreSchemeDefault();
return axtScore(axt, ss);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int axtScoreFilterRepeats	(	struct axt *	axt,
		struct axtScoreScheme *	ss
	)

Definition at line 280 of file axt.c.

References axtScoreSymFilterRepeats(), axt::qSym, ss, axt::symCount, and axt::tSym.

{
return axtScoreSymFilterRepeats(ss, axt->symCount, axt->qSym, axt->tSym);
}

Here is the call graph for this function:

int axtScoreProteinDefault

(

struct axt *

axt

)

Definition at line 301 of file axt.c.

References axtScore(), axtScoreSchemeProteinDefault(), and ss.

Referenced by saveAxtBundle().

{
static struct axtScoreScheme *ss;
if (ss == NULL)
    ss = axtScoreSchemeProteinDefault();
return axtScore(axt, ss);
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct axtScoreScheme* axtScoreSchemeDefault

(

)

[read]

Definition at line 382 of file axt.c.

References AllocVar, propagateCase(), and ss.

Referenced by axtScoreDnaDefault(), and axtScoreSchemeFromBlastzMatrix().

{
static struct axtScoreScheme *ss;

if (ss != NULL)
    return ss;
AllocVar(ss);

/* Set up lower case elements of matrix. */
ss->matrix['a']['a'] = 91;
ss->matrix['a']['c'] = -114;
ss->matrix['a']['g'] = -31;
ss->matrix['a']['t'] = -123;

ss->matrix['c']['a'] = -114;
ss->matrix['c']['c'] = 100;
ss->matrix['c']['g'] = -125;
ss->matrix['c']['t'] = -31;

ss->matrix['g']['a'] = -31;
ss->matrix['g']['c'] = -125;
ss->matrix['g']['g'] = 100;
ss->matrix['g']['t'] = -114;

ss->matrix['t']['a'] = -123;
ss->matrix['t']['c'] = -31;
ss->matrix['t']['g'] = -114;
ss->matrix['t']['t'] = 91;

propagateCase(ss);
ss->gapOpen = 400;
ss->gapExtend = 30;
return ss;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void axtScoreSchemeDnaWrite	(	struct axtScoreScheme *	ss,
		FILE *	f,
		char *	name
	)

Definition at line 727 of file axt.c.

References ss, and stripChar().

{
if (ss == NULL)
    return;
if (f == NULL)
    return;
fprintf(f, "##matrix=%s 16 %d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d\n",
        name,
    ss->matrix['a']['a'],
    ss->matrix['a']['c'],
    ss->matrix['a']['g'],
    ss->matrix['a']['t'],

    ss->matrix['c']['a'],
    ss->matrix['c']['c'],
    ss->matrix['c']['g'],
    ss->matrix['c']['t'],

    ss->matrix['g']['a'],
    ss->matrix['g']['c'],
    ss->matrix['g']['g'],
    ss->matrix['g']['t'],

    ss->matrix['t']['a'],
    ss->matrix['t']['c'],
    ss->matrix['t']['g'],
    ss->matrix['t']['t']);
fprintf(f, "##gapPenalties=%s O=%d E=%d\n", name, ss->gapOpen, ss->gapExtend);
if (ss->extra!=NULL)
    {
    stripChar(ss->extra,' ');
    stripChar(ss->extra,'"');
    fprintf(f, "##blastzParms=%s\n", ss->extra);
    }
}

Here is the call graph for this function:

void axtScoreSchemeFree

(

struct axtScoreScheme **

pObj

)

Definition at line 633 of file axt.c.

References freez().

{
freez(pObj);
}

Here is the call graph for this function:

struct axtScoreScheme* axtScoreSchemeFromBlastzMatrix	(	char *	text,
		int	gapOpen,
		int	gapExtend
	)			[read]

Definition at line 472 of file axt.c.

References axtScoreSchemeDefault(), chopString(), and ss.

{
char *matrixDna[32];
struct axtScoreScheme *ss = axtScoreSchemeDefault();
int matrixSize = chopString(text, ",", matrixDna, 32);
if (matrixSize != 16)
    return ss;
if (ss == NULL)
    return NULL;
ss->gapOpen = gapOpen;
ss->gapExtend = gapExtend;
ss->matrix['a']['a'] = atoi(matrixDna[0]);
ss->matrix['a']['c'] = atoi(matrixDna[1]);
ss->matrix['a']['g'] = atoi(matrixDna[2]);
ss->matrix['a']['t'] = atoi(matrixDna[3]);

ss->matrix['c']['a'] = atoi(matrixDna[4]);
ss->matrix['c']['c'] = atoi(matrixDna[5]);
ss->matrix['c']['g'] = atoi(matrixDna[6]);
ss->matrix['c']['t'] = atoi(matrixDna[7]);

ss->matrix['g']['a'] = atoi(matrixDna[8]);
ss->matrix['g']['c'] = atoi(matrixDna[9]);
ss->matrix['g']['g'] = atoi(matrixDna[10]);
ss->matrix['g']['t'] = atoi(matrixDna[11]);

ss->matrix['t']['a'] = atoi(matrixDna[12]);
ss->matrix['t']['c'] = atoi(matrixDna[13]);
ss->matrix['t']['g'] = atoi(matrixDna[14]);
ss->matrix['t']['t'] = atoi(matrixDna[15]);
return ss;
}

Here is the call graph for this function:

struct axtScoreScheme* axtScoreSchemeProteinDefault

(

)

[read]

Definition at line 616 of file axt.c.

References axtScoreSchemeFromProteinText(), blosumText, and ss.

Referenced by axtScoreProteinDefault(), blastiodAxtOutput(), and countPositives().

{
static struct axtScoreScheme *ss;
int i,j;
if (ss != NULL)
    return ss;
ss = axtScoreSchemeFromProteinText(blosumText, "blosum62");
for (i=0; i<128; ++i)
    for (j=0; j<128; ++j)
        ss->matrix[i][j] *= 19;
ss->gapOpen = 11 * 19;
ss->gapExtend = 1 * 19;
return ss;
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct axtScoreScheme* axtScoreSchemeProteinRead

(

char *

fileName

)

[read]

Definition at line 639 of file axt.c.

References axtScoreSchemeFromProteinText(), freeMem(), readInGulp(), and ss.

{
char *string;
struct axtScoreScheme *ss;

readInGulp(fileName, &string, NULL);
ss = axtScoreSchemeFromProteinText(string, fileName);
freeMem(string);

return ss;
}

Here is the call graph for this function:

struct axtScoreScheme* axtScoreSchemeRead

(

char *

fileName

)

[read]

Definition at line 712 of file axt.c.

References axtScoreSchemeReadLf(), lineFileOpen(), ss, and TRUE.

{
struct lineFile *lf = lineFileOpen(fileName, TRUE);
struct axtScoreScheme *ss = axtScoreSchemeReadLf(lf);
return ss;
}

Here is the call graph for this function:

struct axtScoreScheme* axtScoreSchemeReadLf

(

struct lineFile *

lf

)

[read]

Definition at line 651 of file axt.c.

References AllocVar, ArraySize, chopString(), cloneString(), errAbort(), FALSE, lineFileNeedNum(), lineFileNext(), lineFileRow, propagateCase(), sameString, shortScoreScheme(), ss, and TRUE.

Referenced by axtScoreSchemeRead().

{
char *line, *row[4], *parts[32];
int i,j, partCount;
struct axtScoreScheme *ss;
boolean gotO = FALSE, gotE = FALSE;
static int trans[4] = {'a', 'c', 'g', 't'};

AllocVar(ss);
ss->extra = NULL;
if (!lineFileRow(lf, row))
    shortScoreScheme(lf);
if (row[0][0] != 'A' || row[1][0] != 'C' || row[2][0] != 'G' 
        || row[3][0] != 'T')
    errAbort("%s doesn't seem to be a score matrix file", lf->fileName);
for (i=0; i<4; ++i)
    {
    if (!lineFileRow(lf, row))
        shortScoreScheme(lf);
    for (j=0; j<4; ++j)
        ss->matrix[trans[i]][trans[j]] = lineFileNeedNum(lf, row, j);
    }
if (lineFileNext(lf, &line, NULL))
    {
    ss->extra = cloneString(line);
    partCount = chopString(line, " =,\t", parts, ArraySize(parts));
    for (i=0; i<partCount-1; i += 2)
        {
        if (sameString(parts[i], "O"))
            {
            gotO = TRUE;
            ss->gapOpen = atoi(parts[i+1]);
            }
        if (sameString(parts[i], "E"))
            {
            gotE = TRUE;
            ss->gapExtend = atoi(parts[i+1]);
            }
        }
    if (!gotO || !gotE)
        errAbort("Expecting O = and E = in last line of %s", lf->fileName);
    if (ss->gapOpen <= 0 || ss->gapExtend <= 0)
        errAbort("Must have positive gap scores");
    }
else
    {
    ss->gapOpen = 400;
    ss->gapExtend = 30;
    }
propagateCase(ss);
return ss;
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct axtScoreScheme* axtScoreSchemeRnaDefault

(

)

[read]

Definition at line 452 of file axt.c.

References axtScoreSchemeSimpleDna(), and ss.

Referenced by bandedExtend(), findFromSmallerSeeds(), hardRefineSplice(), and smoothOneGap().

{
static struct axtScoreScheme *ss;
if (ss == NULL)
    ss = axtScoreSchemeSimpleDna(100, 200, 300, 300);
return ss;
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct axtScoreScheme* axtScoreSchemeRnaFill

(

)

[read]

Definition at line 462 of file axt.c.

References axtScoreSchemeSimpleDna(), and ss.

{
static struct axtScoreScheme *ss;
if (ss == NULL)
    ss = axtScoreSchemeSimpleDna(100, 100, 200, 200);
return ss;
}

Here is the call graph for this function:

struct axtScoreScheme* axtScoreSchemeSimpleDna	(	int	match,
		int	misMatch,
		int	gapOpen,
		int	gapExtend
	)			[read]

Definition at line 419 of file axt.c.

References AllocVar, propagateCase(), and ss.

Referenced by axtScoreSchemeRnaDefault(), and axtScoreSchemeRnaFill().

{
static struct axtScoreScheme *ss;
AllocVar(ss);

/* Set up lower case elements of matrix. */
ss->matrix['a']['a'] = match;
ss->matrix['a']['c'] = -misMatch;
ss->matrix['a']['g'] = -misMatch;
ss->matrix['a']['t'] = -misMatch;

ss->matrix['c']['a'] = -misMatch;
ss->matrix['c']['c'] = match;
ss->matrix['c']['g'] = -misMatch;
ss->matrix['c']['t'] = -misMatch;

ss->matrix['g']['a'] = -misMatch;
ss->matrix['g']['c'] = -misMatch;
ss->matrix['g']['g'] = match;
ss->matrix['g']['t'] = -misMatch;

ss->matrix['t']['a'] = -misMatch;
ss->matrix['t']['c'] = -misMatch;
ss->matrix['t']['g'] = -misMatch;
ss->matrix['t']['t'] = match;

propagateCase(ss);
ss->gapOpen = gapOpen;
ss->gapExtend = gapExtend;
return ss;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int axtScoreSym	(	struct axtScoreScheme *	ss,
		int	symCount,
		char *	qSym,
		char *	tSym
	)

Definition at line 197 of file axt.c.

References dnaUtilOpen(), FALSE, ss, and TRUE.

Referenced by axtScore(), hardRefineSplice(), and smoothOneGap().

{
int i;
char q,t;
int score = 0;
boolean lastGap = FALSE;
int gapStart = ss->gapOpen;
int gapExt = ss->gapExtend;

dnaUtilOpen();
for (i=0; i<symCount; ++i)
    {
    q = qSym[i];
    t = tSym[i];
    if (q == '-' || t == '-')
        {
        if (lastGap)
            score -= gapExt;
        else
            {
            /* Use gapStart+gapExt to be consistent with blastz: */
            score -= (gapStart + gapExt);
            lastGap = TRUE;
            }
        }
    else
        {
        score += ss->matrix[(int)q][(int)t];
        lastGap = FALSE;
        }
    }
return score;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int axtScoreUngapped	(	struct axtScoreScheme *	ss,
		char *	q,
		char *	t,
		int	size
	)

Definition at line 187 of file axt.c.

References ss.

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

void axtSubsetOnT	(	struct axt *	axt,
		int	newStart,
		int	newEnd,
		struct axtScoreScheme *	ss,
		FILE *	f
	)

Definition at line 310 of file axt.c.

References axtScore(), axtWrite(), countNonDash(), FALSE, axt::qEnd, axt::qStart, axt::qSym, axt::score, skipIgnoringDash(), ss, axt::symCount, axt::tEnd, TRUE, axt::tStart, and axt::tSym.

{
if (newStart < axt->tStart)
    newStart = axt->tStart;
if (newEnd > axt->tEnd)
    newEnd = axt->tEnd;
if (newEnd <= newStart) 
    return;
if (newStart == axt->tStart && newEnd == axt->tEnd)
    {
    axt->score = axtScore(axt, ss);
    axtWrite(axt, f);
    }
else
    {
    struct axt a = *axt;
    char *tSymStart = skipIgnoringDash(a.tSym, newStart - a.tStart, TRUE);
    char *tSymEnd = skipIgnoringDash(tSymStart, newEnd - newStart, FALSE);
    int symCount = tSymEnd - tSymStart;
    char *qSymStart = a.qSym + (tSymStart - a.tSym);
    a.qStart += countNonDash(a.qSym, qSymStart - a.qSym);
    a.qEnd = a.qStart + countNonDash(qSymStart, symCount);
    a.tStart = newStart;
    a.tEnd = newEnd;
    a.symCount = symCount;
    a.qSym = qSymStart;
    a.tSym = tSymStart;
    a.score = axtScore(&a, ss);
    if (a.qStart < a.qEnd && a.tStart < a.tEnd)
        axtWrite(&a, f);
    }
}

Here is the call graph for this function:

void axtSwap	(	struct axt *	axt,
		int	tSize,
		int	qSize
	)

Definition at line 765 of file axt.c.

References axt::qEnd, axt::qName, axt::qStart, axt::qStrand, axt::qSym, reverseComplement(), reverseIntRange(), axt::symCount, axt::tEnd, axt::tName, axt::tStart, axt::tStrand, and axt::tSym.

{
struct axt old = *axt;

/* Copy non-strand dependent stuff */
axt->qName = old.tName;
axt->tName = old.qName;
axt->qSym = old.tSym;
axt->tSym = old.qSym;
axt->qStart = old.tStart;
axt->qEnd = old.tEnd;
axt->tStart = old.qStart;
axt->tEnd = old.qEnd;

/* Copy strand dependent stuff. */
assert(axt->tStrand != '-');

if (axt->qStrand == '-')
    {
    /* axt'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. */
    reverseIntRange(&axt->tStart, &axt->tEnd, qSize);
    reverseIntRange(&axt->qStart, &axt->qEnd, tSize);
    reverseComplement(axt->qSym, axt->symCount);
    reverseComplement(axt->tSym, axt->symCount);
    }
}

Here is the call graph for this function:

int axtTransPosToQ	(	struct axt *	axt,
		int	tPos
	)

Definition at line 346 of file axt.c.

References countNonDash(), axt::qStart, axt::qSym, skipIgnoringDash(), TRUE, axt::tStart, and axt::tSym.

{
char *tSym = skipIgnoringDash(axt->tSym, tPos - axt->tStart, TRUE);
int symIx = tSym - axt->tSym;
int qPos = countNonDash(axt->qSym, symIx);
return qPos + axt->qStart;
}

Here is the call graph for this function:

void axtWrite	(	struct axt *	axt,
		FILE *	f
	)

Definition at line 102 of file axt.c.

References mustWrite(), axt::qEnd, axt::qName, axt::qStart, axt::qStrand, axt::qSym, axt::score, axt::symCount, axt::tEnd, axt::tName, axt::tStart, and axt::tSym.

Referenced by axtQueryOut(), and axtSubsetOnT().

{
static int ix = 0;
fprintf(f, "%d %s %d %d %s %d %d %c",
        ix++, axt->tName, axt->tStart+1, axt->tEnd, 
        axt->qName, axt->qStart+1, axt->qEnd, axt->qStrand);
fprintf(f, " %d", axt->score);
fputc('\n', f);
mustWrite(f, axt->tSym, axt->symCount);
fputc('\n', f);
mustWrite(f, axt->qSym, axt->symCount);
fputc('\n', f);
fputc('\n', f);
if ((strlen(axt->tSym) != strlen(axt->qSym)) || (axt->symCount > strlen(axt->tSym)))
    fprintf(stderr,"Symbol count %d != %d || %d > %d inconsistent in %s in "
            "record %d.\n",
            (int)strlen(axt->qSym), (int)strlen(axt->tSym), axt->symCount,
            (int)strlen(axt->tSym), axt->qName, ix);
}

Here is the call graph for this function:

Here is the caller graph for this function:

---