lib/nt4.c File Reference

#include "common.h"
#include "dnautil.h"
#include "shaRes.h"
#include "dnaseq.h"
#include "nt4.h"
#include "sig.h"

Include dependency graph for nt4.c:

Go to the source code of this file.

Functions
static size_t	bits32PaddedSize (size_t size)
static struct nt4Seq *	allocNt4 (size_t baseCount, char *name)
nt4Seq *	newNt4 (DNA *dna, int size, char *name)
void	freeNt4 (struct nt4Seq **pSeq)
static FILE *	nt4OpenVerify (char *fileName)
nt4Seq *	loadNt4 (char *fileName, char *seqName)
void	saveNt4 (char *fileName, DNA *dna, bits32 dnaSize)
int	nt4BaseCount (char *fileName)
static void	unpackRightSide (bits32 tile, int baseCount, DNA *out)
static void	unpackLeftSide (bits32 tile, int baseCount, DNA *out)
static void	unpackMidWord (bits32 tile, int startBase, int baseCount, DNA *out)
void	unalignedUnpackDna (bits32 *tiles, int start, int size, DNA *unpacked)
DNA *	nt4Unpack (struct nt4Seq *n, int start, int size)
DNA *	nt4LoadPart (char *fileName, int start, int size)
Variables
static char const	rcsid [] = "$Id: nt4.c,v 1.5 2005/04/10 14:41:24 markd Exp $"

---

Function Documentation

static struct nt4Seq* allocNt4	(	size_t	baseCount,
		char *	name
	)			[static, read]

Definition at line 20 of file nt4.c.

References bits32PaddedSize(), cloneString(), needLargeMem(), and needMem().

Referenced by loadNt4(), and newNt4().

