static struct hash *getChromHash(char *db)
/* Return a hash of chrom names and sizes, from either -chromSize=file or db */
{
struct hash *chromHash = NULL;
if (chromSizes != NULL)
chromHash = hChromSizeHashFromFile(chromSizes);
else
chromHash = hChromSizeHash(db);
return chromHash;
}
static struct chromSize *getChromsFromSpecs(char *db, struct slName *specs)
/* build chromSizes from results of */
{
struct hash *chrTbl = hChromSizeHash(db);
struct chromSize *chroms = NULL;
struct slName *spec;
for (spec = specs; spec != NULL; spec = spec->next)
slSafeAddHead(&chroms, chromSizeNew(spec->name, hashIntVal(chrTbl, spec->name)));
hashFree(&chrTbl);
return chroms;
}
static struct chromSize *getAllChroms(char *db)
/* get list of all chroms */
{
struct chromSize *chroms = NULL;
struct hash *chrTbl = hChromSizeHash(db);
struct hashCookie ck = hashFirst(chrTbl);
struct hashEl *hel;
while ((hel = hashNext(&ck)) != NULL)
slSafeAddHead(&chroms, chromSizeNew(hel->name, ptToInt(hel->val)));
hashFree(&chrTbl);
return chroms;
}
void checkCoverageGaps(char *database, int trackCount, char *tracks[])
/* checkCoverageGaps - Check for biggest gap in coverage for a list of tracks.. */
{
struct slName *chromList = hChromList(database);
struct hash *chromHash = hChromSizeHash(database);
struct sqlConnection *conn = sqlConnect(database);
int i;
printf("#table\tbiggest gap position \tbiggest gap size\n");
for (i=0; i<trackCount; ++i)
{
char *track = tracks[i];
printBiggestGap(database, conn, chromList, chromHash, track);
}
sqlDisconnect(&conn);
}
static struct mafAli *mafOrAxtLoadInRegion2(struct sqlConnection *conn,struct sqlConnection *conn2,
struct trackDb *tdb, char *chrom, int start, int end,
char *axtOtherDb, char *file)
{
if (axtOtherDb != NULL)
{
struct hash *qSizeHash = hChromSizeHash(axtOtherDb);
struct mafAli *mafList = axtLoadAsMafInRegion(conn, tdb->table,
chrom, start, end, database, axtOtherDb, hChromSize(database, chrom), qSizeHash);
hashFree(&qSizeHash);
return mafList;
}
else
return mafLoadInRegion2(conn, conn2, tdb->table, chrom,
start, end, file);
}
static struct chromSize *getLongestChrom(char *db)
/* find the longest chrom */
{
struct hash *chrTbl = hChromSizeHash(db);
char *maxChrom = NULL;;
int maxSize = 0;
struct hashCookie ck = hashFirst(chrTbl);
struct hashEl *hel;
while ((hel = hashNext(&ck)) != NULL)
{
if (ptToInt(hel->val) > maxSize)
{
maxChrom = hel->name;
maxSize = ptToInt(hel->val);
}
}
hashFree(&chrTbl);
return chromSizeNew(maxChrom, maxSize);
}
void mafSplitPos(char *database, char *size, char *outFile)
/* Pick best positions for split close to size.
* Use middle of a gap as preferred site.
* If not gaps are in range, use recent repeats (0% diverged) */
{
int splitSize = 0;
int chromSize = 0;
struct hash *chromHash;
struct hashCookie hc;
struct hashEl *hel;
struct sqlConnection *conn = sqlConnect(database);
FILE *f;
db = database;
verbose(1, "Finding split positions for %s at ~%s Mbp intervals\n",
database, size);
splitSize = sqlSigned(size) * 1000000;
if (chrom == NULL)
{
chromHash = hChromSizeHash(database);
}
else
{
chromHash = hashNew(6);
hashAddInt(chromHash, chrom, hChromSize(database, chrom));
}
conn = sqlConnect(database);
f = mustOpen(outFile, "w");
hc = hashFirst(chromHash);
while ((hel = hashNext(&hc)) != NULL)
{
chrom = hel->name;
chromSize = ptToInt(hel->val);
chromSplits(chrom, chromSize, splitSize, conn, f);
}
sqlDisconnect(&conn);
carefulClose(&f);
}
