Exemplo n.º 1
0
int ffCalcCdnaGapPenalty(int hGap, int nGap)
/* Return gap penalty for given h and n gaps. */
{
int acc = 2;
if (hGap > 400000)	/* Discourage really long introns. */
    {
    acc += (hGap - 400000)/3000;
    if (hGap > ffIntronMax)
        acc += (hGap - ffIntronMax)/2000;
    }
if (hGap < 0)   /* Discourage jumping back in haystack. */
    {
    hGap = -8*hGap;
    if (hGap > 48)
        hGap = (hGap*hGap);
    }
if (nGap < 0)   /* Jumping back in needle gets rid of previous alignment. */
    {
    acc += -nGap;
    nGap = 0;
    }
acc += digitsBaseTwo(hGap)/2;
if (nGap != 0)
    {
    acc += digitsBaseTwo(nGap);
    }
else
    {
    if (hGap > 30)
	acc -= 1;
    }
return acc;
}
Exemplo n.º 2
0
struct hashEl *hashAddN(struct hash *hash, char *name, int nameSize, void *val)
/* Add name of given size to hash (no need to be zero terminated) */
{
struct hashEl *el;
if (hash->lm) 
    el = lmAlloc(hash->lm, sizeof(*el));
else
    AllocVar(el);
el->hashVal = hashString(name);
int hashVal = el->hashVal & hash->mask;
if (hash->lm)
    {
    el->name = lmAlloc(hash->lm, nameSize+1);
    memcpy(el->name, name, nameSize);
    }
else
    el->name = cloneStringZ(name, nameSize);
el->val = val;
el->next = hash->table[hashVal];
hash->table[hashVal] = el;
hash->elCount += 1;
if (hash->autoExpand && hash->elCount > (int)(hash->size * hash->expansionFactor))
    {
    /* double the size */
    hashResize(hash, digitsBaseTwo(hash->size));
    }
return el;
}
Exemplo n.º 3
0
struct hash *hashSizedForTable(struct sqlConnection *conn, char *table)
/* Return a hash sized appropriately to hold all of table. */
{
    char query[256];
    int tableSize;
    sqlSafef(query, sizeof(query), "select count(*) from %s", table);
    tableSize = sqlQuickNum(conn, query);
    printf("%s has %d rows\n", table, tableSize);
    return newHash(digitsBaseTwo(tableSize) + 1);
}
Exemplo n.º 4
0
struct hash *dnaSeqHash(struct dnaSeq *seqList)
/* Return hash of sequences keyed by name. */
{
int size = slCount(seqList)+1;
int sizeLog2 = digitsBaseTwo(size);
struct hash *hash = hashNew(sizeLog2);
struct dnaSeq *seq;
for (seq = seqList; seq != NULL; seq = seq->next)
    hashAddUnique(hash, seq->name, seq);
return hash;
}
Exemplo n.º 5
0
int gapPenalty(struct ffAli *left, struct ffAli *ali)
/* Calculate gap penalty using exon scoring. */
{
int nGap, hGap;
int minGap;

nGap = ali->nStart - left->nEnd;
assert(nGap >= 0);
hGap = ali->hStart - left->hStart;
if (hGap < 0)       
    {
    hGap = 0;
    nGap -= hGap;
    }
minGap = (nGap < hGap ? nGap : hGap);
return (2 + digitsBaseTwo(hGap+minGap) + (nGap-minGap));
}
Exemplo n.º 6
0
uint annoAssemblySeqSize(struct annoAssembly *aa, char *seqName)
/* Return the number of bases in seq which must be in aa's twoBitFile. */
{
if (aa->seqSizes == NULL)
    aa->seqSizes = hashNew(digitsBaseTwo(aa->tbf->seqCount));
struct hashEl *hel = hashLookup(aa->seqSizes, seqName);
uint seqSize;
if (hel != NULL)
    seqSize = (uint)(hel->val - NULL);
else
    {
    seqSize = (uint)twoBitSeqSize(aa->tbf, seqName);
    char *pt = NULL;
    hashAdd(aa->seqSizes, seqName, pt + seqSize);
    }
return seqSize;
}
struct hash *hashKeyField(struct joinedTables *joined, int keyIx,
                          struct joinerField *jf)