{
size_t memSize = bits32PaddedSize(baseCount);
struct nt4Seq *seq = needMem(sizeof(*seq));
seq->baseCount = baseCount;
seq->bases = needLargeMem(memSize);
seq->name = cloneString(name);
return seq;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static size_t bits32PaddedSize

(

size_t

size

)

[static]

Definition at line 15 of file nt4.c.

Referenced by allocNt4(), and loadNt4().

{
    return (((size+15)>>4)<<2);
}

Here is the caller graph for this function:

void freeNt4

(

struct nt4Seq **

pSeq

)

Definition at line 55 of file nt4.c.

References nt4Seq::bases, freeMem(), freez(), and nt4Seq::name.

Referenced by flyFreeNt4Genome(), wormFreeNt4Genome(), and xenAlignBig().

{
struct nt4Seq *seq = *pSeq;
if (seq == NULL)
    return;
freeMem(seq->bases);
freeMem(seq->name);
freez(pSeq);
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct nt4Seq* loadNt4	(	char *	fileName,
		char *	seqName
	)			[read]

Definition at line 78 of file nt4.c.

References allocNt4(), nt4Seq::bases, bits32, bits32PaddedSize(), carefulClose(), mustRead(), mustReadOne, and nt4OpenVerify().

Referenced by flyLoadNt4Genome(), and wormLoadNt4Genome().

{
bits32 size;
struct nt4Seq *seq;
FILE *f = nt4OpenVerify(fileName);

mustReadOne(f, size);
if (seqName == NULL)
    seqName = fileName;
seq = allocNt4(size, seqName);
mustRead(f, seq->bases, bits32PaddedSize(size));
carefulClose(&f);
return seq;
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct nt4Seq* newNt4	(	DNA *	dna,
		int	size,
		char *	name
	)			[read]

Definition at line 32 of file nt4.c.

References allocNt4(), nt4Seq::bases, bits32, and packDna16().

Referenced by xenAlignBig().

{
bits32 *packed;
DNA *unpacked;
char last[16];
struct nt4Seq *seq = allocNt4(size, name);
packed = seq->bases;
unpacked = dna;
while (size > 16)
    {
    *packed++ = packDna16(dna);
    dna += 16;
    size -= 16;
    }
if (size > 0)
    {
    memcpy(last, dna, size);
    *packed++ = packDna16(dna);
    }
return seq;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int nt4BaseCount

(

char *

fileName

)

Definition at line 121 of file nt4.c.

References bits32, mustReadOne, and nt4OpenVerify().

Referenced by wormChromSize().

{
bits32 size;
FILE *f = nt4OpenVerify(fileName);

mustReadOne(f, size);
fclose(f);
return (int)size;
}

Here is the call graph for this function:

Here is the caller graph for this function:

DNA* nt4LoadPart	(	char *	fileName,
		int	start,
		int	size
	)

Definition at line 226 of file nt4.c.

References bits32, freeMem(), mustRead(), mustReadOne, needLargeMem(), nt4OpenVerify(), SEEK_CUR, and unalignedUnpackDna().

Referenced by wormChromPart().

{
bits32 basesInFile;
int tStart, tEnd, tSize;
int end;
FILE *f;
DNA *unpacked;
bits32 *tiles;

/* Open file, and make sure request is covered by file. */
f = nt4OpenVerify(fileName);
mustReadOne(f, basesInFile);

assert(start >= 0);
end = start + size;
assert(end <= (int)basesInFile);

/* Figure out tiles to load */
tStart = (start>>4);
tEnd = ((end+15)>>4);
tSize = tEnd - tStart;

/* Allocate tile array and read it from disk. */
tiles = needLargeMem(tSize * sizeof(*tiles));
fseek(f, tStart * sizeof(*tiles), SEEK_CUR);
mustRead(f, tiles, tSize * sizeof(*tiles) );

/* Allocate and unpack array. */
unpacked = needLargeMem(size+1);
unalignedUnpackDna(tiles, start - (tStart<<4), size, unpacked);

freeMem(tiles);
fclose(f);
return unpacked;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static FILE* nt4OpenVerify

(

char *

fileName

)

[static]

Definition at line 66 of file nt4.c.

References bits32, errAbort(), mustOpen(), mustReadOne, and nt4Signature.

Referenced by loadNt4(), nt4BaseCount(), and nt4LoadPart().

{
FILE *f = mustOpen(fileName, "rb");
bits32 signature;
mustReadOne(f, signature);
if (signature != nt4Signature)
    errAbort("%s is not a good Nt4 file", fileName);
return f;
}

Here is the call graph for this function:

Here is the caller graph for this function:

DNA* nt4Unpack	(	struct nt4Seq *	n,
		int	start,
		int	size
	)

Definition at line 217 of file nt4.c.

References nt4Seq::bases, needLargeMem(), and unalignedUnpackDna().

Referenced by scoreNoninsertingExtensions().

{
DNA *unpacked = needLargeMem(size+1);
unalignedUnpackDna(n->bases, start, size, unpacked);
return unpacked;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void saveNt4	(	char *	fileName,
		DNA *	dna,
		bits32	dnaSize
	)

Definition at line 94 of file nt4.c.

References nt4Seq::bases, bits32, mustOpen(), nt4Signature, packDna16(), writeOne, and zeroBytes().

{
FILE *f = mustOpen(fileName, "wb");
bits32 signature = nt4Signature;
bits32 bases;
char last[16];

writeOne(f, signature);
writeOne(f, dnaSize);
while (dnaSize >= 16)
    {
    bases = packDna16(dna);
    writeOne(f, bases);
    dna += 16;
    dnaSize -= 16;
    }
if (dnaSize > 0)
    {
    zeroBytes(last, sizeof(last));
    memcpy(last, dna, dnaSize);
    bases = packDna16(last);
    writeOne(f, bases);
    }
fclose(f);
}

Here is the call graph for this function:

void unalignedUnpackDna	(	bits32 *	tiles,
		int	start,
		int	size,
		DNA *	unpacked
	)

Definition at line 169 of file nt4.c.

References bits32, dnaUtilOpen(), unpackDna(), unpackLeftSide(), unpackMidWord(), and unpackRightSide().

Referenced by nt4LoadPart(), and nt4Unpack().

{
DNA *pt = unpacked;
int sizeLeft = size;
int firstBases, middleBases;
bits32 *startTile, *endTile;

dnaUtilOpen();

/* See if all data is in a single word. */
startTile = tiles + (start>>4);
endTile = tiles + ((start + size - 1)>>4);
if (startTile == endTile)
    {
    unpackMidWord(*startTile, start&0xf, size, unpacked);
    return;
    }

/* Skip over initial stuff. */
tiles = startTile;

/* See if just have one tile to 
 * Unpack the right hand side of the first tile. */
firstBases = (16 - (start&0xf));
unpackRightSide(*tiles, firstBases, pt);
pt += firstBases;
sizeLeft -= firstBases;
tiles += 1;

/* Unpack all of the middle tiles. */
middleBases = (sizeLeft&0x7ffffff0);
unpackDna(tiles, middleBases>>4, pt);
pt += middleBases;
sizeLeft -= middleBases;
tiles += (middleBases>>4);

/* Unpack the left side of last tile. */
if (sizeLeft > 0)
    unpackLeftSide(*tiles, sizeLeft, pt);
pt += sizeLeft;

/* Add trailing zero to make it a DNA string. */
assert(pt == unpacked+size);
*pt = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void unpackLeftSide	(	bits32	tile,
		int	baseCount,
		DNA *	out
	)			[static]

Definition at line 144 of file nt4.c.

References valToNt.

Referenced by unalignedUnpackDna().

{
int bitsToDump = ((16-baseCount)<<1);
tile >>= bitsToDump;
out += baseCount;
while (--baseCount >= 0)
    {
    *--out = valToNt[tile&0x3];
    tile >>= 2;
    }
}

Here is the caller graph for this function:

static void unpackMidWord	(	bits32	tile,
		int	startBase,
		int	baseCount,
		DNA *	out
	)			[static]

Definition at line 157 of file nt4.c.

References valToNt.

Referenced by unalignedUnpackDna().

{
tile >>= ((16-startBase-baseCount)<<1);
out += baseCount;
while (--baseCount >= 0)
    {
    *--out = valToNt[tile&0x3];
    tile >>= 2;
    }
}

Here is the caller graph for this function:

static void unpackRightSide	(	bits32	tile,
		int	baseCount,
		DNA *	out
	)			[static]

Definition at line 132 of file nt4.c.

References valToNt.

Referenced by unalignedUnpackDna().

{
int j;

for (j=baseCount; --j>=0; )
    {
    out[j] = valToNt[tile & 0x3];
    tile >>= 2;
    }
}

Here is the caller graph for this function:

---

Variable Documentation

char const rcsid[] = "$Id: nt4.c,v 1.5 2005/04/10 14:41:24 markd Exp $" [static]

Definition at line 13 of file nt4.c.

---