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; }