boolean fastFind(DNA *needle, int needleSize,
struct patSpace *ps, struct ffAli **retAli, boolean *retRc, int *retScore)
/* Do fast alignment. */
{
struct patClump *clumpList, *clump;
boolean isRc;
struct aliList *aliList = NULL, *ali;
for (isRc = 0; isRc <= 1; ++isRc)
{
if (isRc)
reverseComplement(needle, needleSize);
if ((clumpList = patSpaceFindOne(ps, needle, needleSize)) != NULL)
{
for (clump = clumpList; clump != NULL; clump = clump->next)
{
struct dnaSeq *haySeq = clump->seq;
DNA *haystack = haySeq->dna;
int start = clump->start;
struct ffAli *ffAli = ffFind(needle, needle+needleSize,
haystack+start, haystack+start+clump->size, ffCdna);
if (ffAli != NULL)
{
AllocVar(ali);
ali->ali = ffAli;
ali->score = ffScoreCdna(ffAli);
ali->isRc = isRc;
slAddHead(&aliList, ali);
}
}
slFreeList(&clumpList);
}
if (isRc)
reverseComplement(needle, needleSize);
}
if (aliList != NULL)
{
slSort(&aliList, cmpAliList);
*retAli = aliList->ali;
aliList->ali = NULL;
*retRc = aliList->isRc;
*retScore = aliList->score;
for (ali = aliList->next; ali != NULL; ali = ali->next)
ffFreeAli(&ali->ali);
slFreeList(&aliList);
return TRUE;
}
else
return FALSE;
}
int main(int argc, char *argv[])
{
char *genoListName;
char *cdnaListName;
char *oocFileName;
char *pairFileName;
struct patSpace *patSpace;
long startTime, endTime;
char **genoList;
int genoListSize;
char *genoListBuf;
char **cdnaList;
int cdnaListSize;
char *cdnaListBuf;
char *genoName;
int i;
int estIx = 0;
struct dnaSeq **seqListList = NULL, *seq;
static char hitFileName[512], mergerFileName[512], okFileName[512];
char *outRoot;
struct hash *pairHash;
if (dumpMe)
{
bigHtmlFile = mustOpen("C:\\inetpub\\wwwroot\\test\\patAli.html", "w");
littleHtmlFile = mustOpen("C:\\inetpub\\wwwroot\\test\\patSpace.html", "w");
htmStart(bigHtmlFile, "PatSpace Alignments");
htmStart(littleHtmlFile, "PatSpace Index");
}
if ((hostName = getenv("HOST")) == NULL)
hostName = "";
if (argc != 6)
usage();
pushWarnHandler(patSpaceWarnHandler);
startTime = clock1000();
dnaUtilOpen();
makePolys();
genoListName = argv[1];
cdnaListName = argv[2];
oocFileName = argv[3];
pairFileName = argv[4];
outRoot = argv[5];
sprintf(hitFileName, "%s.hit", outRoot);
sprintf(mergerFileName, "%s.glu", outRoot);
sprintf(okFileName, "%s.ok", outRoot);
readAllWords(genoListName, &genoList, &genoListSize, &genoListBuf);
readAllWords(cdnaListName, &cdnaList, &cdnaListSize, &cdnaListBuf);
pairHash = makePairHash(pairFileName);
hitOut = mustOpen(hitFileName, "w");
mergerOut = mustOpen(mergerFileName, "w");
dumpOut = mustOpen("dump.out", "w");
seqListList = needMem(genoListSize*sizeof(seqListList[0]) );
fprintf(hitOut, "Pattern space 0.2 cDNA matcher\n");
fprintf(hitOut, "cDNA files: ", cdnaListSize);
for (i=0; i<cdnaListSize; ++i)
fprintf(hitOut, " %s", cdnaList[i]);
fprintf(hitOut, "\n");
fprintf(hitOut, "%d genomic files\n", genoListSize);
for (i=0; i<genoListSize; ++i)
{
genoName = genoList[i];
if (!startsWith("//", genoName) )
{
seqListList[i] = seq = faReadAllDna(genoName);
fprintf(hitOut, "%d els in %s ", slCount(seq), genoList[i]);
for (; seq != NULL; seq = seq->next)
fprintf(hitOut, "%d ", seq->size);
fprintf(hitOut, "\n");
}
}
patSpace = makePatSpace(seqListList, genoListSize, oocFileName);
for (i=0; i<cdnaListSize; ++i)
{
FILE *f;
char *estFileName;
DNA *dna;
char *estName;
int size;
int c;
int maxSizeForFuzzyFind = 20000;
int dotCount = 0;
estFileName = cdnaList[i];
if (startsWith("//", estFileName) )
continue;
f = mustOpen(estFileName, "rb");
while ((c = fgetc(f)) != EOF)
if (c == '>')
break;
printf("%s", cdnaList[i]);
fflush(stdout);
while (fastFaReadNext(f, &dna, &size, &estName))
{
aliSeqName = estName;
if (size < maxSizeForFuzzyFind) /* Some day need to fix this somehow... */
{
struct hashEl *hel;
struct cdnaAliList *calList = NULL;
hel = hashLookup(pairHash, estName);
if (hel != NULL) /* Do pair processing. */
{
struct estPair *ep;
struct seq *thisSeq, *otherSeq;
ep = hel->val;
if (hel->name == ep->name3)
{
thisSeq = &ep->seq3;
otherSeq = &ep->seq5;
}
else
{
thisSeq = &ep->seq5;
otherSeq = &ep->seq3;
}
if (otherSeq->dna == NULL) /* First in pair - need to save sequence. */
{
thisSeq->size = size;
thisSeq->dna = needMem(size);
memcpy(thisSeq->dna, dna, size);
}
else /* Second in pair - do gluing and free partner. */
{
char mergedName[64];
thisSeq->dna = dna;
thisSeq->size = size;
sprintf(mergedName, "%s_AND_%s", ep->name5, ep->name3);
patSpaceFindOne(patSpace, ep->seq5.dna, ep->seq5.size,
'+', '5', ep->name5, &calList);
reverseComplement(ep->seq5.dna, ep->seq5.size);
patSpaceFindOne(patSpace, ep->seq5.dna, ep->seq5.size,
'-', '5', ep->name5, &calList);
patSpaceFindOne(patSpace, ep->seq3.dna, ep->seq3.size,
'+', '3', ep->name3, &calList);
reverseComplement(ep->seq3.dna, ep->seq3.size);
patSpaceFindOne(patSpace, ep->seq3.dna, ep->seq3.size,
'-', '3', ep->name3, &calList);
slReverse(&calList);
writeMergers(calList, mergedName, genoList);
freez(&otherSeq->dna);
thisSeq->dna = NULL;
thisSeq->size =otherSeq->size = 0;
}
}
else
{
patSpaceFindOne(patSpace, dna, size, '+', '5', estName, &calList);
reverseComplement(dna, size);
patSpaceFindOne(patSpace, dna, size, '-', '5', estName, &calList);
slReverse(&calList);
writeMergers(calList, estName, genoList);
}
++estIx;
if ((estIx & 0xfff) == 0)
{
printf(".");
++dotCount;
fflush(stdout);
}
}
}
printf("\n");
}
aliSeqName = "";
printf("ffSubmitted %3d ffAccepted %3d ffOkScore %3d ffSolidMatch %2d\n",
ffSubmitted, ffAccepted, ffOkScore, ffSolidMatch);
endTime = clock1000();
printf("Total time is %4.2f\n", 0.001*(endTime-startTime));
/* Write out file who's presense say's we succeeded */
{
FILE *f = mustOpen(okFileName, "w");
fputs("ok", f);
fclose(f);
}
if (dumpMe)
{
htmEnd(bigHtmlFile);
htmEnd(littleHtmlFile);
}
return 0;
}
void glueFindOne(struct patSpace *ps, DNA *cdna, int cdnaSize,
char strand, char dir, char *cdnaName, struct cdnaAliList **pList)
/* Find occurrences of DNA in patSpace and print to hitOut. */
{
struct patClump *clumpList, *clump;
clumpList = patSpaceFindOne(ps, cdna, cdnaSize);
for (clump = clumpList; clump != NULL; clump = clump->next)
{
struct ffAli *ff;
struct dnaSeq *seq = clump->seq;
DNA *tStart = seq->dna + clump->start;
char *contigName = seq->name;
int seqIx = clump->seqIx;
int bacIx = clump->bacIx;
++ffSubmitted;
ff = ffFind(cdna, cdna+cdnaSize, tStart, tStart + clump->size, ffCdna);
if (ff != NULL)
{
int ffScore = ffScoreCdna(ff);
++ffAccepted;
if (ffScore >= 22)
{
int hiStart, hiEnd;
int oldStart, oldEnd;
struct ffAli *left, *right;
ffFindEnds(ff, &left, &right);
hiStart = oldStart = left->nStart - cdna;
hiEnd = oldEnd = right->nEnd - cdna;
++ffOkScore;
if (solidMatch(&left, &right, cdna, &hiStart, &hiEnd))
{
int solidSize = hiEnd - hiStart;
int solidScore;
int seqStart, seqEnd;
double cookedScore;
solidScore = scoreCdna(left, right);
cookedScore = (double)solidScore/solidSize;
if (cookedScore > 0.25)
{
struct cdnaAliList *cal;
++ffSolidMatch;
seqStart = left->hStart - seq->dna;
seqEnd = right->hEnd - seq->dna;
fprintf(hitOut, "%3.1f%% %c %s:%d-%d (old %d-%d) of %d at %s.%d:%d-%d\n",
100.0 * cookedScore, strand, cdnaName,
hiStart, hiEnd, oldStart, oldEnd, cdnaSize,
contigName, seqIx, seqStart, seqEnd);
cal = newCal(bacIx, seqIx, hiStart, hiEnd, cdnaSize, strand, dir, cookedScore);
slAddHead(pList, cal);
}
}
}
ffFreeAli(&ff);
}
}
slFreeList(&clumpList);
}
int main(int argc, char *argv[])
{
char *genoListName;
char *cdnaListName;
char *oocFileName;
char *hitFileName;
char *mergerFileName;
struct patSpace *patSpace;
long startTime, endTime;
char **genoList;
int genoListSize;
char *genoListBuf;
char **cdnaList;
int cdnaListSize;
char *cdnaListBuf;
char *genoName;
int i;
int estIx = 0;
struct dnaSeq **seqListList = NULL, *seq;
if (dumpMe)
{
bigHtmlFile = mustOpen("C:\\inetpub\\wwwroot\\test\\patAli.html", "w");
littleHtmlFile = mustOpen("C:\\inetpub\\wwwroot\\test\\patSpace.html", "w");
htmStart(bigHtmlFile, "PatSpace Alignments");
htmStart(littleHtmlFile, "PatSpace Index");
}
if (argc != 6)
usage();
startTime = clock1000();
dnaUtilOpen();
makePolys();
genoListName = argv[1];
cdnaListName = argv[2];
oocFileName = argv[3];
hitFileName = argv[4];
mergerFileName = argv[5];
readAllWords(genoListName, &genoList, &genoListSize, &genoListBuf);
readAllWords(cdnaListName, &cdnaList, &cdnaListSize, &cdnaListBuf);
hitOut = mustOpen(hitFileName, "w");
mergerOut = mustOpen(mergerFileName, "w");
dumpOut = mustOpen("dump.out", "w");
seqListList = needMem(genoListSize*sizeof(seqListList[0]) );
fprintf(hitOut, "Pattern space 0.2 cDNA matcher\n");
fprintf(hitOut, "cDNA files: ", cdnaListSize);
for (i=0; i<cdnaListSize; ++i)
fprintf(hitOut, " %s", cdnaList[i]);
fprintf(hitOut, "\n");
fprintf(hitOut, "%d genomic files\n", genoListSize);
for (i=0; i<genoListSize; ++i)
{
genoName = genoList[i];
if (!startsWith("//", genoName) )
{
seqListList[i] = seq = faReadAllDna(genoName);
fprintf(hitOut, "%d els in %s ", slCount(seq), genoList[i]);
for (; seq != NULL; seq = seq->next)
fprintf(hitOut, "%d ", seq->size);
fprintf(hitOut, "\n");
}
}
patSpace = makePatSpace(seqListList, genoListSize, oocFileName);
for (i=0; i<cdnaListSize; ++i)
{
FILE *f;
char *estFileName;
DNA *dna;
char *estName;
int size;
int c;
int maxSizeForFuzzyFind = 20000;
int dotCount = 0;
estFileName = cdnaList[i];
if (startsWith("//", estFileName) )
continue;
f = mustOpen(estFileName, "rb");
while ((c = fgetc(f)) != EOF)
if (c == '>')
break;
printf("%s", cdnaList[i]);
fflush(stdout);
while (fastFaReadNext(f, &dna, &size, &estName))
{
if (size < maxSizeForFuzzyFind) /* Some day need to fix this somehow... */
{
struct cdnaAliList *calList = NULL;
patSpaceFindOne(patSpace, dna, size, '+', estName, estIx, &calList);
reverseComplement(dna, size);
patSpaceFindOne(patSpace, dna, size, '-', estName, estIx, &calList);
slReverse(&calList);
writeMergers(calList, estName, size, genoList);
++estIx;
if ((estIx & 0xfff) == 0)
{
printf(".");
++dotCount;
fflush(stdout);
}
}
}
printf("\n");
}
printf("raw %4d ffSubmitted %3d ffAccepted %3d ffOkScore %3d ffSolidMatch %2d\n",
grandTotalHits, ffSubmitted, ffAccepted, ffOkScore, ffSolidMatch);
endTime = clock1000();
printf("Total time is %4.2f\n", 0.001*(endTime-startTime));
if (dumpMe)
{
htmEnd(bigHtmlFile);
htmEnd(littleHtmlFile);
}
return 0;
}
struct ssBundle *ssFindBundles(struct patSpace *ps, struct dnaSeq *cSeq,
char *cName, enum ffStringency stringency, boolean avoidSelfSelf)
/* Find patSpace alignments. This routine is used by psLayout but not blat. */
{
struct patClump *clumpList, *clump;
struct ssBundle *bundleList = NULL, *bun = NULL;
DNA *cdna = cSeq->dna;
int totalCdnaSize = cSeq->size;
DNA *endCdna = cdna+totalCdnaSize;
struct ssFfItem *ffl;
struct dnaSeq *lastSeq = NULL;
int maxSize = 700;
int preferredSize = 500;
int overlapSize = 250;
for (;;)
{
int cSize = endCdna - cdna;
if (cSize > maxSize)
cSize = preferredSize;
clumpList = patSpaceFindOne(ps, cdna, cSize);
for (clump = clumpList; clump != NULL; clump = clump->next)
{
struct ffAli *ff;
struct dnaSeq *seq = clump->seq;
DNA *tStart = seq->dna + clump->start;
if (!avoidSelfSelf || !sameString(seq->name, cSeq->name))
{
ff = ffFind(cdna, cdna+cSize, tStart, tStart + clump->size, stringency);
if (ff != NULL)
{
if (lastSeq != seq)
{
lastSeq = seq;
if ((bun = findBundle(bundleList, seq)) == NULL)
{
AllocVar(bun);
bun->qSeq = cSeq;
bun->genoSeq = seq;
bun->genoIx = clump->bacIx;
bun->genoContigIx = clump->seqIx;
slAddHead(&bundleList, bun);
}
}
AllocVar(ffl);
ffl->ff = ff;
slAddHead(&bun->ffList, ffl);
}
}
}
cdna += cSize;
if (cdna >= endCdna)
break;
cdna -= overlapSize;
slFreeList(&clumpList);
}
slReverse(&bundleList);
cdna = cSeq->dna;
for (bun = bundleList; bun != NULL; bun = bun->next)
{
ssStitch(bun, stringency, 20, 16);
}
return bundleList;
}
int main(int argc, char *argv[])
{
char *estName, *targetName, *oocName;
FILE *estFile;
struct dnaSeq *target;
struct dnaSeq *est;
struct patSpace *ps;
struct patClump *clumpList, *clump;
int estIx = 0;
/* Check command line arguments and assign to local variables. */
if (argc != 4)
usage();
estName = argv[1];
estFile = mustOpen(estName, "rb");
targetName = argv[2];
oocName = argv[3];
/* Read in target DNA from fasta files and check not too big. */
fprintf(stderr, "Reading %s\n", targetName);
target = faReadAllDna(targetName);
if (totalSequenceSize(target) > 8000000)
{
errAbort("Can only handle 8000000 bases of genomic sequence at once, %s has %d.",
targetName, totalSequenceSize(target));
}
/* Make a pattern space index structure. */
fprintf(stderr, "Making Pattern Space index\n");
ps = makePatSpace(&target, 1, oocName, 4, 32000);
/* Loop through each EST in query list. */
printf("Searching for hits\n\n");
while (faReadNext(estFile, NULL, TRUE, NULL, &est))
{
boolean isRc; /* Reverse complemented? */
if (++estIx % 5000 == 0)
fprintf(stderr, "Processing EST %d\n", estIx);
if (est->size > 20000)
{
warn("Very large EST sequence %s.\n"
"Maybe you mixed up the EST and genomic parameters?", est->name);
usage();
}
for (isRc = 0; isRc <= 1; ++isRc) /* Search both strands. */
{
if (isRc)
reverseComplement(est->dna, est->size);
clumpList = patSpaceFindOne(ps, est->dna, est->size);
/* For each homology clump patSpace finds, do a fuzzyFinder
* alignment of it and print the results. */
for (clump = clumpList; clump != NULL; clump = clump->next)
{
struct ffAli *ali, *a;
boolean isRc;
int score;
struct dnaSeq *t = clump->seq;
DNA *tStart = t->dna + clump->start;
ali = ffFind(est->dna, est->dna+est->size, tStart, tStart + clump->size, ffCdna);
if (ali != NULL)
{
score = ffScoreCdna(ali);
printf("%s hits %s strand %c score %d\n",
est->name, t->name, (isRc ? '+' : '-'), score);
for (a = ali; a != NULL; a = a->right)
{
printf(" Q %4d - %4d\t T %4d -%4d\n",
a->nStart - est->dna, a->nEnd - est->dna,
a->hStart - t->dna, a->hEnd - t->dna);
}
printf("\n");
ffFreeAli(&ali);
}
else
{
printf("Couldn't align clump at %s %d-%d\n",
t->name, clump->start, clump->start + clump->size);
}
}
slFreeList(&clumpList);
}
freeDnaSeq(&est);
}
/* Clean up time. */
freePatSpace(&ps);
freeSeqList(&target);
return 0;
}
