int scoreCdna(struct ffAli *left, struct ffAli *right)
/* Score ali using cDNA scoring. */
{
int size, nGap, hGap;
struct ffAli *ff, *next;
int score = 0, oneScore;
for (ff=left; ;)
{
next = ff->right;
size = ff->nEnd - ff->nStart;
oneScore = ffScoreMatch(ff->nStart, ff->hStart, size);
if (next != NULL && ff != right)
{
/* Penalize all gaps except for intron-looking ones. */
nGap = next->nStart - ff->nEnd;
hGap = next->hStart - ff->hEnd;
/* Process what are stretches of mismatches rather than gaps. */
if (nGap > 0 && hGap > 0)
{
if (nGap > hGap)
{
nGap -= hGap;
oneScore -= hGap;
hGap = 0;
}
else
{
hGap -= nGap;
oneScore -= nGap;
nGap = 0;
}
}
if (nGap < 0)
nGap = -nGap-nGap;
if (hGap < 0)
hGap = -hGap-hGap;
if (nGap > 0)
oneScore -= 8*nGap;
if (hGap > 30)
oneScore -= 1;
else if (hGap > 0)
oneScore -= 8*hGap;
}
score += oneScore;
if (ff == right)
break;
ff = next;
}
return score;
}
int scoreExonAli(struct ffAli *ali)
/* Score alignment using assumptions that it may have introns. */
{
struct ffAli *left;
int oneScore;
int onePenalty;
int score;
score = ffScoreMatch(ali->nStart, ali->hStart, ali->nEnd - ali->nStart);
for (;;)
{
left = ali;
if ((ali = ali->right) == NULL)
break;
onePenalty = gapPenalty(left, ali);
score -= onePenalty;
oneScore = ffScoreMatch(ali->nStart, ali->hStart, ali->nEnd - ali->nStart);
score += oneScore;
}
return score;
}
int rightFlakySize(struct ffAli *ali, DNA *needle, int needleSize)
/* Returns # of unalligned or flakily aligned bases on right side
* of needle. */
{
int aliSize;
DNA *firstGood = NULL;
while (ali->right) ali = ali->right;
while (ali != NULL)
{
aliSize = ali->nEnd - ali->nStart;
if (ffScoreMatch(ali->nStart, ali->hStart, aliSize) >= minGoodSize)
{
firstGood = ali->nEnd;
break;
}
ali = ali->left;
}
if (firstGood == NULL)
return needleSize;
else
return (needle + needleSize) - firstGood;
}
static struct ffAli *trimFlakyEnds(struct dnaSeq *qSeq, struct dnaSeq *tSeq,
struct ffAli *ffList)
/* Get rid of small initial and terminal exons that seem to just
* be chance alignments. Looks for splice sites and non-degenerate
* sequence to keep things. */
{
int orientation = ffIntronOrientation(ffList);
struct ffAli *left, *right;
char *iStart, *iEnd;
int blockScore, gapPenalty;
/* If one or less block then don't bother. */
if (ffAliCount(ffList) < 2)
return ffList;
/* Trim beginnings. */
left = ffList;
right = ffList->right;
while (right != NULL)
{
blockScore = ffScoreMatch(left->nStart, left->hStart,
left->nEnd-left->nStart);
blockScore -= aPenalty(left->nStart, left->nEnd - left->nStart);
iStart = left->hEnd;
iEnd = right->hStart;
gapPenalty = trimGapPenalty(iEnd-iStart,
right->nStart - left->nEnd, iStart, iEnd, orientation);
if (gapPenalty >= blockScore)
{
freeMem(left);
ffList = right;
right->left = NULL;
}
else
break;
left = right;
right = right->right;
}
right = ffRightmost(ffList);
if (right == ffList)
return ffList;
left = right->left;
while (left != NULL)
{
blockScore = ffScoreMatch(right->nStart, right->hStart,
right->nEnd-right->nStart);
blockScore -= aPenalty(right->nStart, right->nEnd - right->nStart);
iStart = left->hEnd;
iEnd = right->hStart;
gapPenalty = trimGapPenalty(iEnd-iStart,
right->nStart - left->nEnd, iStart, iEnd, orientation);
if (gapPenalty >= blockScore)
{
freeMem(right);
left->right = NULL;
}
else
break;
right = left;
left = left->left;
}
return ffList;
}
