void loadCr2g(char *fileName, struct cr2g **chromLists) { char buf[512]; struct cr2g *el; FILE *f = mustOpen(fileName, "r"); char *words[8]; int wordCount; char *parts[3]; int partCount; int chromIx; uglyf("Loading %s<BR>\n", fileName); while (fgets(buf, sizeof(buf), f) != NULL) { wordCount = chopString(buf, whiteSpaceChopper, words, ArraySize(words)); if (wordCount != 3) errAbort("Bad cr2g file\n"); partCount = chopString(words[0], ":-", parts, ArraySize(parts)); if (partCount != 3) errAbort("Bad cr2g file\n"); AllocVar(el); chromIx = findChromIx(parts[0]); el->strand = words[1][0]; el->start = atoi(parts[1]); el->end = atoi(parts[2]); strncpy(el->geneName, words[2], sizeof(el->geneName)); el->next = chromLists[chromIx]; chromLists[chromIx] = el; } uglyf("Done loading %s<BR>\n", fileName); fclose(f); }
void chainPair(struct seqPair *sp, FILE *f) /* Make chains for all alignments in sp. */ { long startTime, dt; struct axt *axt; struct cBlock *blockList, *block; struct chain *chainList = NULL, *chain; uglyf("%s %d nodes\n", sp->name, slCount(sp->blockList)); /* Make up tree and time it for debugging. */ startTime = clock1000(); chainList = chainBlocks(&sp->blockList, gapCost); dt = clock1000() - startTime; uglyf("Made %d chains in %5.3f seconds\n", slCount(chainList), dt*0.001); /* Dump chains to file. */ for (chain = chainList; chain != NULL; chain = chain->next) { struct cBlock *first = chain->blockList; struct cBlock *last = slLastEl(first); struct cBlock *block; fprintf(f, "%s Chain %d, score %d, %d %d, %d %d:\n", sp->name, slCount(chain->blockList), chain->score, first->qStart, last->qEnd, first->tStart, last->qEnd); for (block = chain->blockList; block != NULL; block = block->next) { fprintf(f, " %s q %d, t %d, score %d\n", sp->name, block->qStart, block->tStart, block->score); } fprintf(f, "\n"); } chainFreeList(&chainList); uglyf("\n"); }
void rt1dFindOld(char *tabFile, char *treeFile, bits32 chromIx, bits32 start, bits32 end) /* rt1dCreate - find items in 1-D range tree. */ { struct lineFile *lf = lineFileOpen(tabFile, TRUE); struct cirTreeFile *crf = cirTreeFileOpen(treeFile); struct fileOffsetSize *block, *blockList = cirTreeFindOverlappingBlocks(crf, chromIx, start, end); uglyf("Got %d overlapping blocks\n", slCount(blockList)); for (block = blockList; block != NULL; block = block->next) { uglyf("block->offset %llu, block->size %llu\n", block->offset, block->size); lineFileSeek(lf, block->offset, SEEK_SET); bits64 sizeUsed = 0; while (sizeUsed < block->size) { char *line; int size; if (!lineFileNext(lf, &line, &size)) errAbort("Couldn't read %s\n", lf->fileName); char *parsedLine = cloneString(line); char *row[3]; if (chopLine(parsedLine, row) != ArraySize(row)) errAbort("Badly formatted line of %s\n%s", lf->fileName, line); bits32 bedChromIx = sqlUnsigned(row[0]); bits32 bedStart = sqlUnsigned(row[1]); bits32 bedEnd = sqlUnsigned(row[2]); if (bedChromIx == chromIx && rangeIntersection(bedStart, bedEnd, start, end) > 0) fprintf(stdout, "%s\n", line); freeMem(parsedLine); sizeUsed += size; } } }
void alignNt(char *nt) /* Do alignments of draft bacs against one NT. */ { char indexFileName[512]; char ntFaName[512]; struct lineFile *indexLf; int lineSize; char *line; char *words[3]; int wordCount; struct patSpace *ps; struct dnaSeq *ntSeq; printf("<H1>Check Layout of %s</H1>\n", nt); printf("<PRE>"); sprintf(ntFaName, "%s/p%s.fa", faDir, nt); ntSeq = faReadAllDna(ntFaName); ps = makePatSpace(&ntSeq, 1, oocFile, 10, 500); sprintf(indexFileName, "%s/%s.index", indexDir, nt); uglyf("Checking out %s and %s\n", indexFileName, ntFaName); indexLf = lineFileOpen(indexFileName, TRUE); while (lineFileNext(indexLf, &line, &lineSize)) { wordCount = chopLine(line, words); if (wordCount > 0) { char bacFaName[512]; struct dnaSeq *contigList, *contig; char *bacAcc = words[0]; char *s = strrchr(bacAcc, '.'); if (s != NULL) *s = 0; uglyf("%s\n", bacAcc); sprintf(bacFaName, "%s/%s.fa", faDir, bacAcc); contigList = faReadAllDna(bacFaName); for (contig = contigList; contig != NULL; contig = contig->next) { boolean isRc; uglyf(" %s\n", contig->name); for (isRc = FALSE; isRc <= TRUE; isRc += 1) { struct ssBundle *bunList, *bun; bunList = ssFindBundles(ps, contig, contig->name, ffTight); for (bun = bunList; bun != NULL; bun = bun->next) { showBundle(bun, isRc); } ssBundleFreeList(&bunList); reverseComplement(contig->dna, contig->size); } } freeDnaSeqList(&contigList); } } lineFileClose(&indexLf); freeDnaSeqList(&ntSeq); }
void intersectOnChrom(char *db, struct sqlConnection *conn, char *chrom, char *track1, char *track2) /* Do intersection on one chromosome. */ { int chromSize = hChromSize(chrom); struct lm *lm = lmInit(0); struct bed *bedList1, *bedList2, *andBed; struct featureBits *fb1, *fb2; Bits *bit1, *bit2; int fieldCount1, fieldCount2; struct binKeeper *bk2; uglyTime(NULL); scanChromTable(conn, chrom, track1); scanChromTable(conn, chrom, track2); uglyTime("Scan tracks"); bedList1 = getChromAsBed(conn, db, track1, chrom, lm, &fieldCount1); bedList2 = getChromAsBed(conn, db, track2, chrom, lm, &fieldCount2); uglyTime("Tracks as bed"); uglyf("%d items with %d fields in %s, ", slCount(bedList1), fieldCount1, track1); uglyf("%d items with %d fields in %s\n", slCount(bedList2), fieldCount2, track2); bit1 = bitAlloc(chromSize+8); bit2 = bitAlloc(chromSize+8); uglyTime("bitAlloc"); fb1 = fbList(db, chrom, track1, bedList1, chromSize); fb2 = fbList(db, chrom, track1, bedList1, chromSize); uglyTime("bed to featureBits list"); fbOrBits(bit1, chromSize, fb1, 0); fbOrBits(bit2, chromSize, fb2, 0); uglyTime("or into bits"); bitAnd(bit1, bit2, chromSize); uglyTime("Anding bitfields"); andBed = bitsToBed4List(bit1, chromSize, chrom, 0, 0, chromSize, lm); uglyTime("Converting bitfield to bed 4"); bitCountAllOverlaps(bedList1, bit2, fieldCount2); uglyTime("Counting overlaps in track1 with bitfield of track2"); bk2 = fbToBinKeeper(fb2, chromSize); uglyTime("Adding featureBits list from track 2 into binKeeper."); bkCountAllOverlaps(bedList1, bk2, fieldCount2); uglyTime("Count overlaps in track1 with binKeeper of track2"); featureBitsFreeList(&fb1); featureBitsFreeList(&fb2); uglyTime("free featureBits"); bitFree(&bit1); bitFree(&bit2); uglyTime("bitFree"); }
void hgNibSeq(char *database, char *destDir, int faCount, char *faNames[]) /* hgNibSeq - convert DNA to nibble-a-base and store location in database. */ { char dir[256], name[128], chromName[128], ext[64]; char nibName[512]; struct sqlConnection *conn = sqlConnect(database); char query[512]; int i; char *faName; struct dnaSeq *seq = NULL; unsigned long total = 0; int size; if (!strchr(destDir, '/')) errAbort("Use full path name for nib file dir\n"); makeDir(destDir); if ((!appendTbl) || !sqlTableExists(conn, tableName)) createTable(conn); for (i=0; i<faCount; ++i) { faName = faNames[i]; splitPath(faName, dir, name, ext); sprintf(nibName, "%s/%s.nib", destDir, name); printf("Processing %s to %s\n", faName, nibName); if (preMadeNib) { FILE *nibFile; nibOpenVerify(nibName, &nibFile, &size); carefulClose(&nibFile); } else { seq = faReadDna(faName); if (seq != NULL) { size = seq->size; uglyf("Read DNA\n"); nibWrite(seq, nibName); uglyf("Wrote nib\n"); freeDnaSeq(&seq); } } strcpy(chromName, chromPrefix); strcat(chromName, name); sqlSafef(query, sizeof query, "INSERT into %s VALUES('%s', %d, '%s')", tableName, chromName, size, nibName); sqlUpdate(conn,query); total += size; } sqlDisconnect(&conn); printf("%lu total bases\n", total); }
int main() { testPolyOut(); uglyf("Ok1\n"); testPolyIn(); uglyf("Ok2\n"); testPolyhOut(); uglyf("Ok3\n"); testPolyhIn(); uglyf("Ok4\n"); return 0; }
void makeCdnaToGene(struct cdnaInfo *cdnaList) /* Make cdna to gene translation file. */ { struct hash *hash = newHash(12); struct cdnaInfo *ci; struct fineAli *fa; struct geneHit *gh; struct geneHitList *geneHitList = NULL; struct geneHitList *ghl; struct hashEl *he; uglyf("Making cdnaToGene file<BR>\n"); for (ci = cdnaList; ci != NULL; ci = ci->next) { if (ci->isDupe) continue; for (fa = ci->fineAli; fa != NULL; fa = fa->next) { if (fa->isDupe || !fa->isGood) continue; if ((he = hashLookup(hash, fa->geneName)) == NULL) { AllocVar(ghl); ghl->geneName = fa->geneName; ghl->next = geneHitList; geneHitList = ghl; he = hashAdd(hash, fa->geneName, ghl); } ghl = (struct geneHitList *)(he->val); AllocVar(gh); gh->cdnaName = ci->name; gh->chromOffset = fa->hStart; gh->next = ghl->hits; ghl->hits = gh; } } slSort(&geneHitList, cmpGhlName); for (ghl=geneHitList; ghl!=NULL; ghl = ghl->next) { slReverse(&ghl->hits); slSort(&ghl->hits, cmpGhOffset); fprintf(cdnaToGeneFile, "%s ", ghl->geneName); for (gh = ghl->hits; gh != NULL; gh = gh->next) fprintf(cdnaToGeneFile, "%s ", gh->cdnaName); fprintf(cdnaToGeneFile, "\n"); } freeHash(&hash); slFreeList(&geneHitList); uglyf("Done making cdnaToGene file<BR>\n"); }
void smallTest() /* Test out stuff. */ { struct ggMrnaCluster *mc = makeTestInput(); struct geneGraph *gg; static struct ggMrnaInput dummyCi; uglyf("Initial input\n"); dumpMc(mc); uglyf("\n"); gg = ggGraphCluster(mc, &dummyCi); traverseGeneGraph(gg, mc->tStart, mc->tEnd, dumpGgAliInfo); errAbort("Done testing"); }
int bwtSearch(UBYTE *bwt, bits32 size, char *string) /* Reverse Burrows Wheeler transform of string. */ { /* Empty case is easy here (and a pain if we have to deal with it later) */ if (size == 0) return 0; /* Make array that will store the count of occurences of each character up to a given position. */ bits32 *occ; AllocArray(occ, size+1); /* Count up occurences of all characters into offset array. */ bits32 i, counts[256], offsets[256]; for (i=0; i<256; ++i) counts[i] = 0; for (i=0; i<size; ++i) { int c = bwt[i]; occ[i] = counts[c]; counts[c] += 1; } /* Convert counts to offsets. */ bits32 total = 0; for (i=0; i<ArraySize(offsets); ++i) { offsets[i] = total; total += counts[i]; } i = strlen(string)-1; int start = 0, end = size-1; while (start <= end) { UBYTE c = string[i]; int startOcc = findOcc(bwt, c, start-1); int endOcc = findOcc(bwt, c, end) - 1; uglyf("%u start=%u end=%u c=%c(%d) offsets[%c]=%d startOcc=%d endOcc=%d\n", i, start, end, c, c, c, offsets[c], startOcc, endOcc); start = offsets[c] + startOcc; end = offsets[c] + endOcc; if (i == 0) break; i = i - 1; } uglyf("final i=%d start=%u end=%u\n", i, start, end); if (i != 0) return 0; return end - start + 1; }
void freen(char *chrom) /* Test something */ { uglyTime(NULL); struct sqlConnection *conn = sqlConnect("hg19"); uglyTime("connect"); char query[512]; sqlSafef(query, sizeof(query), "select * from knownGene where chrom='%s'", chrom); struct sqlResult *sr = sqlGetResult(conn, query); uglyTime("get result"); char **row; struct rbTree *rt = rangeTreeNew(); while ((row = sqlNextRow(sr)) != NULL) { struct genePred *gp = genePredLoad(row); int i; int exonCount = gp->exonCount; for (i=0; i<exonCount; ++i) rangeTreeAdd(rt, gp->exonStarts[i], gp->exonEnds[i]); } uglyTime("Add rows"); struct range *list = rangeTreeList(rt); uglyTime("Did list"); uglyf("%d items in chrom %s\n", slCount(list), chrom); }
void loadFaSeq(struct hash *faHash, char *newName, char strand, char **pName, struct dnaSeq **pSeq, char *pStrand) /* retrieve sequence from hash. Reverse complement * if necessary. */ { struct dnaSeq *seq; if (sameString(newName, *pName)) { if (strand != *pStrand) { seq = *pSeq; reverseComplement(seq->dna, seq->size); *pStrand = strand; } } else { char fileName[512]; *pName = newName; *pSeq = seq = hashFindVal(faHash, newName); *pStrand = strand; if (strand == '-') reverseComplement(seq->dna, seq->size); uglyf("Loaded %d bases from %s fa\n", seq->size, newName); } }
void splitSim(char *XXX) /* splitSim - Simulate gapless distribution size. */ { int splitCount = simSize / aveSize; bool *splitBuf = needMem(simSize+1); int start = 0, size; int i; uglyf("split count %d\n", splitCount); for (i=0; i<splitCount; ++i) { for (;;) { int rPos = random()%simSize; if (splitBuf[rPos] == 0) { splitBuf[rPos] = 1; break; } } } splitBuf[simSize] = 1; start = 0; for (i=0; i<=simSize; ++i) { if (splitBuf[i]) { size = i - start; if (size < countCount) counts[size] += 1; start = i; } } for (i=0; i<countCount; ++i) printf("%3d %6d\n", i, counts[i]); }
int main(int argc, char *argv[]) { char *rerunDir = "/projects/cc/hg/gs.2/g2g/g2g.fix"; FILE *f = mustOpen("/projects/cc/hg/gs.2/g2g/g2g.fix/makeFix.con", "w"); char *inName = "/projects/cc/hg/gs.2/g2g/miss.txt"; struct lineFile *lf = lineFileOpen(inName, TRUE); int wordCount, lineSize, len; char *line, *words[16]; char *a, *b; char *s; char both[32]; while (lineFileNext(lf, &line, &lineSize)) { s = strchr(line, ':'); if (s == NULL) continue; *s = 0; a = line; b = strchr(a, '_'); if (b == NULL) errAbort("Expecting '_' in first word line %d of %s", lf->lineIx, lf->fileName); *b++ = 0; sprintf(both, "%s_%s", a, b); uglyf("Processing %s\n", both); fprintf(f, "log = %s/log/%s\n", rerunDir, both); fprintf(f, "error = %s/err/%s\n", rerunDir, both); fprintf(f, "output = %s/out/%s\n", rerunDir, both); fprintf(f, "arguments = in/%s in/%s g2g /var/tmp/hg/h/11.ooc %s/psl/%s.psl\n", a, b, rerunDir, both); fprintf(f, "queue 1\n\n"); } }
void loadIfNewSeq(char *nibDir, char *newName, char strand, char **pName, struct dnaSeq **pSeq, char *pStrand) /* Load sequence unless it is already loaded. Reverse complement * if necessary. */ { struct dnaSeq *seq; if (sameString(newName, *pName)) { if (strand != *pStrand) { seq = *pSeq; reverseComplement(seq->dna, seq->size); *pStrand = strand; } } else { char fileName[512]; freeDnaSeq(pSeq); snprintf(fileName, sizeof(fileName), "%s/%s.nib", nibDir, newName); *pName = newName; *pSeq = seq = nibLoadAllMasked(NIB_MASK_MIXED, fileName); *pStrand = strand; if (strand == '-') reverseComplement(seq->dna, seq->size); uglyf("Loaded %d bases in %s\n", seq->size, fileName); } }
void fakeChromLinkage(char *database, char *chrom, FILE *f) /* Generate fake linkage data for one chromosome */ { int size = hdbChromSize(database, chrom); int stepSize = 5000000; int pos; uglyf("faking %s %d\n", chrom, size); struct sqlConnection *conn = hAllocConn(); for (pos=0; pos<size; pos += stepSize) { int rowOffset = 0; char query[512]; sqlSafef(query, sizeof(query), "select name from stsMap where chrom='%s' and chromStart >= %d && chromStart < %d", chrom, pos, pos+stepSize); struct sqlResult *sr = sqlGetResult(conn, query); char **row = sqlNextRow(sr); if (row != NULL) { double x; if (rand()%250 == 0) { x = 3.5 + (double)rand()/RAND_MAX; } else { x = (double)rand() / RAND_MAX + 0.001; x = log(x) + 1; if (x < -1) x = -1; } fprintf(f, "%s\t%f\n", row[0], x); } sqlFreeResult(&sr); } hFreeConn(&conn); }
static void getCloneDna(struct clone *clone, struct hash *fragHash) /* Read in clone DNA from file in format with one record per * clone contig. Make clone->dna so that it is same as * non-fragmented clone file. */ { struct dnaSeq *seqList = faReadAllDna(clone->faFile), *seq; int fragSize; clone->dna = needLargeMem(clone->size+1); clone->dna[clone->size] = 0; uglyf("GetCloneDna %s\n", clone->faFile); for (seq = seqList; seq != NULL; seq = seq->next) { struct frag *frag = hashFindVal(fragHash, seq->name); if (frag == NULL) errAbort("Couldn't find %s from %s in trans files", seq->name, clone->faFile); assert(frag->end <= clone->size); fragSize = frag->end - frag->start; assert(fragSize >= 0); if (fragSize != seq->size) errAbort("Size mismatch (%d vs %d) between trans and .ffa files on %s", fragSize, seq->size, frag->name); memcpy(clone->dna + frag->start, seq->dna, fragSize); } freeDnaSeqList(&seqList); }
void doItPromoterBed(struct inInfo *in, struct bed *chiaList, double *out1, double *out2) /* Process overlaps with promoters defined by a gene bed file. */ { struct genomeRangeTree *grt = grtFromOpenBed(in->lf, 12, TRUE); outputOverlappingGrt(chiaList, grt, out1, out2); uglyf("done %s\n", in->fileName); }
void testDbSorts(struct htmlPage *dbPage, char *org, char *db, char *accColumn, struct slName *geneList) /* Test on one database. */ { struct htmlPage *emptyConfig; struct htmlFormVar *sortVar = htmlFormVarGet(dbPage->forms, orderVarName); struct slName *gene, *sort; uglyf("testDbSorts %s %s\n", org, db); if (sortVar == NULL) errAbort("Couldn't find var %s", orderVarName); emptyConfig = emptyConfigPage(dbPage, org, db); if (emptyConfig != NULL) { for (sort = sortVar->values; sort != NULL; sort= sort->next) { for (gene = geneList; gene != NULL; gene = gene->next) { testSort(emptyConfig, org, db, sort->name, gene->name, accColumn); } } htmlPageFree(&emptyConfig); } }
char *cellAbbreviation(char *cell) /* Return abbreviated version of cell-name */ { if (cellLetterHash == NULL) return cellAbbrevDefault(cell, FALSE); if (noLetterOk) { // strip qualifiers (follow the '+' char) char *plus = stringIn("+", cell); if (plus) *plus = 0; } char *val = hashFindVal(cellLetterHash, cell); if (val != NULL) return val; if (noLetterOk) return cellAbbrevDefault(cell, TRUE); if (noLetter) uglyf("cell %s isn't in %s\n", cell, cellLetter); else errAbort("cell %s isn't in %s\n", cell, cellLetter); return NULL; }
struct fullExperiment *getGoodExperiments(struct sqlConnection *conn, struct edwExperiment *eeList, char *assembly) /* Get list of experiments that are good in the sense of being replicated and having * bam,broadPeak and so forth all from hotspot in the same run */ { uglyf("Got %d on eeList\n", slCount(eeList)); struct fullExperiment *fullList = getFullExperimentList(conn, eeList, assembly, NULL); uglyf("Got %d on fullList\n", slCount(fullList)); int replicatedCount = 0, goodCount = 0, goodIndividualRepCount = 0, totalRepCount = 0; struct fullExperiment *full, *next, *goodList = NULL, *badList = NULL; for (full = fullList; full != NULL; full = next) { next = full->next; int repCount = slCount(full->repList); totalRepCount += repCount; if (repCount > 0) { uglyf("%s %d\n", full->exp->accession, repCount); if (repCount > 1) ++replicatedCount; int goodRepCount = 0; struct replicate *r; for (r = full->repList; r != NULL; r = r->next) { if (replicateIsComplete(conn, r)) { ++goodRepCount; ++goodIndividualRepCount; } } if (goodRepCount >= 2) { ++goodCount; slAddHead(&goodList, full); } else slAddHead(&badList, full); } } slReverse(&goodList); uglyf("%d replicates %d are good\n", totalRepCount, goodIndividualRepCount); uglyf("%d replicated experiments, %d of which look good\n", replicatedCount, goodCount); return goodList; }
void chopFaLines(char *inName, char *outName) /* chopFaLines - Read in FA file with long lines and rewrite it with shorter lines. */ { FILE *in = mustOpen(inName, "r"); FILE *out = mustOpen(outName, "w"); char *commentLine; struct dnaSeq *seq; while (faReadNext(in, NULL, TRUE, &commentLine, &seq)) { commentLine = trimSpaces(commentLine+1); uglyf(">%s\n", commentLine); mustWrite(uglyOut, seq->dna, 100); uglyf("\n"); uglyAbort("All for now"); faWriteNext(out, commentLine, seq->dna, seq->size); } }
double paranoidSqrt(double x) /* There seems to be a bug in MS's square-root that enclosing it in * a subroutine avoids. */ { double y = sqrt(x); if (fabs(y*y - x) > 0.001) uglyf("sqrt(%f) = %f !?? \n", x, y); return y; }
void setupHugeGaps(char *insertFile) /* Setup things to lookup gaps. */ { struct lineFile *lf; char *words[8]; int wordCount; struct chromGaps *chromList = NULL, *cg; struct hugeGap *gap; char *chrom; char query[512]; struct sqlResult *sr; char **row; struct ctgPos ctgPos; int start, size; struct hashEl *hel; struct sqlConnection *conn = sqlConnect("hg4"); hugeHash = newHash(6); lf = lineFileOpen(insertFile, TRUE); while ((wordCount = lineFileChop(lf, words)) != 0) { chrom = words[0]; if (sameString(words[2], "-")) continue; if ((cg = hashFindVal(hugeHash, chrom)) == NULL) { AllocVar(cg); slAddHead(&chromList, cg); hel = hashAdd(hugeHash, chrom, cg); cg->chrom = hel->name; } size = atoi(words[3]); sqlSafef(query, sizeof query, "select * from ctgPos where contig = '%s'", words[2]); sr = sqlGetResult(conn, query); if ((row = sqlNextRow(sr)) == NULL) errAbort("Couldn't find %s from %s in database", words[2], lf->fileName); ctgPosStaticLoad(row, &ctgPos); if (!sameString(chrom, ctgPos.chrom)) errAbort("%s is in %s in database and %s in %s", ctgPos.contig, ctgPos.chrom, chrom, lf->fileName); start = ctgPos.chromStart; uglyf("%s %s (%d size %d) %s \n", chrom, words[1], start, size, words[2]); sqlFreeResult(&sr); AllocVar(gap); slAddHead(&cg->gapList, gap); gap->offset = start; gap->size = size; } lineFileClose(&lf); sqlDisconnect(&conn); for (cg = chromList; cg != NULL; cg = cg->next) { slSort(&cg->gapList, cmpHugeGap); } }
struct hash *hashPsls(char *fileName) /* Return hash of all psls in file. */ { struct psl *pslList = pslLoadAll(fileName), *psl; struct hash *hash = newHash(20); for (psl = pslList; psl != NULL; psl = psl->next) hashAdd(hash, psl->qName, psl); uglyf("Loaded %d psls from %s\n", slCount(pslList), fileName); return hash; }
void constraintsForBac(char *bacAcc, char *outDir) /* Generate a set of constraint files for bac. */ { struct ggMrnaInput *ci = ggGetMrnaForBac(bacAcc); struct ggMrnaCluster *mc, *mcList = ggClusterMrna(ci); struct geneGraph *gg; uglyf("Got %d clusters\n", slCount(mcList)); for (mc = mcList; mc != NULL; mc = mc->next) { uglyf("Initial input\n"); dumpMc(mc); uglyf("\n"); gg = ggGraphCluster(mc, ci); uglyf("Constraints\n"); traverseGeneGraph(gg, mc->tStart, mc->tEnd, dumpGgAliInfo); uglyf("\n\n"); } }
struct memGfx *getScaledMg(int bases, int height) /* Allocate a memGfx big enough for bases. */ { int width = baseToDot(bases); struct memGfx *mg; uglyf("Allocatting memory graphic of %d x %d (for %d bases)\n", width, height, bases); mg = mgNew(width, height); mgClearPixels(mg); return mg; }
void gifTest() { static char *labels[] = {"cerebellum", "thymus", "breast", "heart", "stomach", "cartilage", "kidney", "liver", "lung", "testis", "black hole" }; int size = gifLabelMaxWidth(labels, ArraySize(labels)); int gifLabelMaxWidth(char **labels, int labelCount) gifLabelVerticalText("../trash/foo.gif", labels, ArraySize(labels), size); uglyf("<IMG SRC=\"../trash/foo.gif\">"); }
void spanRaft(char *spanFile, char *raftFile, char *outFile) /* spanRaft - combine James Gilbert's phrap derived * .span files with ooGreedy raft files ease comparison. */ { struct span *spanList = NULL, *span; struct spanFrag *sf; struct raft *raftList = NULL, *raft; struct raftFrag *rf; struct hash *fragHash = newHash(0); spanList = readSpanFile(spanFile); printf("Got %d spans\n", slCount(spanList)); raftList = readRaftFile(raftFile); printf("Got %d rafts\n", slCount(raftList)); printf("Got %d non-singleton rafts\n", multiRaftCount(raftList)); matchFrags(raftList, spanList, fragHash); uglyf("Matched frags\n"); writeFrags(raftList, spanList, outFile); uglyf("All done\n"); }
void printListVals(struct sageCounts *scList, int index) { struct sageCounts *sc = NULL; struct sortable *s=NULL, *sList = NULL, *next = NULL; for(sc = scList; sc != NULL; sc = sc->next) { AllocVar(s); s->val = sc->expCounts[index]; slAddHead(&sList,s); } slSort(&sList,compSortable); for(s = sList; s!= NULL; s=s->next) uglyf("%d,",s->val); uglyf("\n"); for(s=sList; s != NULL; s = next) { next = s->next; freez(&s); } }