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