/* Make a hash based on key field. */
{
    int hashSize = digitsBaseTwo(joined->rowCount);
    struct hash *hash = NULL;
    struct joinedRow *jr;

    if (hashSize > 20)
        hashSize = 20;
    hash = newHash(hashSize);
    for (jr = joined->rowList; jr != NULL; jr = jr->next)
    {
        struct slName *key;
        for (key = jr->keys[keyIx]; key != NULL; key = key->next)
        {
            if (jf->separator == NULL)
            {
                char *s = chopKey(jf->chopBefore, jf->chopAfter, key->name);
                if (s[0] != 0)
                    hashAdd(hash, s, jr);
            }
            else
            {
                char *s = key->name, *e;
                char sep = jf->separator[0];
                while (s != NULL && s[0] != 0)
                {
                    e = strchr(s, sep);
                    if (e != NULL)
                        *e++ = 0;
                    s = chopKey(jf->chopBefore, jf->chopAfter, s);
                    if (s[0] != 0)
                        hashAdd(hash, s, jr);
                    s = e;
                }
            }
        }
    }
    return hash;
}
struct hash *readKeyHash(char *db, struct joiner *joiner,
                         struct joinerField *keyField, struct keyHitInfo **retList)
/* Read key-field into hash.  Check for dupes if need be. */
{
    struct sqlConnection *conn = sqlWarnConnect(db);
    struct hash *keyHash = NULL;
    struct keyHitInfo *khiList = NULL, *khi;
    if (conn == NULL)
    {
        return NULL;
    }
    else
    {
        struct slName *table;
        struct slName *tableList = getTablesForField(conn,keyField->splitPrefix,
                                   keyField->table,
                                   keyField->splitSuffix);
        int rowCount = totalTableRows(conn, tableList);
        int hashSize = digitsBaseTwo(rowCount)+1;
        char query[256], **row;
        struct sqlResult *sr;
        int itemCount = 0;
        int dupeCount = 0;
        char *dupe = NULL;

        if (rowCount > 0)
        {
            if (hashSize > hashMaxSize)
                hashSize = hashMaxSize;
            keyHash = hashNew(hashSize);
            for (table = tableList; table != NULL; table = table->next)
            {
                safef(query, sizeof(query), "select %s from %s",
                      keyField->field, table->name);
                sr = sqlGetResult(conn, query);
                while ((row = sqlNextRow(sr)) != NULL)
                {
                    char *id = doChopsAndUpper(keyField, row[0]);
                    if (hashLookup(keyHash, id))
                    {
                        if (keyField->unique)
                        {
                            if (keyField->exclude == NULL ||
                                    !slNameInList(keyField->exclude, id))
                            {
                                if (dupeCount == 0)
                                    dupe = cloneString(id);
                                ++dupeCount;
                            }
                        }
                    }
                    else
                    {
                        AllocVar(khi);
                        hashAddSaveName(keyHash, id, khi, &khi->name);
                        slAddHead(&khiList, khi);
                        ++itemCount;
                    }
                }
                sqlFreeResult(&sr);
            }
            if (dupe != NULL)
            {
                warn("Error: %d duplicates in %s.%s.%s including '%s'",
                     dupeCount, db, keyField->table, keyField->field, dupe);
                freez(&dupe);
            }
            verbose(2, " %s.%s.%s - %d unique identifiers\n",
                    db, keyField->table, keyField->field, itemCount);
        }
        slFreeList(&tableList);
    }
    sqlDisconnect(&conn);
    *retList = khiList;
    return keyHash;
}