void doRewrite(char *outDir, char *inDir, char *trackFile)
/* Do some sort of rewrite on entire system. */
{
/* Make list and hash of root dir */
struct lm *rootLm = lmInit(0);
char rootName[PATH_LEN];
safef(rootName, sizeof(rootName), "%s/%s", inDir, trackFile);
struct raLevel *rootLevel = raLevelRead(rootName, rootLm);
/* Make subdirectory list. */
struct fileInfo *org, *orgList = listDirX(inDir, "*", FALSE);
for (org = orgList; org != NULL; org = org->next)
{
if (org->isDir)
{
struct lm *orgLm = lmInit(0);
char inOrgDir[PATH_LEN], outOrgDir[PATH_LEN];
safef(inOrgDir, sizeof(inOrgDir), "%s/%s", inDir, org->name);
safef(outOrgDir, sizeof(outOrgDir), "%s/%s", outDir, org->name);
char inOrgFile[PATH_LEN];
safef(inOrgFile, sizeof(inOrgFile), "%s/%s", inOrgDir, trackFile);
struct raLevel *orgLevel = raLevelRead(inOrgFile, orgLm);
orgLevel->parent = rootLevel;
rewriteLevel(orgLevel, outOrgDir, orgLm);
struct fileInfo *db, *dbList = listDirX(inOrgDir, "*", FALSE);
for (db = dbList; db != NULL; db = db->next)
{
if (db->isDir)
{
struct lm *dbLm = lmInit(0);
char inDbDir[PATH_LEN], outDbDir[PATH_LEN];
safef(inDbDir, sizeof(inDbDir), "%s/%s", inOrgDir, db->name);
safef(outDbDir, sizeof(outDbDir), "%s/%s", outOrgDir, db->name);
char inDbFile[PATH_LEN];
safef(inDbFile, sizeof(inDbFile), "%s/%s", inDbDir, trackFile);
struct raLevel *dbLevel = raLevelRead(inDbFile, dbLm);
dbLevel->parent = orgLevel;
rewriteLevel(dbLevel, outDbDir, dbLm);
hashFree(&dbLevel->trackHash);
lmCleanup(&dbLm);
}
}
hashFree(&orgLevel->trackHash);
lmCleanup(&orgLm);
}
}
hashFree(&rootLevel->trackHash);
lmCleanup(&rootLm);
}
static void snapSoftToCloseHard(struct rbTree *vertexTree, struct rbTree *edgeTree, int maxSnapSize,
int maxUncheckedSnapSize, struct nibTwoCache *seqCache, char *chromName)
/* Snap hard vertices to nearby soft vertices of same type. */
{
struct lm *lm = lmInit(0);
addWaysInAndOut(vertexTree, edgeTree, lm);
struct dlList *vList = sortedListFromTree(vertexTree);
struct dlNode *node;
int snapCount = 0;
for (node = vList->head; !dlEnd(node); node = node->next)
{
if (snapVertex(node, maxSnapSize, maxUncheckedSnapSize, seqCache, chromName))
{
rbTreeRemove(vertexTree, node->val);
++snapCount;
}
}
/* Clean up ways in and out since have removed some nodes. */
for (node = vList->head; !dlEnd(node); node = node->next)
{
struct vertex *v = node->val;
v->waysIn = v->waysOut = NULL;
}
if (snapCount > 0)
{
verbose(3, "Snapped %d close edges, now have %d vertices\n", snapCount, vertexTree->n);
updateForwardedEdges(edgeTree);
}
dlListFree(&vList);
lmCleanup(&lm);
}
void wordChain(char *inFile, int maxSize)
/* wordChain - Create Markov chain of words and optionally output chain in two formats. */
{
struct lm *lm = lmInit(0);
struct wordTree *wt = wordTreeForChainsInFile(inFile, maxSize, lm);
if (optionExists("chain"))
{
char *fileName = optionVal("chain", NULL);
FILE *f = mustOpen(fileName, "w");
wordTreeDump(0, wt, f);
carefulClose(&f);
}
if (optionExists("nonsense"))
{
char *fileName = optionVal("nonsense", NULL);
FILE *f = mustOpen(fileName, "w");
int maxSize = min(wt->useCount, maxNonsenseSize);
wordTreeMakeNonsense(wt, maxChainSize, pickRandomWord(wt->following), maxSize, f);
carefulClose(&f);
}
lmCleanup(&lm); // Not really needed since we're just going to exit.
}
struct slName *randomBigBedIds(char *table, struct sqlConnection *conn, int count)
/* Return some arbitrary IDs from a bigBed file. */
{
/* Figure out bigBed file name and open it. Get contents for first chromosome as an example. */
struct slName *idList = NULL;
char *fileName = bigBedFileName(table, conn);
struct bbiFile *bbi = bigBedFileOpen(fileName);
struct bbiChromInfo *chromList = bbiChromList(bbi);
struct lm *lm = lmInit(0);
int orderedCount = count * 4;
if (orderedCount < 100)
orderedCount = 100;
struct bigBedInterval *iv, *ivList = getNElements(bbi, chromList, lm, orderedCount);
shuffleList(&ivList);
// Make a list of item names from intervals.
int outCount = 0;
for (iv = ivList; iv != NULL && outCount < count; iv = iv->next)
{
char *row[bbi->fieldCount];
char startBuf[16], endBuf[16];
bigBedIntervalToRow(iv, chromList->name, startBuf, endBuf, row, bbi->fieldCount);
if (idList == NULL || differentString(row[3], idList->name))
{
slAddHead(&idList, slNameNew(row[3]));
outCount++;
}
}
lmCleanup(&lm);
bbiFileClose(&bbi);
freeMem(fileName);
return idList;
}
struct slName *randomBamIds(char *table, struct sqlConnection *conn, int count)
/* Return some semi-random qName based IDs from a BAM file. */
{
/* Read 10000 items from bam file, or if they ask for a big list, then 4x what they ask for. */
char *fileName = bamFileName(table, conn, NULL);
samfile_t *fh = bamOpen(fileName, NULL);
struct lm *lm = lmInit(0);
int orderedCount = count * 4;
if (orderedCount < 10000)
orderedCount = 10000;
struct samAlignment *sam, *samList = bamReadNextSamAlignments(fh, orderedCount, lm);
/* Shuffle list and extract qNames from first count of them. */
shuffleList(&samList);
struct slName *randomIdList = NULL;
int i;
for (i=0, sam = samList; i<count && sam != NULL; ++i, sam = sam->next)
slNameAddHead(&randomIdList, sam->qName);
/* Clean up and go home. */
lmCleanup(&lm);
bamClose(&fh);
freez(&fileName);
return randomIdList;
}
static void addFilteredBedsOnRegion(char *fileName, struct region *region,
char *table, struct asFilter *filter, struct lm *bedLm, struct bed **pBedList,
struct hash *idHash, int *pMaxOut)
/* Add relevant beds in reverse order to pBedList */
{
struct lm *lm = lmInit(0);
struct samAlignment *sam, *samList = bamFetchSamAlignment(fileName, region->chrom,
region->start, region->end, lm);
char *row[SAMALIGNMENT_NUM_COLS];
char numBuf[BAM_NUM_BUF_SIZE];
for (sam = samList; sam != NULL; sam = sam->next)
{
samAlignmentToRow(sam, numBuf, row);
if (asFilterOnRow(filter, row))
{
if ((idHash != NULL) && (hashLookup(idHash, sam->qName) == NULL))
continue;
struct bed *bed;
lmAllocVar(bedLm, bed);
bed->chrom = lmCloneString(bedLm, sam->rName);
bed->chromStart = sam->pos - 1;
bed->chromEnd = bed->chromStart + cigarWidth(sam->cigar, strlen(sam->cigar));
bed->name = lmCloneString(bedLm, sam->qName);
slAddHead(pBedList, bed);
}
(*pMaxOut)--;
if (*pMaxOut <= 0)
break;
}
lmCleanup(&lm);
}
struct perBaseWig* perBaseWigLoadContinue(struct metaBig* mb, char* chrom, int start, int end)
/* load a perBaseWig from a wig/bigWig that's already open */
{
if (mb->type != isaBigWig)
return NULL;
struct perBaseWig* list = NULL;
struct lm* lm = lmInit(0);
struct bbiInterval* intervals = bigWigIntervalQuery(mb->big.bbi, chrom, start, end, lm);
struct bbiInterval *bbStart = intervals, *bbEnd;
while (bbStart != NULL) {
struct perBaseWig* region;
struct bbiInterval* cur;
int i = 0;
bbEnd = bbStart;
/* loop until discontinuity detected */
while ((bbEnd->next != NULL) && (bbEnd->end == bbEnd->next->start))
bbEnd = bbEnd->next;
region = alloc_perBaseWig(chrom, bbStart->start, bbEnd->end);
for (cur = bbStart; cur != bbEnd->next; cur = cur->next) {
int j;
for (j = cur->start; j < cur->end; j++)
region->data[i++] = cur->val;
}
slAddHead(&list, region);
bbStart = bbEnd->next;
}
lmCleanup(&lm);
slReverse(&list);
return list;
}
Bits *bitsForIntersectingTable(struct sqlConnection *conn, struct region *region, int chromSize,
boolean isBpWise)
/* Get a bitmap that corresponds to the table we are intersecting with.
* Consult CGI vars to figure out what table it is. */
{
boolean invTable2 = cartCgiUsualBoolean(cart, hgtaInvertTable2, FALSE);
char *table2 = cartString(cart, hgtaIntersectTable);
struct hTableInfo *hti2 = getHti(database, table2, conn);
struct lm *lm2 = lmInit(64*1024);
Bits *bits2 = bitAlloc(chromSize+8);
struct bed *bedList2;
if (isBigWigTable(table2))
bedList2 = bigWigIntervalsToBed(conn, table2, region, lm2);
else
// We should go straight to raw beds here, not through the routines that
// do filter & intersections, because the secondary table has no filter
// and sure shouldn't be intersected. :)
bedList2 = getFilteredBeds(conn, table2, region, lm2, NULL);
if (!isBpWise)
expandZeroSize(bedList2, hti2->hasBlocks, chromSize);
bedOrBits(bits2, chromSize, bedList2, hti2->hasBlocks, 0);
if (invTable2)
bitNot(bits2, chromSize);
lmCleanup(&lm2);
return bits2;
}
long metaBigNumItems(struct metaBig* mb, boolean verbose)
/* return the total number of items in a bigBed or BAM */
/* used on a bigWig will return 0 */
/* unfortunately this is a loop through the entire file basically. */
/* nicer would be something that just glances at the index, but doing that */
/* might count items that would be filtered out upon fetching. */
{
long sum = 0;
struct bed* section;
struct bed* chroms = NULL;
if (mb->type == isaBigWig)
return 0;
else if (mb->type == isaBigBed)
return (long)bigBedItemCount(mb->big.bbi);
else
chroms = sectionsFromChromSizes(mb->chromSizeHash);
for (section = chroms; section != NULL; section = section->next) {
struct lm* lm = lmInit(0);
struct bed6* list = metaBigBed6Fetch(mb, section->chrom, section->chromStart, section->chromEnd, lm);
int num = slCount(list);
if (verbose)
printf("Number of items in %s of %s: %d\n", section->chrom, mb->fileName, num);
sum += num;
lmCleanup(&lm);
}
bedFreeList(&chroms);
return sum;
}
static void loadCytoBandsIdeo(struct track *tg)
/* Load up cytoBandIdeo from database table to track items. */
{
if (tg->isBigBed)
{
struct lm *lm = lmInit(0);
int start = 0;
int end = hChromSize(database, chromName);
struct bigBedInterval *bb, *bbList = bigBedSelectRange(tg, chromName, start, end, lm);
char *bedRow[32];
char startBuf[16], endBuf[16];
for (bb = bbList; bb != NULL; bb = bb->next)
{
bigBedIntervalToRow(bb, chromName, startBuf, endBuf, bedRow, ArraySize(bedRow));
struct cytoBand *bed = cytoBandLoad(bedRow);
slAddHead(&tg->items, bed);
}
slReverse(&tg->items);
lmCleanup(&lm);
return;
}
char query[256];
sqlSafef(query, sizeof(query),
"select * from cytoBandIdeo where chrom like '%s'", chromName);
if(hTableExists(database, "cytoBandIdeo"))
bedLoadItemByQuery(tg, "cytoBandIdeo", query, (ItemLoader)cytoBandLoad);
if(slCount(tg->items) == 0)
{
tg->limitedVisSet = TRUE;
tg->limitedVis = tvHide;
}
}
void joinTwoInfo(char *spec1, char *spec2)
/* joinTwoInfo - Look at two columns in two tables in mySQL and see how joinable they look.. */
{
char *s1[4], *s2[4];
struct lm *lm = lmInit(0);
int partCount = chopByChar(lmCloneString(lm, spec1), '.', s1, ArraySize(s1));
if (partCount != 3)
usage();
partCount = chopByChar(lmCloneString(lm, spec2), '.', s2, ArraySize(s2));
if (partCount != 3)
usage();
struct slName *list1 = getColumn(s1[0], s1[1], s1[2], lm);
struct hash *uniq1 = uniqHash(list1);
struct slName *list2 = getColumn(s2[0], s2[1], s2[2], lm);
struct hash *uniq2 = uniqHash(list2);
int countOneInTwo = countInHash(list1, uniq2);
int countTwoInOne = countInHash(list2, uniq1);
int countUniqOneInTwo = countUniqInHash(list1, uniq2);
int countUniqTwoInOne = countUniqInHash(list2, uniq1);
printf("%s: %d items, %d unique items, %d items (%d unique) in %s\n",
spec1, slCount(list1), uniq1->elCount, countOneInTwo, countUniqOneInTwo, spec2);
printf("%s: %d items, %d unique items, %d items (%d unique) in %s\n",
spec2, slCount(list2), uniq2->elCount, countTwoInOne, countUniqTwoInOne, spec1);
lmCleanup(&lm);
}
void bigWigFileCreate(
char *inName, /* Input file in ascii wiggle format. */
char *chromSizes, /* Two column tab-separated file: <chromosome> <size>. */
int blockSize, /* Number of items to bundle in r-tree. 1024 is good. */
int itemsPerSlot, /* Number of items in lowest level of tree. 512 is good. */
boolean clipDontDie, /* If TRUE then clip items off end of chrom rather than dying. */
boolean compress, /* If TRUE then compress data. */
boolean keepAllChromosomes, /* If TRUE then store all chromosomes in chromosomal b-tree. */
boolean fixedSummaries, /* If TRUE then impose fixed summary levels. */
char *outName)
/* Convert ascii format wig file (in fixedStep, variableStep or bedGraph format)
* to binary big wig format. */
{
/* This code needs to agree with code in two other places currently - bigBedFileCreate,
* and bbiFileOpen. I'm thinking of refactoring to share at least between
* bigBedFileCreate and bigWigFileCreate. It'd be great so it could be structured
* so that it could send the input in one chromosome at a time, and send in the zoom
* stuff only after all the chromosomes are done. This'd potentially reduce the memory
* footprint by a factor of 2 or 4. Still, for now it works. -JK */
struct hash *chromSizeHash = bbiChromSizesFromFile(chromSizes);
struct lm *lm = lmInit(0);
struct bwgSection *sectionList = bwgParseWig(inName, clipDontDie, chromSizeHash, itemsPerSlot, lm);
if (sectionList == NULL)
errAbort("%s is empty of data", inName);
bwgCreate(sectionList, chromSizeHash, blockSize, itemsPerSlot, compress, keepAllChromosomes, fixedSummaries, outName);
lmCleanup(&lm);
}
INLINE void agTrimToStart(struct annoGrator *self, char *chrom, uint start)
/* If queue contains items whose end is to the left of start, splice them out. */
{
struct annoRow *qRow, *prevQRow = NULL, *nextQRow;
for (qRow = self->qHead; qRow != NULL; qRow = nextQRow)
{
nextQRow = qRow->next;
int cDifRowP = strcmp(qRow->chrom, chrom);
if (cDifRowP > 0 || (cDifRowP == 0 && qRow->start >= start))
break;
else if (cDifRowP < 0 || qRow->end < start)
{
if (prevQRow == NULL)
self->qHead = qRow->next;
else
prevQRow->next = qRow->next;
if (self->qTail == qRow)
self->qTail = prevQRow;
}
else
prevQRow = qRow;
}
if (self->qHead == NULL)
{
// Queue is empty - clean up lm
lmCleanup(&(self->qLm));
self->qLm = lmInit(0);
self->qSkippedCount = 0;
}
}
void bigWigFillDataVector(char *table, struct region *region,
struct sqlConnection *conn, struct dataVector *vector)
/* Fill in data vector with bigWig info on region. Handles filters and intersections. */
{
/* Figure out filter values if any. */
double ll, ul;
enum wigCompare cmp;
getWigFilter(database, curTable, &cmp, &ll, &ul);
/* Get intervals that pass filter and intersection. */
struct lm *lm = lmInit(0);
char *fileName = bigWigFileName(table, conn);
struct bbiFile *bwf = bigWigFileOpen(fileName);
struct bbiInterval *iv, *ivList;
ivList = intersectedFilteredBbiIntervalsOnRegion(conn, bwf, region, cmp, ll, ul, lm);
int vIndex = 0;
for (iv = ivList; iv != NULL; iv = iv->next)
{
int start = max(iv->start, region->start);
int end = min(iv->end, region->end);
double val = iv->val;
int i;
for (i=start; i<end && vIndex < vector->maxCount; ++i)
{
vector->value[vIndex] = val;
vector->position[vIndex] = i;
++vIndex;
}
}
vector->count = vIndex;
bbiFileClose(&bwf);
freeMem(fileName);
lmCleanup(&lm);
}
void cirTreeFileBulkIndexToOpenFile(
void *itemArray, int itemSize, bits64 itemCount,
bits32 blockSize, bits32 itemsPerSlot,
void *context,
struct cirTreeRange (*fetchKey)(const void *va, void *context),
bits64 (*fetchOffset)(const void *va, void *context),
bits64 endFileOffset, FILE *f)
/* Create a r tree index from a sorted array, writing output starting at current position
* of an already open file. See rTreeFileCreate for explanation of parameters. */
{
int levelCount;
struct lm *lm = lmInit(0);
struct rTree *tree = rTreeFromChromRangeArray(lm, blockSize, itemsPerSlot,
itemArray, itemSize, itemCount, context, fetchKey, fetchOffset, endFileOffset,
&levelCount);
bits32 magic = cirTreeSig;
bits32 reserved = 0;
writeOne(f, magic);
writeOne(f, blockSize);
writeOne(f, itemCount);
writeOne(f, tree->startChromIx);
writeOne(f, tree->startBase);
writeOne(f, tree->endChromIx);
writeOne(f, tree->endBase);
writeOne(f, endFileOffset);
writeOne(f, itemsPerSlot);
writeOne(f, reserved);
writeTreeToOpenFile(tree, blockSize, levelCount, f);
lmCleanup(&lm);
}
void bigBedAddLinkedFeaturesFrom(struct track *track,
char *chrom, int start, int end, int scoreMin, int scoreMax, boolean useItemRgb,
int fieldCount, struct linkedFeatures **pLfList)
/* Read in items in chrom:start-end from bigBed file named in track->bbiFileName, convert
* them to linkedFeatures, and add to head of list. */
{
struct lm *lm = lmInit(0);
struct trackDb *tdb = track->tdb;
struct bigBedInterval *bb, *bbList = bigBedSelectRange(track, chrom, start, end, lm);
char *bedRow[32];
char startBuf[16], endBuf[16];
char *scoreFilter = cartOrTdbString(cart, track->tdb, "scoreFilter", NULL);
char *mouseOverField = cartOrTdbString(cart, track->tdb, "mouseOverField", NULL);
int minScore = 0;
if (scoreFilter)
minScore = atoi(scoreFilter);
int mouseOverIdx = bbExtraFieldIndex(tdb, mouseOverField);
for (bb = bbList; bb != NULL; bb = bb->next)
{
char* mouseOver = restField(bb, mouseOverIdx);
bigBedIntervalToRow(bb, chromName, startBuf, endBuf, bedRow, ArraySize(bedRow));
struct bed *bed = bedLoadN(bedRow, fieldCount);
struct linkedFeatures *lf = bedMungToLinkedFeatures(&bed, tdb, fieldCount,
scoreMin, scoreMax, useItemRgb);
if (scoreFilter == NULL || lf->score >= minScore)
slAddHead(pLfList, lf);
lf->mouseOver = mouseOver; // leaks some memory, cloneString handles NULL ifself
if (sameString(track->tdb->type, "bigGenePred"))
lf->original = genePredFromBigGenePred(chromName, bb);
}
lmCleanup(&lm);
}
void bitmapToMaskArray(struct hash *bitmapHash, struct hash *tbHash)
/* Translate each bitmap in bitmapHash into an array of mask coordinates
* in the corresponding twoBit in tbHash. Assume tbHash's mask array is
* empty at the start -- we allocate it here. Free bitmap when done. */
{
struct hashCookie cookie = hashFirst(tbHash);
struct hashEl *hel = NULL;
while ((hel = hashNext(&cookie)) != NULL)
{
char *seqName = hel->name;
struct twoBit *tb = (struct twoBit *)(hel->val);
struct hashEl *bHel = hashLookup(bitmapHash, seqName);
Bits *bits;
unsigned start=0, end=0;
assert(tb != NULL);
assert(tb->maskBlockCount == 0);
if (bHel == NULL)
errAbort("Missing bitmap for seq \"%s\"", seqName);
bits = (Bits *)bHel->val;
if (bits != NULL)
{
struct lm *lm = lmInit(0);
struct unsignedRange *rangeList = NULL, *range = NULL;
int i;
for (;;)
{
start = bitFindSet(bits, end, tb->size);
if (start >= tb->size)
break;
end = bitFindClear(bits, start, tb->size);
if (end > start)
{
lmAllocVar(lm, range);
range->start = start;
range->size = (end - start);
slAddHead(&rangeList, range);
}
}
slReverse(&rangeList);
tb->maskBlockCount = slCount(rangeList);
if (tb->maskBlockCount > 0)
{
AllocArray(tb->maskStarts, tb->maskBlockCount);
AllocArray(tb->maskSizes, tb->maskBlockCount);
for (i = 0, range = rangeList; range != NULL;
i++, range = range->next)
{
tb->maskStarts[i] = range->start;
tb->maskSizes[i] = range->size;
}
}
lmCleanup(&lm);
bitFree(&bits);
bHel->val = NULL;
}
}
}
static void resetRowBuf(struct rowBuf *rowBuf)
/* Reset temporary storage for chunked query rows. */
{
rowBuf->buf = NULL;
rowBuf->size = 0;
rowBuf->ix = 0;
lmCleanup(&(rowBuf->lm));
}
static void resetMergeState(struct annoStreamDb *self)
/* Reset or initialize members that track merging of coarse-bin items with fine-bin items. */
{
self->mergeBins = FALSE;
self->bigItemQueue = self->smallItemQueue = NULL;
lmCleanup(&(self->qLm));
self->gotFinestBin = FALSE;
}
void gffClose(struct gff *gff)
/* Close down gff structure. */
{
if (gff->file != NULL)
fclose(gff->file);
freeMem(gff->dna);
lmCleanup(&gff->memPool);
zeroBytes(gff, sizeof(*gff));
}
static void addBbCorrelations(struct bbiChromInfo *chrom, struct genomeRangeTree *targetGrt,
struct bbiFile *aBbi, struct bbiFile *bBbi,
int numColIx, struct correlate *c, struct correlate *cInEnriched,
long long *aTotalSpan, long long *bTotalSpan, long long *overlapTotalSpan)
/* Find bits of a and b that overlap and also overlap with targetRanges. Try to extract
* some number from the bed (which number depends on format). Returns total number of
* overlapping bases between the two big-beds. */
{
struct lm *lm = lmInit(0);
struct rbTree *targetRanges = NULL;
if (targetGrt != NULL)
targetRanges = genomeRangeTreeFindRangeTree(targetGrt, chrom->name);
struct bigBedInterval *a, *aList = bigBedIntervalQuery(aBbi, chrom->name, 0, chrom->size, 0, lm);
struct bigBedInterval *b, *bList = bigBedIntervalQuery(bBbi, chrom->name, 0, chrom->size, 0, lm);
long long totalOverlap = 0;
/* This is a slightly complex but useful loop for two sorted lists that will get overlaps between
* the two in linear time. */
a = aList;
b = bList;
for (;;)
{
if (a == NULL || b == NULL)
break;
int s = max(a->start,b->start);
int e = min(a->end,b->end);
int overlap = e - s;
if (overlap > 0)
{
totalOverlap += overlap;
/* Do correlation over a/b overlap */
double aVal = getDoubleValAt(a->rest, numColIx);
double bVal = getDoubleValAt(b->rest, numColIx);
correlateNextMulti(c, aVal, bVal, overlap);
/* Got intersection of a and b - is it also in targetRange? */
if (targetRanges)
{
int targetOverlap = rangeTreeOverlapSize(targetRanges, s, e);
if (targetOverlap > 0)
{
correlateNextMulti(cInEnriched, aVal, bVal, targetOverlap);
}
}
}
if (a->end < b->end)
a = a->next;
else
b = b->next;
}
*overlapTotalSpan += totalOverlap;
*aTotalSpan += bbIntervalListTotalSpan(aList);
*bTotalSpan += bbIntervalListTotalSpan(bList);
lmCleanup(&lm);
}
static void asbwSetRegion(struct annoStreamer *vSelf, char *chrom, uint regionStart, uint regionEnd)
/* Set region -- and free localmem from previous query if necessary. */
{
annoStreamerSetRegion(vSelf, chrom, regionStart, regionEnd);
struct annoStreamBigWig *self = (struct annoStreamBigWig *)vSelf;
self->nextInterval = self->intervalList = NULL;
self->queryChrom = NULL;
self->eof = FALSE;
lmCleanup(&(self->intervalQueryLm));
}
void writeBw(char *inName, char *outName, struct hash *chromSizeHash)
/* copied from bwtool_shared.c */
{
struct lm *lm = lmInit(0);
struct bwgSection *sectionList = bwgParseWig(inName, TRUE, chromSizeHash, 1024, lm);
if (sectionList == NULL)
errAbort("%s is empty of data", inName);
bwgCreate(sectionList, chromSizeHash, 256, 1024, TRUE, outName);
lmCleanup(&lm);
}
void tagStormFree(struct tagStorm **pTagStorm)
/* Free up memory associated with tag storm */
{
struct tagStorm *tagStorm = *pTagStorm;
if (tagStorm != NULL)
{
lmCleanup(&tagStorm->lm);
*pTagStorm = NULL;
}
}
void rbTreeFree(struct rbTree **pTree)
/* rbTreeFree() - Frees space used by the red-black tree pointed to by t. */
{
struct rbTree *tree = *pTree;
if (tree != NULL)
{
lmCleanup(&tree->lm);
freez(pTree);
}
}
struct middles* metaBig_get_middles(struct metaBig* mb, char* chrom, unsigned start, unsigned end)
/* return middles struct used with stackreads program */
{
struct middles* mids = NULL;
struct lm* lm = lmInit(0);
struct bed6* bedList = metaBigBed6Fetch(mb, chrom, start, end, lm);
mids = beds_to_middles(bedList);
lmCleanup(&lm);
return mids;
}
void searchOneProt(aaSeq *seq, struct genoFind *gf, FILE *f)
/* Search for protein seq in index and write results to psl. */
{
int hitCount;
struct lm *lm = lmInit(0);
struct gfClump *clumpList = gfFindClumps(gf, seq, lm, &hitCount);
gfAlignAaClumps(gf, clumpList, seq, FALSE, minScore, gvo);
gfClumpFreeList(&clumpList);
lmCleanup(&lm);
}
/* --- .Call ENTRY POINT --- */
SEXP BWGSectionList_cleanup(SEXP r_sections)
{
pushRHandlers();
if (r_sections != R_NilValue) {
struct lm *lm = R_ExternalPtrAddr(R_ExternalPtrTag(r_sections));
lmCleanup(&lm);
}
popRHandlers();
return R_NilValue;
}
struct starts* metaBig_get_starts(struct metaBig* mb, char* chrom, unsigned start, unsigned end)
/* return starts struct used with the phasogram/distogram programs */
{
struct starts* starts = NULL;
struct lm* lm = lmInit(0);
struct bed6* bedList = metaBigBed6Fetch(mb, chrom, start, end, lm);
starts = beds_to_starts(bedList);
lmCleanup(&lm);
return starts;
}
struct cdsEvidence *orfsOnRna(struct dnaSeq *seq, struct hash *nmdHash, struct hash *mafHash,
int otherSpeciesCount, boolean anyStart)
/* Return scored list of all ORFs on RNA. */
{
DNA *dna = seq->dna;
int lastPos = seq->size - 3;
int startPos;
struct cdsEvidence *orfList = NULL, *orf;
struct lm *lm = lmInit(64*1024);
/* Figure out the key piece of info for NMD. */
int lastIntronPos = findLastIntronPos(nmdHash, seq->name);
double orthoWeightPer = 0;
struct orthoCdsArray *orthoList = NULL;
/* Calculate stuff useful for orthology */
if (otherSpeciesCount > 0)
{
orthoWeightPer = 1.0/otherSpeciesCount;
struct mafAli *maf = hashFindVal(mafHash, seq->name);
if (maf != NULL)
{
orthoList = calcOrthoList(maf, lm);
// uglyf("%s: ", seq->name);
// dumpOrthoArray(orthoArray, uglyOut);
}
}
/* Allocate some arrays that keep track of bases in
* upstream. This dramatically speeds up processing
* of TTN and other long transcripts which otherwise
* can take almost a minute each. */
int *upAtgCount, *upKozakCount;
lmAllocArray(lm, upAtgCount, seq->size);
lmAllocArray(lm, upKozakCount, seq->size);
calcUpstreams(seq, upAtgCount, upKozakCount);
/* Go through sequence making up a record for each
* start codon we find. */
for (startPos=0; startPos<=lastPos; ++startPos)
{
if (startsWith("atg", dna+startPos) || (anyStart && startPos < 3))
{
int stopPos = orfEndInSeq(seq, startPos);
orf = createCds(seq, startPos, stopPos, upAtgCount, upKozakCount,
lastIntronPos, orthoList, orthoWeightPer);
slAddHead(&orfList, orf);
}
}
slReverse(&orfList);
/* Clean up and go home. */
lmCleanup(&lm);
return orfList;
}
