void writeAxtFromChain(struct chain *chain, struct dnaSeq *qSeq, int qOffset,
struct dnaSeq *tSeq, int tOffset, FILE *f, FILE *gapFile)
/* Write out axt's that correspond to chain. */
{
struct axt *axt, *axtList;
if (gapFile != NULL)
writeGaps(chain, gapFile);
axtList = chainToAxt(chain, qSeq, qOffset, tSeq, tOffset, maxGap, BIGNUM);
verbose(9, "%d axts\n", slCount(axtList));
for (axt = axtList; axt != NULL; axt = axt->next)
axtWrite(axt, f);
axtFreeList(&axtList);
}
struct axt *netFillToAxt(struct cnFill *fill, struct dnaSeq *tChrom , int tSize,
struct hash *qChromHash, char *nibDir,
struct chain *chain, boolean swap)
/* Convert subset of chain as defined by fill to axt. swap query and target if swap is true*/
{
struct dnaSeq *qSeq;
boolean isRev = (chain->qStrand == '-');
struct chain *subChain, *chainToFree;
int qOffset;
struct axt *axtList = NULL , *axt;
struct nibInfo *nib = hashFindVal(qChromHash, fill->qName);
/* Get query sequence fragment. */
{
if (nib == NULL)
{
char path[512];
AllocVar(nib);
safef(path, sizeof(path), "%s/%s.nib", nibDir, fill->qName);
nib->fileName = cloneString(path);
nibOpenVerify(path, &nib->f, &nib->size);
hashAdd(qChromHash, fill->qName, nib);
}
qSeq = nibLoadPartMasked(NIB_MASK_MIXED, nib->fileName,
fill->qStart, fill->qSize);
if (isRev)
{
reverseComplement(qSeq->dna, qSeq->size);
qOffset = nib->size - (fill->qStart + fill->qSize);
}
else
qOffset = fill->qStart;
}
chainSubsetOnT(chain, fill->tStart, fill->tStart + fill->tSize,
&subChain, &chainToFree);
if (subChain != NULL)
{
axtList = chainToAxt(subChain, qSeq, qOffset, tChrom, fill->tStart, 100, BIGNUM);
if (swap)
{
for (axt = axtList ; axt != NULL ; axt = axt->next)
axtSwap(axt, tSize, nib->size);
}
}
chainFree(&chainToFree);
freeDnaSeq(&qSeq);
return axtList;
}
static void doAChain(struct chain *chain, struct nibTwoCache *tSeqCache, struct nibTwoCache *qSeqCache,
FILE *f)
/* Convert one chain to an axt. */
{
struct dnaSeq *qSeq = loadSeqStrand(qSeqCache, chain->qName, chain->qStart, chain->qEnd, chain->qStrand);
struct dnaSeq *tSeq = loadSeqStrand(tSeqCache, chain->tName, chain->tStart, chain->tEnd, '+');
struct axt *axtList= chainToAxt(chain, qSeq, chain->qStart, tSeq, chain->tStart, maxGap, BIGNUM);
struct axt *axt = NULL;
for (axt = axtList; axt != NULL; axt = axt->next)
{
double idRatio = axtIdRatio(axt);
if (minIdRatio <= idRatio)
{
if (bedOut)
bedWriteAxt(axt, chain->qSize, chain->tSize, idRatio, f);
else
axtWrite(axt, f);
}
}
axtFreeList(&axtList);
freeDnaSeq(&qSeq);
freeDnaSeq(&tSeq);
}
void checkExp(char *bedFileName, char *tNibDir, char *nibList)
{
struct lineFile *bf = lineFileOpen(bedFileName , TRUE), *af = NULL;
char *row[PSEUDOGENELINK_NUM_COLS] ;
struct pseudoGeneLink *ps;
char *tmpName[512], cmd[512];
struct axt *axtList = NULL, *axt, *mAxt = NULL;
struct dnaSeq *qSeq = NULL, *tSeq = NULL, *seqList = NULL;
struct nibInfo *qNib = NULL, *tNib = NULL;
FILE *op;
int ret;
if (nibHash == NULL)
nibHash = hashNew(0);
while (lineFileNextRow(bf, row, ArraySize(row)))
{
struct misMatch *misMatchList = NULL;
struct binKeeper *bk = NULL;
struct binElement *el, *elist = NULL;
struct psl *mPsl = NULL, *rPsl = NULL, *pPsl = NULL, *psl ;
struct misMatch *mf = NULL;
ps = pseudoGeneLinkLoad(row);
tmpName[0] = cloneString(ps->name);
chopByChar(tmpName[0], '.', tmpName, sizeof(tmpName));
verbose(2,"name %s %s:%d-%d\n",
ps->name, ps->chrom, ps->chromStart,ps->chromEnd);
/* get expressed retro from hash */
bk = hashFindVal(mrnaHash, ps->chrom);
elist = binKeeperFindSorted(bk, ps->chromStart, ps->chromEnd ) ;
for (el = elist; el != NULL ; el = el->next)
{
rPsl = el->val;
verbose(2,"retroGene %s %s:%d-%d\n",rPsl->qName, ps->chrom, ps->chromStart,ps->chromEnd);
}
/* find mrnas that overlap parent gene */
bk = hashFindVal(mrnaHash, ps->gChrom);
elist = binKeeperFindSorted(bk, ps->gStart , ps->gEnd ) ;
for (el = elist; el != NULL ; el = el->next)
{
pPsl = el->val;
verbose(2,"parent %s %s:%d %d,%d\n",
pPsl->qName, pPsl->tName,pPsl->tStart,
pPsl->match, pPsl->misMatch);
}
/* find self chain */
bk = hashFindVal(chainHash, ps->chrom);
elist = binKeeperFind(bk, ps->chromStart , ps->chromEnd ) ;
slSort(&elist, chainCmpScoreDesc);
for (el = elist; el != NULL ; el = el->next)
{
struct chain *chain = el->val, *subChain, *retChainToFree, *retChainToFree2;
int qs = chain->qStart;
int qe = chain->qEnd;
int id = chain->id;
if (chain->qStrand == '-')
{
qs = chain->qSize - chain->qEnd;
qe = chain->qSize - chain->qStart;
}
if (!sameString(chain->qName , ps->gChrom) ||
!positiveRangeIntersection(qs, qe, ps->gStart, ps->gEnd))
{
verbose(2," wrong chain %s:%d-%d %s:%d-%d parent %s:%d-%d\n",
chain->qName, qs, qe,
chain->tName,chain->tStart,chain->tEnd,
ps->gChrom,ps->gStart,ps->gEnd);
continue;
}
verbose(2,"chain id %d %4.0f",chain->id, chain->score);
chainSubsetOnT(chain, ps->chromStart+7, ps->chromEnd-7,
&subChain, &retChainToFree);
if (subChain != NULL)
chain = subChain;
chainSubsetOnQ(chain, ps->gStart, ps->gEnd,
&subChain, &retChainToFree2);
if (subChain != NULL)
chain = subChain;
if (chain->qStrand == '-')
{
qs = chain->qSize - chain->qEnd;
qe = chain->qSize - chain->qStart;
}
verbose(2," %s:%d-%d %s:%d-%d ",
chain->qName, qs, qe,
chain->tName,chain->tStart,chain->tEnd);
if (subChain != NULL)
verbose(2,"subChain %s:%d-%d %s:%d-%d\n",
subChain->qName, subChain->qStart, subChain->qEnd,
subChain->tName,subChain->tStart,subChain->tEnd);
qNib = nibInfoFromCache(nibHash, tNibDir, chain->qName);
tNib = nibInfoFromCache(nibHash, tNibDir, chain->tName);
tSeq = nibInfoLoadStrand(tNib, chain->tStart, chain->tEnd, '+');
qSeq = nibInfoLoadStrand(qNib, chain->qStart, chain->qEnd, chain->qStrand);
axtList = chainToAxt(chain, qSeq, chain->qStart, tSeq, chain->tStart,
maxGap, BIGNUM);
verbose(2,"axt count %d misMatch cnt %d\n",slCount(axtList), slCount(misMatchList));
for (axt = axtList; axt != NULL ; axt = axt->next)
{
addMisMatch(&misMatchList, axt, chain->qSize);
}
verbose(2,"%d in mismatch list %s id %d \n",slCount(misMatchList), chain->qName, id);
chainFree(&retChainToFree);
chainFree(&retChainToFree2);
break;
}
/* create axt of each expressed retroGene to parent gene */
/* get alignment for each mrna overlapping retroGene */
bk = hashFindVal(mrnaHash, ps->chrom);
elist = binKeeperFindSorted(bk, ps->chromStart , ps->chromEnd ) ;
{
char queryName[512];
char axtName[512];
char pslName[512];
safef(queryName, sizeof(queryName), "/tmp/query.%s.fa", ps->chrom);
safef(axtName, sizeof(axtName), "/tmp/tmp.%s.axt", ps->chrom);
safef(pslName, sizeof(pslName), "/tmp/tmp.%s.psl", ps->chrom);
op = fopen(pslName,"w");
for (el = elist ; el != NULL ; el = el->next)
{
psl = el->val;
pslOutput(psl, op, '\t','\n');
qSeq = twoBitReadSeqFrag(twoBitFile, psl->qName, 0, 0);
if (qSeq != NULL)
slAddHead(&seqList, qSeq);
else
errAbort("seq %s not found \n", psl->qName);
}
fclose(op);
faWriteAll(queryName, seqList);
safef(cmd,sizeof(cmd),"pslPretty -long -axt %s %s %s %s",pslName , nibList, queryName, axtName);
ret = system(cmd);
if (ret != 0)
errAbort("ret is %d %s\n",ret,cmd);
verbose(2, "ret is %d %s\n",ret,cmd);
af = lineFileOpen(axtName, TRUE);
while ((axt = axtRead(af)) != NULL)
slAddHead(&mAxt, axt);
lineFileClose(&af);
}
slReverse(&mAxt);
/* for each parent/retro pair, count bases matching retro and parent better */
for (el = elist; el != NULL ; el = el->next)
{
int i, scoreRetro=0, scoreParent=0, scoreNeither=0;
struct dyString *parentMatch = newDyString(16*1024);
struct dyString *retroMatch = newDyString(16*1024);
mPsl = el->val;
if (mAxt != NULL)
{
verbose(2,"mrna %s %s:%d %d,%d axt %s\n",
mPsl->qName, mPsl->tName,mPsl->tStart,
mPsl->match, mPsl->misMatch,
mAxt->qName);
assert(sameString(mPsl->qName, mAxt->qName));
for (i = 0 ; i< (mPsl->tEnd-mPsl->tStart) ; i++)
{
int j = mAxt->tStart - mPsl->tStart;
verbose(5, "listLen = %d\n",slCount(&misMatchList));
if ((mf = matchFound(&misMatchList, (mPsl->tStart)+i)) != NULL)
{
if (toupper(mf->retroBase) == toupper(mAxt->qSym[j+i]))
{
verbose (3,"match retro[%d] %d %c == %c parent %c %d\n",
i,mf->retroLoc, mf->retroBase, mAxt->qSym[j+i],
mf->parentBase, mf->parentLoc);
dyStringPrintf(retroMatch, "%d,", mf->retroLoc);
scoreRetro++;
}
else if (toupper(mf->parentBase) == toupper(mAxt->qSym[j+i]))
{
verbose (3,"match parent[%d] %d %c == %c retro %c %d\n",
i,mf->parentLoc, mf->parentBase, mAxt->qSym[j+i],
mf->retroBase, mf->retroLoc);
dyStringPrintf(parentMatch, "%d,", mf->parentLoc);
scoreParent++;
}
else
{
verbose (3,"match neither[%d] %d %c != %c retro %c %d\n",
i,mf->parentLoc, mf->parentBase, mAxt->tSym[j+i],
mf->retroBase, mf->retroLoc);
scoreNeither++;
}
}
}
verbose(2,"final score %s parent %d retro %d neither %d\n",
mPsl->qName, scoreParent, scoreRetro, scoreNeither);
fprintf(outFile,"%s\t%d\t%d\t%s\t%d\t%s\t%d\t%d\t%s\t%d\t%d\t%d\t%s\t%s\n",
ps->chrom, ps->chromStart, ps->chromEnd, ps->name, ps->score,
mPsl->tName, mPsl->tStart, mPsl->tEnd, mPsl->qName,
scoreParent, scoreRetro, scoreNeither, parentMatch->string, retroMatch->string);
mAxt = mAxt->next;
}
dyStringFree(&parentMatch);
dyStringFree(&retroMatch);
}
}
}
