static int read_DB(DAZZ_DB *block, char *name, int kmer)
{ int i, isdam;
isdam = Open_DB(name,block);
if (isdam < 0)
Clean_Exit(1);
Trim_DB(block);
if (block->cutoff < kmer)
{ for (i = 0; i < block->nreads; i++)
if (block->reads[i].rlen < kmer)
{ fprintf(stderr,"%s: Block %s contains reads < %dbp long ! Run DBsplit.\n",
Prog_Name,name,kmer);
Clean_Exit(1);
}
}
Read_All_Sequences(block,0);
return (isdam);
}
static char *CommandBuffer(char *aname, char *bname, char *spath)
{ static char *cat = NULL;
static int max = -1;
int len;
len = 2*(strlen(aname) + strlen(bname) + strlen(spath)) + 200;
if (len > max)
{ max = ((int) (1.2*len)) + 100;
if ((cat = (char *) realloc(cat,max+1)) == NULL)
{ fprintf(stderr,"%s: Out of memory (Making path name)\n",Prog_Name);
Clean_Exit(1);
}
}
return (cat);
}
void * Safe_realloc
(void * q, size_t len, const char * src_fname, size_t line_num)
// Reallocate memory for q to len bytes and return a
// pointer to the new memory. If fail, print a message and exit,
// assuming the call came from source file src_fname at line line_num .
{
char Clean_Exit_Msg_Line [MAX_ERROR_MSG_LEN];
void * p;
p = realloc (q, len);
if (p == NULL)
{
sprintf (Clean_Exit_Msg_Line,
"ERROR: realloc failed %lu bytes",
(long unsigned) (len));
Clean_Exit (Clean_Exit_Msg_Line, src_fname, line_num);
}
return p;
}
void * Safe_malloc
(size_t len, const char * src_fname, size_t line_num)
// Allocate and return a pointer to len bytes of memory.
// If fail, print a message and exit, assuming the call came from
// source file src_fname at line line_num .
{
void * p;
char Clean_Exit_Msg_Line [MAX_ERROR_MSG_LEN];
p = malloc (len);
if (p == NULL)
{
sprintf (Clean_Exit_Msg_Line,
"ERROR: malloc failed %lu bytes",
(long unsigned) (len));
Clean_Exit (Clean_Exit_Msg_Line, src_fname, line_num);
}
return p;
}
void * Safe_calloc
(size_t n, size_t len, const char * src_fname, size_t line_num)
// Allocate and return a pointer to enough memory to hold an
// array with n entries of len bytes each. All memory is
// cleared to 0. If fail, print a message and exit, assuming the
// call came from source file src_fname at line line_num .
{
void * p;
char Clean_Exit_Msg_Line [MAX_ERROR_MSG_LEN];
p = calloc (n, len);
if (p == NULL)
{
sprintf (Clean_Exit_Msg_Line,
"ERROR: calloc failed %lu x %lu",
(long unsigned) (n), (long unsigned) (len));
Clean_Exit (Clean_Exit_Msg_Line, src_fname, line_num);
}
return p;
}
static DAZZ_DB *complement_DB(DAZZ_DB *block, int inplace)
{ static DAZZ_DB _cblock, *cblock = &_cblock;
int nreads;
DAZZ_READ *reads;
char *seq;
nreads = block->nreads;
reads = block->reads;
if (inplace)
{ seq = (char *) block->bases;
cblock = block;
}
else
{ seq = (char *) Malloc(block->reads[nreads].boff+1,"Allocating dazzler sequence block");
if (seq == NULL)
Clean_Exit(1);
*seq++ = 4;
memmove(seq,block->bases,block->reads[nreads].boff);
*cblock = *block;
cblock->bases = (void *) seq;
cblock->tracks = NULL;
}
{ int i;
float x;
x = cblock->freq[0];
cblock->freq[0] = cblock->freq[3];
cblock->freq[3] = x;
x = cblock->freq[1];
cblock->freq[1] = cblock->freq[2];
cblock->freq[2] = x;
for (i = 0; i < nreads; i++)
complement(seq+reads[i].boff,reads[i].rlen);
}
{ DAZZ_TRACK *src, *trg;
int *data, *tata;
int i, x, rlen;
int64 *tano, *anno;
int64 j, k;
for (src = block->tracks; src != NULL; src = src->next)
{ tano = (int64 *) src->anno;
tata = (int *) src->data;
if (inplace)
{ data = tata;
anno = tano;
trg = src;
}
else
{ data = (int *) Malloc(sizeof(int)*tano[nreads],
"Allocating dazzler interval track data");
anno = (int64 *) Malloc(sizeof(int64)*(nreads+1),
"Allocating dazzler interval track index");
trg = (DAZZ_TRACK *) Malloc(sizeof(DAZZ_TRACK),
"Allocating dazzler interval track header");
if (data == NULL || trg == NULL || anno == NULL)
Clean_Exit(1);
trg->name = Strdup(src->name,"Copying track name");
if (trg->name == NULL)
Clean_Exit(1);
trg->size = 4;
trg->anno = (void *) anno;
trg->data = (void *) data;
trg->next = cblock->tracks;
cblock->tracks = trg;
}
for (i = 0; i < nreads; i++)
{ rlen = reads[i].rlen;
anno[i] = tano[i];
j = tano[i+1]-1;
k = tano[i];
while (k < j)
{ x = tata[j];
data[j--] = rlen - tata[k];
data[k++] = rlen - x;
}
if (k == j)
data[k] = rlen - tata[k];
}
anno[nreads] = tano[nreads];
}
}
return (cblock);
}
static int read_DB(DAZZ_DB *block, char *name, char **mask, int *mstat, int mtop, int kmer)
{ int i, isdam, status, kind, stop;
isdam = Open_DB(name,block);
if (isdam < 0)
Clean_Exit(1);
for (i = 0; i < mtop; i++)
{ status = Check_Track(block,mask[i],&kind);
if (status >= 0)
if (kind == MASK_TRACK)
mstat[i] = 0;
else
{ if (mstat[i] != 0)
mstat[i] = -3;
}
else
{ if (mstat[i] == -2)
mstat[i] = status;
}
if (status == 0 && kind == MASK_TRACK)
Open_Track(block,mask[i]);
}
Trim_DB(block);
stop = 0;
for (i = 0; i < mtop; i++)
{ DAZZ_TRACK *track;
int64 *anno;
int j;
status = Check_Track(block,mask[i],&kind);
if (status < 0 || kind != MASK_TRACK)
continue;
stop += 1;
track = Open_Track(block,mask[i]);
Load_All_Track_Data(track);
anno = (int64 *) (track->anno);
for (j = 0; j <= block->nreads; j++)
anno[j] /= sizeof(int);
}
if (stop > 1)
{ int64 nsize;
DAZZ_TRACK *track;
nsize = merge_size(block,stop);
track = merge_tracks(block,stop,nsize);
while (block->tracks != NULL)
Close_Track(block,block->tracks);
block->tracks = track;
}
if (block->cutoff < kmer)
{ for (i = 0; i < block->nreads; i++)
if (block->reads[i].rlen < kmer)
{ fprintf(stderr,"%s: Block %s contains reads < %dbp long ! Run DBsplit.\n",
Prog_Name,name,kmer);
Clean_Exit(1);
}
}
Load_All_Reads(block,0);
return (isdam);
}
static DAZZ_TRACK *merge_tracks(DAZZ_DB *block, int mtop, int64 nsize)
{ DAZZ_TRACK *ntrack;
Event ev[mtop+1];
Event *heap[mtop+2];
int r, mhalf;
int64 *anno;
int *data;
ntrack = (DAZZ_TRACK *) Malloc(sizeof(DAZZ_TRACK),"Allocating merged track");
if (ntrack == NULL)
Clean_Exit(1);
ntrack->name = Strdup("merge","Allocating merged track");
ntrack->anno = anno = (int64 *) Malloc(sizeof(int64)*(block->nreads+1),"Allocating merged track");
ntrack->data = data = (int *) Malloc(sizeof(int)*nsize,"Allocating merged track");
ntrack->size = sizeof(int);
ntrack->next = NULL;
if (anno == NULL || data == NULL || ntrack->name == NULL)
Clean_Exit(1);
{ DAZZ_TRACK *track;
int i;
track = block->tracks;
for (i = 0; i < mtop; i++)
{ ev[i].ano = ((int *) (track->data)) + ((int64 *) (track->anno))[0];
ev[i].out = 1;
heap[i+1] = ev+i;
track = track->next;
}
ev[mtop].idx = INT32_MAX;
heap[mtop+1] = ev+mtop;
}
mhalf = mtop/2;
nsize = 0;
for (r = 0; r < block->nreads; r++)
{ int i, level, hsize;
DAZZ_TRACK *track;
anno[r] = nsize;
track = block->tracks;
for (i = 0; i < mtop; i++)
{ ev[i].end = ((int *) (track->data)) + ((int64 *) (track->anno))[r+1];
if (ev[i].ano < ev[i].end)
ev[i].idx = *(ev[i].ano);
else
ev[i].idx = INT32_MAX;
track = track->next;
}
hsize = mtop;
for (i = mhalf; i > 1; i--)
reheap(i,heap,hsize);
level = 0;
while (1)
{ Event *p;
reheap(1,heap,hsize);
p = heap[1];
if (p->idx == INT32_MAX) break;
p->out = 1-p->out;
if (p->out)
{ level -= 1;
if (level == 0)
data[nsize++] = p->idx;
}
else
{ if (level == 0)
data[nsize++] = p->idx;
level += 1;
}
p->ano += 1;
if (p->ano >= p->end)
p->idx = INT32_MAX;
else
p->idx = *(p->ano);
}
}
anno[r] = nsize;
return (ntrack);
}
