int main(int argc, char *argv[])
{ HITS_DB _db1, *db1 = &_db1;
HITS_DB _db2, *db2 = &_db2;
int VERBOSE;
int SORTED;
int ISTWO;
// Process options
{ int i, j, k;
int flags[128];
ARG_INIT("LAcheck")
j = 1;
for (i = 1; i < argc; i++)
if (argv[i][0] == '-')
switch (argv[i][1])
{
default:
ARG_FLAGS("vS")
break;
}
else
argv[j++] = argv[i];
argc = j;
VERBOSE = flags['v'];
SORTED = flags['S'];
if (argc <= 2)
{ fprintf(stderr,"Usage: %s %s\n",Prog_Name,Usage);
exit (1);
}
}
int main(int argc, char *argv[])
{ DAZZ_DB db, dbs;
int64 dbpos;
FILE *dbfile, *ixfile;
char *dbfile_name, *ixfile_name;
int status;
int FORCE;
int ALL;
int CUTOFF;
int64 SIZE;
{ int i, j, k;
int flags[128];
char *eptr;
float size;
ARG_INIT("DBsplit")
CUTOFF = 0;
size = 200;
j = 1;
for (i = 1; i < argc; i++)
if (argv[i][0] == '-')
switch (argv[i][1])
{ default:
ARG_FLAGS("af")
break;
case 'x':
ARG_NON_NEGATIVE(CUTOFF,"Min read length cutoff")
break;
case 's':
ARG_REAL(size)
if (size <= 0.)
{ fprintf(stderr,"%s: Block size must be a positive number\n",Prog_Name);
exit (1);
}
break;
}
else
argv[j++] = argv[i];
argc = j;
SIZE = size*1000000ll;
ALL = flags['a'];
FORCE = flags['f'];
if (argc != 2)
{ fprintf(stderr,"Usage: %s %s\n",Prog_Name,Usage);
fprintf(stderr,"\n");
fprintf(stderr," -s: Target size of blocks (in Mbp).\n");
fprintf(stderr," -x: Trimmed DB has reads >= this threshold.\n");
fprintf(stderr," -a: Trimmed DB contains all reads from a well (not just longest).\n");
fprintf(stderr," -f: Force the split to occur even if already split.\n");
exit (1);
}
}
int main(int argc, char *argv[])
{ FILE *istub, *ostub;
char *dbname;
char *root, *pwd;
FILE *bases, *indx;
int64 boff, ioff;
int ifiles, ofiles;
char **flist;
HITS_DB db;
int ureads;
int64 offset;
FILE *IFILE;
int VERBOSE;
// Usage: [-v] <path:string> ( -f<file> | <input:fasta> ... )
{ int i, j, k;
int flags[128];
ARG_INIT("fasta2DB")
IFILE = NULL;
j = 1;
for (i = 1; i < argc; i++)
if (argv[i][0] == '-')
switch (argv[i][1])
{ default:
ARG_FLAGS("v")
break;
case 'f':
IFILE = fopen(argv[i]+2,"r");
if (IFILE == NULL)
{ fprintf(stderr,"%s: Cannot open file of inputs '%s'\n",Prog_Name,argv[i]+2);
exit (1);
}
break;
}
else
argv[j++] = argv[i];
argc = j;
VERBOSE = flags['v'];
if ((IFILE == NULL && argc <= 2) || (IFILE != NULL && argc != 2))
{ fprintf(stderr,"Usage: %s %s\n",Prog_Name,Usage);
exit (1);
}
}
int main(int argc, char *argv[])
{ HITS_DB db, dbs;
int64 dbpos;
FILE *dbfile, *ixfile;
int status;
int ALL;
int CUTOFF;
int64 SIZE;
{ int i, j, k;
int flags[128];
char *eptr;
float size;
ARG_INIT("DBsplit")
CUTOFF = 0;
size = 200;
j = 1;
for (i = 1; i < argc; i++)
if (argv[i][0] == '-')
switch (argv[i][1])
{ default:
ARG_FLAGS("a")
break;
case 'x':
ARG_NON_NEGATIVE(CUTOFF,"Min read length cutoff")
break;
case 's':
ARG_REAL(size)
if (size <= 0.)
{ fprintf(stderr,"%s: Block size must be a positive number\n",Prog_Name);
exit (1);
}
break;
}
else
argv[j++] = argv[i];
argc = j;
SIZE = size*1000000ll;
ALL = flags['a'];
if (argc != 2)
{ fprintf(stderr,"Usage: %s %s\n",Prog_Name,Usage);
exit (1);
}
}
int main(int argc, char *argv[])
{ HITS_DB _db1, *db1 = &_db1;
HITS_DB _db2, *db2 = &_db2;
Overlap _ovl, *ovl = &_ovl;
FILE *input;
int64 novl;
int tspace, tbytes, small;
int tmax;
int reps, *pts;
int input_pts;
int OVERLAP;
int DOCOORDS, DODIFFS, DOTRACE, DOLENS;
int ISTWO;
// Process options
{ int i, j, k;
int flags[128];
ARG_INIT("LAdump")
j = 1;
for (i = 1; i < argc; i++)
if (argv[i][0] == '-')
switch (argv[i][1])
{ default:
ARG_FLAGS("ocdtl")
break;
}
else
argv[j++] = argv[i];
argc = j;
OVERLAP = flags['o'];
DOCOORDS = flags['c'];
DODIFFS = flags['d'];
DOTRACE = flags['t'];
DOLENS = flags['l'];
if (DOTRACE)
DOCOORDS = 1;
if (argc <= 2)
{ fprintf(stderr,"Usage: %s %s\n",Prog_Name,Usage);
exit (1);
}
}
int main(int argc, char *argv[])
{ HITS_DB _db, *db = &_db;
HITS_READ *reads;
int VERBOSE;
int SORTED;
int RANGE;
// Process options
{ int i, j, k;
int flags[128];
ARG_INIT("LAcheck")
RANGE = 0;
reads = NULL;
j = 1;
for (i = 1; i < argc; i++)
if (argv[i][0] == '-')
switch (argv[i][1])
{ default:
ARG_FLAGS("vS")
break;
case 'a':
RANGE = 1;
if (argv[i][2] != ':')
{ fprintf(stderr,"%s: Unrecognizable option %s\n",Prog_Name,argv[i]);
exit (1);
}
if (Open_DB(argv[i]+3,db))
exit (1);
Trim_DB(db);
reads = db->reads;
break;
}
else
argv[j++] = argv[i];
argc = j;
VERBOSE = flags['v'];
SORTED = flags['S'];
if (argc < 2)
{ fprintf(stderr,"Usage: %s %s\n",Prog_Name,Usage);
exit (1);
}
}
int main(int argc, char *argv[])
{ HITS_DB _db, *db = &_db;
HITS_TRACK *dust;
int reps, *pts;
int DUST, TRIM, UPPER;
int QVTOO, QVNUR;
int WIDTH;
// Process arguments
{ int i, j, k;
int flags[128];
char *eptr;
ARG_INIT("DBshow")
WIDTH = 80;
j = 1;
for (i = 1; i < argc; i++)
if (argv[i][0] == '-')
switch (argv[i][1])
{ default:
ARG_FLAGS("udqUQ")
break;
case 'w':
ARG_NON_NEGATIVE(WIDTH,"Line width")
break;
}
else
argv[j++] = argv[i];
argc = j;
DUST = flags['d'];
TRIM = 1-flags['u'];
UPPER = 1+flags['U'];
QVTOO = flags['q'];
QVNUR = flags['Q'];
if (QVNUR)
QVTOO = 0;
if (argc <= 1)
{ fprintf(stderr,"Usage: %s %s\n",Prog_Name,Usage);
exit (1);
}
}
int main(int argc, char *argv[])
{ HITS_DB _db, *db = &_db;
FILE *dbfile;
int nfiles;
int VERBOSE, UPPER, WIDTH;
// Process arguments
{ int i, j, k;
int flags[128];
char *eptr;
ARG_INIT("DB2fasta")
WIDTH = 80;
j = 1;
for (i = 1; i < argc; i++)
if (argv[i][0] == '-')
switch (argv[i][1])
{
default:
ARG_FLAGS("vU")
break;
case 'w':
ARG_NON_NEGATIVE(WIDTH,"Line width")
break;
}
else
argv[j++] = argv[i];
argc = j;
UPPER = 1 + flags['U'];
VERBOSE = flags['v'];
if (argc != 2)
{ fprintf(stderr,"Usage: %s %s\n",Prog_Name,Usage);
exit (1);
}
}
int main(int argc, char *argv[])
{ HITS_DB _ablock, _bblock;
HITS_DB *ablock = &_ablock, *bblock = &_bblock;
char *afile, *bfile;
char *aroot, *broot;
void *aindex, *bindex;
int alen, blen;
Align_Spec *asettings;
int isdam;
int MMAX, MTOP, *MSTAT;
char **MASK;
int KMER_LEN;
int BIN_SHIFT;
int MAX_REPS;
int HIT_MIN;
double AVE_ERROR;
int SPACING;
{ int i, j, k;
int flags[128];
char *eptr;
ARG_INIT("daligner")
KMER_LEN = 14;
HIT_MIN = 35;
BIN_SHIFT = 6;
MAX_REPS = 0;
HGAP_MIN = 0;
AVE_ERROR = .70;
SPACING = 100;
MINOVER = 1000; // Globally visible to filter.c
MEM_PHYSICAL = getMemorySize();
MEM_LIMIT = MEM_PHYSICAL;
if (MEM_PHYSICAL == 0)
{ fprintf(stderr,"\nWarning: Could not get physical memory size\n");
fflush(stderr);
}
MTOP = 0;
MMAX = 10;
MASK = (char **) Malloc(MMAX*sizeof(char *),"Allocating mask track array");
MSTAT = (int *) Malloc(MMAX*sizeof(int),"Allocating mask status array");
if (MASK == NULL || MSTAT == NULL)
exit (1);
j = 1;
for (i = 1; i < argc; i++)
if (argv[i][0] == '-')
switch (argv[i][1])
{ default:
ARG_FLAGS("vbAI")
break;
case 'k':
ARG_POSITIVE(KMER_LEN,"K-mer length")
break;
case 'w':
ARG_POSITIVE(BIN_SHIFT,"Log of bin width")
break;
case 'h':
ARG_POSITIVE(HIT_MIN,"Hit threshold (in bp.s)")
break;
case 't':
ARG_POSITIVE(MAX_REPS,"Tuple supression frequency")
break;
case 'H':
ARG_POSITIVE(HGAP_MIN,"HGAP threshold (in bp.s)")
break;
case 'e':
ARG_REAL(AVE_ERROR)
if (AVE_ERROR < .7 || AVE_ERROR >= 1.)
{ fprintf(stderr,"%s: Average correlation must be in [.7,1.) (%g)\n",
Prog_Name,AVE_ERROR);
exit (1);
}
break;
case 'l':
ARG_POSITIVE(MINOVER,"Minimum alignment length")
break;
case 's':
ARG_POSITIVE(SPACING,"Trace spacing")
break;
case 'M':
{ int limit;
ARG_NON_NEGATIVE(limit,"Memory allocation (in Gb)")
MEM_LIMIT = limit * 0x40000000ll;
break;
}
case 'm':
if (MTOP >= MMAX)
{ MMAX = 1.2*MTOP + 10;
MASK = (char **) Realloc(MASK,MMAX*sizeof(char *),"Reallocating mask track array");
MSTAT = (int *) Realloc(MSTAT,MMAX*sizeof(int),"Reallocating mask status array");
if (MASK == NULL || MSTAT == NULL)
exit (1);
}
MASK[MTOP++] = argv[i]+2;
break;
}
else
argv[j++] = argv[i];
argc = j;
VERBOSE = flags['v']; // Globally declared in filter.h
BIASED = flags['b']; // Globally declared in filter.h
SYMMETRIC = 1-flags['A'];
IDENTITY = flags['I'];
if (argc <= 2)
{ fprintf(stderr,"Usage: %s %s\n",Prog_Name,Usage[0]);
fprintf(stderr," %*s %s\n",(int) strlen(Prog_Name),"",Usage[1]);
fprintf(stderr," %*s %s\n",(int) strlen(Prog_Name),"",Usage[2]);
exit (1);
}
}
int main(int argc, char *argv[])
{ void *iblock, *fblock;
int64 isize, osize;
int64 ovlsize, ptrsize;
int tspace, tbytes;
int i;
int VERBOSE;
// Process options
{ int j, k;
int flags[128];
ARG_INIT("LAsort")
j = 1;
for (i = 1; i < argc; i++)
if (argv[i][0] == '-')
{ ARG_FLAGS("v") }
else
argv[j++] = argv[i];
argc = j;
VERBOSE = flags['v'];
if (argc <= 1)
{ fprintf(stderr,"Usage: %s %s\n",Prog_Name,Usage);
exit (1);
}
}
// For each file do
ptrsize = sizeof(void *);
ovlsize = sizeof(Overlap) - ptrsize;
isize = 0;
iblock = NULL;
osize = MEMORY * 1000000ll;
fblock = Malloc(osize,"Allocating LAsort output block");
for (i = 1; i < argc; i++)
{ int64 *perm;
FILE *input, *foutput;
int64 novl;
// Read in the entire file and output header
{ int64 size;
struct stat info;
char *pwd, *root, *name;
pwd = PathTo(argv[i]);
root = Root(argv[i],".las");
name = Catenate(pwd,"/",root,".las");
input = Fopen(name,"r");
if (input == NULL)
exit (1);
stat(name,&info);
size = info.st_size;
fread(&novl,sizeof(int64),1,input);
fread(&tspace,sizeof(int),1,input);
if (tspace <= TRACE_XOVR)
tbytes = sizeof(uint8);
else
tbytes = sizeof(uint16);
if (VERBOSE)
{ printf(" %s: ",root);
Print_Number(novl,0,stdout);
printf(" records ");
Print_Number(size-novl*ovlsize,0,stdout);
printf(" trace bytes\n");
fflush(stdout);
}
foutput = Fopen(Catenate(pwd,"/",root,".S.las"),"w");
if (foutput == NULL)
exit (1);
fwrite(&novl,sizeof(int64),1,foutput);
fwrite(&tspace,sizeof(int),1,foutput);
free(pwd);
free(root);
if (size > isize)
{ if (iblock == NULL)
iblock = Malloc(size+ptrsize,"Allocating LAsort input block");
else
iblock = Realloc(iblock-ptrsize,size+ptrsize,"Allocating LAsort input block");
if (iblock == NULL)
exit (1);
iblock += ptrsize;
isize = size;
}
fread(iblock,1,isize,input);
fclose(input);
}
// Set up unsorted permutation array
perm = (int64 *) Malloc(sizeof(int64)*novl,"Allocating LAsort permutation vector");
if (perm == NULL)
exit (1);
{ int64 off;
int j;
off = -ptrsize;
for (j = 0; j < novl; j++)
{ perm[j] = off;
off += ovlsize + ((Overlap *) (iblock+off))->path.tlen*tbytes;
}
}
// Sort permutation array of ptrs to records
IBLOCK = iblock;
qsort(perm,novl,sizeof(int64),SORT_OVL);
// Output the records in sorted order
{ int j;
Overlap *w;
int64 tsize, span;
void *fptr, *ftop;
fptr = fblock;
ftop = fblock + osize;
for (j = 0; j < novl; j++)
{ w = (Overlap *) (iblock+perm[j]);
tsize = w->path.tlen*tbytes;
span = ovlsize + tsize;
if (fptr + span > ftop)
{ fwrite(fblock,1,fptr-fblock,foutput);
fptr = fblock;
}
memcpy(fptr,((void *) w)+ptrsize,ovlsize);
fptr += ovlsize;
memcpy(fptr,(void *) (w+1),tsize);
fptr += tsize;
}
if (fptr > fblock)
fwrite(fblock,1,fptr-fblock,foutput);
}
free(perm);
fclose(foutput);
}
if (iblock != NULL)
free(iblock - ptrsize);
free(fblock);
exit (0);
}
int main(int argc, char *argv[])
{ int nblocks;
int fblock, lblock;
char *pwd, *root;
int MUNIT, DUNIT;
int VON, BON, DON;
int WINT, TINT, HGAP, HINT, KINT, SINT, LINT;
double EREL, MREL;
{ int i, j, k; // Process options
int flags[128];
char *eptr;
ARG_INIT("HPCdaligner")
DUNIT = 4;
MUNIT = 25;
KINT = 14;
WINT = 6;
HINT = 35;
TINT = 0;
HGAP = 0;
EREL = .70;
MREL = .55;
SINT = 100;
LINT = 1000;
j = 1;
for (i = 1; i < argc; i++)
if (argv[i][0] == '-')
switch (argv[i][1])
{ default:
optflags:
ARG_FLAGS("vbd");
break;
case 'k':
ARG_POSITIVE(KINT,"K-mer length")
break;
case 'w':
ARG_POSITIVE(WINT,"Log of bin width")
break;
case 'h':
ARG_POSITIVE(HINT,"Hit threshold (in bp.s)")
break;
case 't':
ARG_POSITIVE(TINT,"Tuple suppression frequency")
break;
case 'H':
ARG_POSITIVE(HGAP,"HGAP threshold (in bp.s)")
break;
case 'e':
ARG_REAL(EREL)
if (EREL < .7 || EREL >= 1.)
{ fprintf(stderr,"%s: Average correlation must be in [.7,1.) (%g)\n",Prog_Name,EREL);
exit (1);
}
break;
case 's':
ARG_POSITIVE(SINT,"Trace spacing")
break;
case 'l':
ARG_POSITIVE(LINT,"Minimum ovlerap length")
break;
case 'm':
if (argv[i][2] == 'r' && argv[i][3] == 'g')
{ MUNIT = strtol(argv[i]+4,&eptr,10);
if (*eptr != '\0' || argv[i][4] == '\0')
{ fprintf(stderr,"%s: -mrg argument is not an integer\n",Prog_Name);
exit (1);
}
if (MUNIT <= 0)
{ fprintf(stderr,"%s: Files per merge must be positive (%d)\n",
Prog_Name,MUNIT);
exit (1);
}
if (MUNIT < 3)
{ fprintf(stderr,"%s: Files per merge must be at least 3 (%d)\n",
Prog_Name,MUNIT);
exit (1);
}
break;
}
ARG_REAL(MREL)
if (MREL < .55 || MREL >= 1.)
{ fprintf(stderr,"%s: Minimum correlation must be in [.55,1.) (%g)\n",Prog_Name,MREL);
exit (1);
}
break;
case 'd':
if (argv[i][2] == 'a' && argv[i][3] == 'l')
{ DUNIT = strtol(argv[i]+4,&eptr,10);
if (*eptr != '\0' || argv[i][4] == '\0')
{ fprintf(stderr,"%s: -dal argument is not an integer\n",Prog_Name);
exit (1);
}
if (DUNIT <= 0)
{ fprintf(stderr,"%s: Blocks per daligner call must be positive (%d)\n",
Prog_Name,DUNIT);
exit (1);
}
}
else
goto optflags;
break;
}
else
argv[j++] = argv[i];
argc = j;
VON = flags['v'];
BON = flags['b'];
DON = flags['d'];
if (argc < 2 || argc > 3)
{ fprintf(stderr,"Usage: %s %s\n",Prog_Name,Usage[0]);
fprintf(stderr," %*s %s\n",(int) strlen(Prog_Name),"",Usage[1]);
fprintf(stderr," %*s %s\n",(int) strlen(Prog_Name),"",Usage[2]);
fprintf(stderr," %*s %s\n",(int) strlen(Prog_Name),"",Usage[3]);
exit (1);
}
}
int main(int argc, char *argv[])
{ HITS_DB _db, *db = &_db;
FILE *dbfile, *quiva;
int VERBOSE, UPPER;
// Process arguments
{ int i, j, k;
int flags[128];
ARG_INIT("DB2quiva")
j = 1;
for (i = 1; i < argc; i++)
if (argv[i][0] == '-')
{ ARG_FLAGS("vU") }
else
argv[j++] = argv[i];
argc = j;
VERBOSE = flags['v'];
UPPER = flags['U'];
if (argc != 2)
{ fprintf(stderr,"Usage: %s %s\n",Prog_Name,Usage);
exit (1);
}
}
// Open db, db stub file, and .qvs file
{ char *pwd, *root;
if (Open_DB(argv[1],db))
{ fprintf(stderr,"%s: Database %s.db could not be opened\n",Prog_Name,argv[1]);
exit (1);
}
if (db->part > 0)
{ fprintf(stderr,"%s: Cannot be called on a block: %s.db\n",Prog_Name,argv[1]);
exit (1);
}
pwd = PathTo(argv[1]);
root = Root(argv[1],".db");
dbfile = Fopen(Catenate(pwd,"/",root,".db"),"r");
quiva = Fopen(Catenate(pwd,PATHSEP,root,".qvs"),"r");
free(pwd);
free(root);
if (dbfile == NULL || quiva == NULL)
exit (1);
}
// For each file do:
{ HITS_READ *reads;
int f, first, nfiles;
QVcoding *coding;
char **entry;
if (fscanf(dbfile,DB_NFILE,&nfiles) != 1)
SYSTEM_ERROR
entry = New_QV_Buffer(db);
reads = db->reads;
first = 0;
for (f = 0; f < nfiles; f++)
{ int i, last;
FILE *ofile;
char prolog[MAX_NAME], fname[MAX_NAME];
// Scan db image file line, create .quiva file for writing
if (reads[first].coff < 0) break;
if (fscanf(dbfile,DB_FDATA,&last,fname,prolog) != 3)
SYSTEM_ERROR
if ((ofile = Fopen(Catenate(".","/",fname,".quiva"),"w")) == NULL)
exit (1);
if (VERBOSE)
{ fprintf(stderr,"Creating %s.quiva ...\n",fname);
fflush(stderr);
}
coding = Read_QVcoding(quiva);
// For the relevant range of reads, write the header for each to the file
// and then uncompress and write the quiva entry for each
for (i = first; i < last; i++)
{ int e, flags, qv, rlen;
HITS_READ *r;
r = reads + i;
flags = r->flags;
rlen = r->end - r->beg;
qv = (flags & DB_QV);
fprintf(ofile,"@%s/%d/%d_%d",prolog,r->origin,r->beg,r->end);
if (qv > 0)
fprintf(ofile," RQ=0.%3d",qv);
fprintf(ofile,"\n");
Uncompress_Next_QVentry(quiva,entry,coding,rlen);
if (UPPER)
{ char *deltag = entry[1];
int j;
for (j = 0; j < rlen; j++)
deltag[j] -= 32;
}
for (e = 0; e < 5; e++)
fprintf(ofile,"%.*s\n",rlen,entry[e]);
}
first = last;
}
}
fclose(quiva);
fclose(dbfile);
Close_DB(db);
exit (0);
}
int main(int argc, char *argv[])
{ DAZZ_DB _ablock, _bblock;
DAZZ_DB *ablock = &_ablock, *bblock = &_bblock;
char *afile, *bfile;
char *aroot, *broot, *apwd;
void *aindex, *bindex;
int alen, blen;
int isdam, nblocks; // of reference (a-argument)
int mflag;
char *command;
Align_Spec *settings;
int COVER, NOMAP;
int KMER_LEN;
int MAX_REPS;
double AVE_ERROR;
int NTHREADS;
int MAP_ORDER;
int MMAX, MTOP, *MSTAT;
char **MASK;
{ int i, j, k;
int flags[128];
char *eptr;
DIR *dirp;
ARG_INIT("damapper")
KMER_LEN = 20;
MAX_REPS = 0;
AVE_ERROR = .85;
SPACING = 100; // Globally visible to map.c
BEST_TIE = 1.0;
NTHREADS = 4;
SORT_PATH = "/tmp";
MEM_PHYSICAL = getMemorySize();
MEM_LIMIT = MEM_PHYSICAL;
if (MEM_PHYSICAL == 0)
{ fprintf(stderr,"\nWarning: Could not get physical memory size\n");
fflush(stderr);
}
MTOP = 0;
MMAX = 10;
MASK = (char **) Malloc(MMAX*sizeof(char *),"Allocating mask track array");
MSTAT = (int *) Malloc(MMAX*sizeof(int),"Allocating mask status array");
if (MASK == NULL || MSTAT == NULL)
exit (1);
j = 1;
for (i = 1; i < argc; i++)
if (argv[i][0] == '-')
switch (argv[i][1])
{ default:
ARG_FLAGS("vbpzCN")
break;
case 'e':
ARG_REAL(AVE_ERROR)
if (AVE_ERROR < .7 || AVE_ERROR >= 1.)
{ fprintf(stderr,"%s: Average correlation must be in [.7,1.) (%g)\n",
Prog_Name,AVE_ERROR);
exit (1);
}
break;
case 'k':
ARG_POSITIVE(KMER_LEN,"K-mer length")
if (KMER_LEN > 32)
{ fprintf(stderr,"%s: K-mer length must be 32 or less\n",Prog_Name);
exit (1);
}
break;
case 'm':
if (MTOP >= MMAX)
{ MMAX = 1.2*MTOP + 10;
MASK = (char **) Realloc(MASK,MMAX*sizeof(char *),"Reallocating mask track array");
MSTAT = (int *) Realloc(MSTAT,MMAX*sizeof(int),"Reallocating mask status array");
if (MASK == NULL || MSTAT == NULL)
exit (1);
}
MASK[MTOP++] = argv[i]+2;
break;
case 'n':
ARG_REAL(BEST_TIE)
if (BEST_TIE < .7 || BEST_TIE > 1.)
{ fprintf(stderr,"%s: Near optimal threshold must be in [.7,1.] (%g)\n",
Prog_Name,BEST_TIE);
exit (1);
}
break;
case 's':
ARG_POSITIVE(SPACING,"Trace spacing")
break;
case 't':
ARG_POSITIVE(MAX_REPS,"Tuple supression frequency")
break;
case 'M':
{ int limit;
ARG_NON_NEGATIVE(limit,"Memory allocation (in Gb)")
MEM_LIMIT = limit * 0x40000000ll;
break;
}
case 'P':
SORT_PATH = argv[i]+2;
if ((dirp = opendir(SORT_PATH)) == NULL)
{ fprintf(stderr,"%s: -P option: cannot open directory %s\n",Prog_Name,SORT_PATH);
exit (1);
}
closedir(dirp);
break;
case 'T':
ARG_POSITIVE(NTHREADS,"Number of threads")
break;
}
else
argv[j++] = argv[i];
argc = j;
VERBOSE = flags['v']; // Globally declared in map.h
BIASED = flags['b'];
PROFILE = flags['p'];
COVER = flags['C'];
NOMAP = flags['N'];
MAP_ORDER = 1-flags['z'];
if (argc <= 2)
{ fprintf(stderr,"Usage: %s %s\n",Prog_Name,Usage[0]);
fprintf(stderr," %*s %s\n",(int) strlen(Prog_Name),"",Usage[1]);
fprintf(stderr," %*s %s\n",(int) strlen(Prog_Name),"",Usage[2]);
fprintf(stderr,"\n");
fprintf(stderr," -k: k-mer size (must be <= 32).\n");
fprintf(stderr," -t: Ignore k-mers that occur >= -t times in a block.\n");
fprintf(stderr," -M: Use only -M GB of memory by ignoring most frequent k-mers.\n");
fprintf(stderr,"\n");
fprintf(stderr," -e: Look for alignments with -e percent similarity.\n");
fprintf(stderr," -s: Use -s as the trace point spacing for encoding alignments.\n");
fprintf(stderr," -n: Output all matches within this %% of the best\n");
fprintf(stderr,"\n");
fprintf(stderr," -T: Use -T threads.\n");
fprintf(stderr," -P: Do sorts and merges in directory -P.\n");
fprintf(stderr," -m: Soft mask the blocks with the specified mask.\n");
fprintf(stderr," -b: For AT/GC biased data, compensate k-mer counts (deprecated).\n");
fprintf(stderr,"\n");
fprintf(stderr," -v: Verbose mode, output statistics as proceed.\n");
fprintf(stderr," -z: sort .las by A,B-read pairs (overlap piles)\n");
fprintf(stderr," off => sort .las by A-read,A-position pairs");
fprintf(stderr," (default for mapping)\n");
fprintf(stderr," -p: Output repeat profile track\n");
fprintf(stderr," -C: Output reference vs reads .las.\n");
fprintf(stderr," -N: Do not output reads vs reference .las.\n");
exit (1);
}
if (COVER)
if (NOMAP)
mflag = FLAG_DOB;
else
mflag = FLAG_DOA | FLAG_DOB;
else
if (NOMAP)
{ fprintf(stderr,"%s: Cannot specify both C and N flags together\n",Prog_Name);
exit (1);
}
else
mflag = FLAG_DOA;
if (NOMAP && PROFILE)
{ fprintf(stderr,"%s: Cannot specify both N and p flags together\n",Prog_Name);
exit (1);
}
for (j = 0; j < MTOP; j++)
MSTAT[j] = -2;
}
int main(int argc, char *argv[])
{ DAZZ_DB _db, *db = &_db;
FILE *hdrs = NULL;
char *hdrs_name = NULL;
int nfiles;
char **flist = NULL;
int *findx = NULL;
int reps, *pts;
int input_pts;
File_Iterator *iter = NULL;
FILE *input;
int TRIM, UPPER;
int DOSEQ, DOQVS, DOARR, QUIVA, ARROW, DAM;
int WIDTH;
int MMAX, MTOP;
char **MASK;
// Process arguments
{ int i, j, k;
int flags[128];
char *eptr;
ARG_INIT("DBshow")
WIDTH = 80;
MTOP = 0;
MMAX = 10;
MASK = (char **) Malloc(MMAX*sizeof(char *),"Allocating mask track array");
if (MASK == NULL)
exit (1);
j = 1;
for (i = 1; i < argc; i++)
if (argv[i][0] == '-')
switch (argv[i][1])
{ default:
ARG_FLAGS("unqaUQA")
break;
case 'w':
ARG_NON_NEGATIVE(WIDTH,"Line width")
break;
case 'm':
if (MTOP >= MMAX)
{ MMAX = 1.2*MTOP + 10;
MASK = (char **) Realloc(MASK,MMAX*sizeof(char *),"Reallocating mask track array");
if (MASK == NULL)
exit (1);
}
MASK[MTOP++] = argv[i]+2;
break;
}
else
argv[j++] = argv[i];
argc = j;
DAM = 0;
TRIM = 1-flags['u'];
UPPER = 1+flags['U'];
DOQVS = flags['q'];
DOARR = flags['a'];
DOSEQ = 1-flags['n'];
QUIVA = flags['Q'];
ARROW = flags['A'];
if ((QUIVA || DOQVS) && (ARROW || DOARR))
{ fprintf(stderr,"%s: Cannot request both Quiver (-Q,-q) and Arrow (-A,a) information\n",
Prog_Name);
exit (1);
}
if (QUIVA)
{ DOQVS = 1;
DOSEQ = 0;
MTOP = 0;
}
if (ARROW)
{ DOARR = 1;
DOSEQ = 0;
MTOP = 0;
}
if (argc <= 1)
{ fprintf(stderr,"Usage: %s %s\n",Prog_Name,Usage[0]);
fprintf(stderr," %*s %s\n",(int) strlen(Prog_Name),"",Usage[1]);
fprintf(stderr,"\n");
fprintf(stderr," -u: Show the untrimmed database.\n");
fprintf(stderr,"\n");
fprintf(stderr," -q: Show also the .quiva streams.\n");
fprintf(stderr," -a: Show also the .arrow pulse sequences.\n");
fprintf(stderr," -n: Do not show the default read DNA sequences.\n");
fprintf(stderr," -m: Show mask intervals and highlight in sequence.\n");
fprintf(stderr,"\n");
fprintf(stderr," -Q: Produce a .quiva file (ignore all other options but -uU).\n");
fprintf(stderr," -A: Produce a .arrow file (ignore all other options but -uw).\n");
fprintf(stderr,"\n");
fprintf(stderr," -U: Use upper case for DNA (default is lower case).\n");
fprintf(stderr," -w: Print -w bp per line (default is 80).\n");
exit (1);
}
}
int main(int argc, char* argv[])
{ int VERBOSE;
int KEEP;
int LOSSY;
{ int i, j, k;
int flags[128];
ARG_INIT("dexqv")
j = 1;
for (i = 1; i < argc; i++)
if (argv[i][0] == '-')
{ ARG_FLAGS("vkl") }
else
argv[j++] = argv[i];
argc = j;
VERBOSE = flags['v'];
KEEP = flags['k'];
LOSSY = flags['l'];
if (argc == 1)
{ fprintf(stderr,"Usage: %s %s\n",Prog_Name,Usage);
exit (1);
}
}
// For each .quiva file to be compressed:
{ int i;
for (i = 1; i < argc; i++)
{ char *pwd, *root;
FILE *input, *output;
QVcoding *coding;
pwd = PathTo(argv[i]);
root = Root(argv[i],".quiva");
input = Fopen(Catenate(pwd,"/",root,".quiva"),"r");
if (input == NULL)
exit (1);
output = Fopen(Catenate(pwd,"/",root,".dexqv"),"w");
if (output == NULL)
exit (1);
if (VERBOSE)
{ fprintf(stderr,"Processing '%s' ...\n",root);
fflush(stderr);
}
// Scan the file collecting statistics for Huffman schemes
QVcoding_Scan(input);
// Create and output the encoding schemes
coding = Create_QVcoding(LOSSY);
{ char *slash, *read;
rewind (input);
Read_Lines(input,1);
read = QVentry();
slash = index(read+1,'/');
if (slash != NULL)
{ coding->prefix = (char *) malloc((slash-read)+1);
if (coding->prefix == NULL)
{ fprintf(stderr,"%s: Out of memory (Allocating header prefix)\n",Prog_Name);
exit (1);
}
*slash = '\0';
if (strcpy(coding->prefix,read) == NULL)
SYSTEM_ERROR
*slash = '/';
}
}
Write_QVcoding(output,coding);
// For each entry do
{ int lwell;
rewind (input);
lwell = 0;
while (Read_Lines(input,1) > 0)
{ int well, beg, end, qv;
char *slash;
uint16 half;
uint8 byte;
// Interpret the header, encode and write out the fields
slash = index(QVentry(),'/');
sscanf(slash+1,"%d/%d_%d RQ=0.%d\n",&well,&beg,&end,&qv);
while (well - lwell >= 255)
{ byte = 0xff;
fwrite(&byte,1,1,output);
lwell += 255;
}
byte = (uint8) (well-lwell);
fwrite(&byte,1,1,output);
lwell = well;
half = (uint16) beg;
fwrite(&half,sizeof(uint16),1,output);
half = (uint16) end;
fwrite(&half,sizeof(uint16),1,output);
half = (uint16) qv;
fwrite(&half,sizeof(uint16),1,output);
Compress_Next_QVentry(input,output,coding,LOSSY);
}
}
// Clean up for the next file
Free_QVcoding(coding);
fclose(input);
fclose(output);
if (!KEEP)
unlink(Catenate(pwd,"/",root,".quiva"));
free(root);
free(pwd);
if (VERBOSE)
{ fprintf(stderr,"Done\n");
fflush(stderr);
}
}
}
free(QVentry());
exit (0);
}
int main(int argc, char *argv[])
{ DAZZ_DB _bblock;
DAZZ_DB *bblock = &_bblock;
char *bfile;
char *broot;
Align_Spec *settings;
int isdam;
char *command;
int KMER_LEN;
int BIN_SHIFT;
int HIT_MIN;
double AVE_ERROR;
int SPACING;
int NTHREADS;
{ int i, j, k;
int flags[128];
char *eptr;
DIR *dirp;
ARG_INIT("datander")
KMER_LEN = 12;
HIT_MIN = 35;
BIN_SHIFT = 4;
AVE_ERROR = .70;
SPACING = 100;
MINOVER = 500; // Globally visible to filter.c
NTHREADS = 4;
SORT_PATH = "/tmp";
j = 1;
for (i = 1; i < argc; i++)
if (argv[i][0] == '-')
switch (argv[i][1])
{ default:
ARG_FLAGS("v")
break;
case 'k':
ARG_POSITIVE(KMER_LEN,"K-mer length")
if (KMER_LEN > 32)
{ fprintf(stderr,"%s: K-mer length must be 32 or less\n",Prog_Name);
exit (1);
}
break;
case 'w':
ARG_POSITIVE(BIN_SHIFT,"Log of bin width")
break;
case 'h':
ARG_POSITIVE(HIT_MIN,"Hit threshold (in bp.s)")
break;
case 'e':
ARG_REAL(AVE_ERROR)
if (AVE_ERROR < .6 || AVE_ERROR >= 1.)
{ fprintf(stderr,"%s: Average correlation must be in [.6,1.) (%g)\n",
Prog_Name,AVE_ERROR);
exit (1);
}
break;
case 'l':
ARG_POSITIVE(MINOVER,"Minimum alignment length")
break;
case 's':
ARG_POSITIVE(SPACING,"Trace spacing")
break;
case 'P':
SORT_PATH = argv[i]+2;
if ((dirp = opendir(SORT_PATH)) == NULL)
{ fprintf(stderr,"%s: -P option: cannot open directory %s\n",Prog_Name,SORT_PATH);
exit (1);
}
closedir(dirp);
break;
case 'T':
ARG_POSITIVE(NTHREADS,"Number of threads")
break;
}
else
argv[j++] = argv[i];
argc = j;
VERBOSE = flags['v']; // Globally declared in filter.h
if (argc <= 1)
{ fprintf(stderr,"Usage: %s %s\n",Prog_Name,Usage[0]);
fprintf(stderr," %*s %s\n",(int) strlen(Prog_Name),"",Usage[1]);
fprintf(stderr,"\n");
fprintf(stderr," -v: Verbose mode, output statistics as proceed.\n");
fprintf(stderr," -k: k-mer size (must be <= 32).\n");
fprintf(stderr," -w: Look for k-mers in averlapping bands of size 2^-w.\n");
fprintf(stderr," -h: A seed hit if the k-mers in band cover >= -h bps in the");
fprintf(stderr," targest read.\n");
fprintf(stderr,"\n");
fprintf(stderr," -e: Look for alignments with -e percent similarity.\n");
fprintf(stderr," -l: Look for alignments of length >= -l.\n");
fprintf(stderr," -s: Use -s as the trace point spacing for encoding alignments.\n");
fprintf(stderr,"\n");
fprintf(stderr," -T: Use -T threads.\n");
fprintf(stderr," -P: Do first level sort and merge in directory -P.\n");
exit (1);
}
}
int main(int argc, char *argv[])
{ DAZZ_DB _db1, *db1 = &_db1;
DAZZ_DB _db2, *db2 = &_db2;
Overlap _ovl, *ovl = &_ovl;
Alignment _aln, *aln = &_aln;
FILE *input;
int64 novl;
int tspace, tbytes, small;
int reps, *pts;
int ALIGN, CARTOON, REFERENCE, FLIP;
int INDENT, WIDTH, BORDER, UPPERCASE;
int ISTWO;
int ICE_FL;
int M4OVL;
// Process options
{ int i, j, k;
int flags[128];
char *eptr;
ARG_INIT("LA4Ice")
INDENT = 4;
WIDTH = 100;
BORDER = 10;
M4OVL = 0;
ICE_FL = 0;
j = 1;
for (i = 1; i < argc; i++)
if (argv[i][0] == '-')
switch (argv[i][1])
{ default:
ARG_FLAGS("carmEUF")
break;
case 'i':
ARG_NON_NEGATIVE(INDENT,"Indent")
break;
case 'w':
ARG_POSITIVE(WIDTH,"Alignment width")
break;
case 'b':
ARG_NON_NEGATIVE(BORDER,"Alignment border")
break;
}
else
argv[j++] = argv[i];
argc = j;
UPPERCASE = flags['U'];
ALIGN = flags['a'];
REFERENCE = flags['r'];
CARTOON = flags['c'];
FLIP = flags['F'];
M4OVL = flags['m'];
ICE_FL = flags['E'];
if (argc <= 2)
{ fprintf(stderr,"Usage: %s %s\n",Prog_Name,Usage[0]);
fprintf(stderr," %*s %s\n",(int) strlen(Prog_Name),"",Usage[1]);
exit (1);
}
}
int main(int argc, char *argv[])
{ FILE *istub, *ostub;
char *dbname;
char *root, *pwd;
FILE *bases, *indx, *hdrs;
int64 boff, ioff, hoff, noff;
int ifiles, ofiles;
char **flist;
DAZZ_DB db;
int ureads;
int64 offset, hdrset;
char *PIPE;
FILE *IFILE;
int VERBOSE;
// Process command line
{ int i, j, k;
int flags[128];
ARG_INIT("fasta2DAM")
IFILE = NULL;
PIPE = NULL;
j = 1;
for (i = 1; i < argc; i++)
if (argv[i][0] == '-')
switch (argv[i][1])
{ default:
ARG_FLAGS("v")
break;
case 'f':
IFILE = fopen(argv[i]+2,"r");
if (IFILE == NULL)
{ fprintf(stderr,"%s: Cannot open file of inputs '%s'\n",Prog_Name,argv[i]+2);
exit (1);
}
break;
case 'i':
PIPE = argv[i]+2;
if (PIPE[0] != '\0')
{ FILE *temp;
temp = fopen(PIPE,"w");
if (temp == NULL)
{ fprintf(stderr,"%s: Cannot create -i name '%s'\n",Prog_Name,argv[i]+2);
exit (1);
}
fclose(temp);
unlink(PIPE);
}
break;
}
else
argv[j++] = argv[i];
argc = j;
VERBOSE = flags['v'];
if (IFILE != NULL && PIPE != NULL)
{ fprintf(stderr,"%s: Cannot use both -f and -i together\n",Prog_Name);
exit (1);
}
if ( (IFILE == NULL && PIPE == NULL && argc <= 2) ||
((IFILE != NULL || PIPE != NULL) && argc != 2))
{ fprintf(stderr,"Usage: %s %s\n",Prog_Name,Usage);
fprintf(stderr,"\n");
fprintf(stderr," -f: import files listed 1/line in given file.\n");
fprintf(stderr," -i: import data from stdin, use optiona name as data source.\n");
fprintf(stderr," : otherwise, import sequence of specified files.\n");
exit (1);
}
}
int main(int argc, char *argv[])
{ HITS_DB _db, *db = &_db;
int dam;
int64 ototal;
int oreads;
int nbin, *hist;
int64 *bsum;
int NONE;
int TRIM;
int BIN;
int MMAX, MTOP;
char **MASK;
{ int i, j, k;
int flags[128];
char *eptr;
ARG_INIT("DBstats")
BIN = 1000;
MTOP = 0;
MMAX = 10;
MASK = (char **) Malloc(MMAX*sizeof(char *),"Allocating mask track array");
if (MASK == NULL)
exit (1);
j = 1;
for (i = 1; i < argc; i++)
if (argv[i][0] == '-')
switch (argv[i][1])
{ default:
ARG_FLAGS("nu")
break;
case 'b':
ARG_POSITIVE(BIN,"Bin size")
break;
case 'm':
if (MTOP >= MMAX)
{ MMAX = 1.2*MTOP + 10;
MASK = (char **) Realloc(MASK,MMAX*sizeof(char *),"Reallocating mask track array");
if (MASK == NULL)
exit (1);
}
MASK[MTOP++] = argv[i]+2;
break;
}
else
argv[j++] = argv[i];
argc = j;
NONE = flags['n'];
TRIM = 1-flags['u'];
if (argc != 2)
{ fprintf(stderr,"Usage: %s %s\n",Prog_Name,Usage);
exit (1);
}
}
int main(int argc, char *argv[])
{ DAZZ_DB _db, *db = &_db;
int dam;
int64 ototal;
int oreads;
int nbin, *hist;
int64 *bsum;
int NONE;
int TRIM;
int BIN;
int MMAX, MTOP;
char **MASK;
{ int i, j, k;
int flags[128];
char *eptr;
ARG_INIT("DBstats")
BIN = 1000;
MTOP = 0;
MMAX = 10;
MASK = (char **) Malloc(MMAX*sizeof(char *),"Allocating mask track array");
if (MASK == NULL)
exit (1);
j = 1;
for (i = 1; i < argc; i++)
if (argv[i][0] == '-')
switch (argv[i][1])
{ default:
ARG_FLAGS("nu")
break;
case 'b':
ARG_POSITIVE(BIN,"Bin size")
break;
case 'm':
if (MTOP >= MMAX)
{ MMAX = 1.2*MTOP + 10;
MASK = (char **) Realloc(MASK,MMAX*sizeof(char *),"Reallocating mask track array");
if (MASK == NULL)
exit (1);
}
MASK[MTOP++] = argv[i]+2;
break;
}
else
argv[j++] = argv[i];
argc = j;
NONE = flags['n'];
TRIM = 1-flags['u'];
if (argc != 2)
{ fprintf(stderr,"Usage: %s %s\n",Prog_Name,Usage);
fprintf(stderr,"\n");
fprintf(stderr," -u: Give stats for the untrimmed database.\n");
fprintf(stderr,"\n");
fprintf(stderr," -n: Do not show histogram of read lengths.\n");
fprintf(stderr," -m: Show histogram of mask intervals.\n");
fprintf(stderr," -b: Use histogram buckets of this size (default 1Kbp).\n");
exit (1);
}
}
int main(int argc, char *argv[])
{ HITS_DB _db, *db = &_db;
FILE *hdrs = NULL;
int nfiles;
char **flist = NULL;
int *findx = NULL;
int reps, *pts;
int input_pts;
File_Iterator *iter = NULL;
FILE *input;
int TRIM, UPPER;
int DOSEQ, DOQVS, QUIVA, DAM;
int WIDTH;
int MMAX, MTOP;
char **MASK;
// Process arguments
{ int i, j, k;
int flags[128];
char *eptr;
ARG_INIT("DBshow")
WIDTH = 80;
MTOP = 0;
MMAX = 10;
MASK = (char **) Malloc(MMAX*sizeof(char *),"Allocating mask track array");
if (MASK == NULL)
exit (1);
j = 1;
for (i = 1; i < argc; i++)
if (argv[i][0] == '-')
switch (argv[i][1])
{ default:
ARG_FLAGS("unqUQ")
break;
case 'w':
ARG_NON_NEGATIVE(WIDTH,"Line width")
break;
case 'm':
if (MTOP >= MMAX)
{ MMAX = 1.2*MTOP + 10;
MASK = (char **) Realloc(MASK,MMAX*sizeof(char *),"Reallocating mask track array");
if (MASK == NULL)
exit (1);
}
MASK[MTOP++] = argv[i]+2;
break;
}
else
argv[j++] = argv[i];
argc = j;
DAM = 0;
TRIM = 1-flags['u'];
UPPER = 1+flags['U'];
DOQVS = flags['q'];
DOSEQ = 1-flags['n'];
QUIVA = flags['Q'];
if (QUIVA && (!DOSEQ || MTOP > 0))
{ fprintf(stderr,"%s: -Q (quiva) format request inconsistent with -n and -m options\n",
Prog_Name);
exit (1);
}
if (QUIVA)
DOQVS = 1;
if (argc <= 1)
{ fprintf(stderr,"Usage: %s %s\n",Prog_Name,Usage[0]);
fprintf(stderr," %*s %s\n",(int) strlen(Prog_Name),"",Usage[1]);
exit (1);
}
}
int main(int argc, char *argv[])
{ char *prefix;
FILE *aout, *dout;
int VERBOSE;
// Process arguments
{ int i, j, k;
int flags[128];
ARG_INIT("Catrack")
j = 1;
for (i = 1; i < argc; i++)
if (argv[i][0] == '-')
{ ARG_FLAGS("v") }
else
argv[j++] = argv[i];
argc = j;
VERBOSE = flags['v'];
if (argc != 3)
{ fprintf(stderr,"Usage: %s %s\n",Prog_Name,Usage);
exit (1);
}
}
{ char *pwd, *root;
int plen;
plen = strlen(argv[1]);
if (strcmp(argv[1]+(plen-3),".dam") == 0)
root = Root(argv[1],".dam");
else
root = Root(argv[1],".db");
pwd = PathTo(argv[1]);
prefix = Strdup(Catenate(pwd,PATHSEP,root,"."),"Allocating track name");
free(pwd);
free(root);
aout = fopen(Catenate(prefix,argv[2],".","anno"),"r");
if (aout != NULL)
{ fprintf(stderr,"%s: Track file %s%s.anno already exists!\n",Prog_Name,prefix,argv[2]);
fclose(aout);
exit (1);
}
dout = fopen(Catenate(prefix,argv[2],".","data"),"r");
if (dout != NULL)
{ fprintf(stderr,"%s: Track file %s%s.data already exists!\n",Prog_Name,prefix,argv[2]);
fclose(dout);
exit (1);
}
aout = Fopen(Catenate(prefix,argv[2],".","anno"),"w");
if (aout == NULL)
exit (1);
dout = NULL;
}
{ int tracktot, tracksiz;
int64 trackoff;
int nfiles;
char data[1024];
void *anno;
anno = NULL;
trackoff = 0;
tracktot = tracksiz = 0;
fwrite(&tracktot,sizeof(int),1,aout);
fwrite(&tracksiz,sizeof(int),1,aout);
nfiles = 0;
while (1)
{ FILE *afile, *dfile;
int i, size, tracklen;
afile = fopen(Numbered_Suffix(prefix,nfiles+1,Catenate(".",argv[2],".","anno")),"r");
if (afile == NULL)
break;
dfile = fopen(Numbered_Suffix(prefix,nfiles+1,Catenate(".",argv[2],".","data")),"r");
if (VERBOSE)
{ fprintf(stderr,"Concatenating %s%d.%s ...\n",prefix,nfiles+1,argv[2]);
fflush(stderr);
}
if (fread(&tracklen,sizeof(int),1,afile) != 1)
SYSTEM_ERROR
if (fread(&size,sizeof(int),1,afile) != 1)
SYSTEM_ERROR
if (nfiles == 0)
{ tracksiz = size;
if (dfile != NULL)
{ dout = Fopen(Catenate(prefix,argv[2],".","data"),"w");
if (dout == NULL)
{ fclose(afile);
fclose(dfile);
goto error;
}
}
else
{ anno = Malloc(size,"Allocating annotation record");
if (anno == NULL)
{ fclose(afile);
goto error;
}
}
}
else
{ int escape = 1;
if (tracksiz != size)
{ fprintf(stderr,"%s: Track block %d does not have the same annotation size (%d)",
Prog_Name,nfiles+1,size);
fprintf(stderr," as previous blocks (%d)\n",tracksiz);
}
else if (dfile == NULL && dout != NULL)
fprintf(stderr,"%s: Track block %d does not have data but previous blocks do\n",
Prog_Name,nfiles+1);
else if (dfile != NULL && dout == NULL)
fprintf(stderr,"%s: Track block %d has data but previous blocks do not\n",
Prog_Name,nfiles+1);
else
escape = 0;
if (escape)
{ fclose(afile);
if (dfile != NULL) fclose(dfile);
if (anno != NULL) free(anno);
goto error;
}
}
if (dfile != NULL)
{ int64 dlen;
if (size == 4)
{ int anno4;
for (i = 0; i < tracklen; i++)
{ if (fread(&anno4,sizeof(int),1,afile) != 1)
SYSTEM_ERROR
anno4 += trackoff;
fwrite(&anno4,sizeof(int),1,aout);
}
if (fread(&anno4,sizeof(int),1,afile) != 1)
SYSTEM_ERROR
dlen = anno4;
}
else
{ int64 anno8;
for (i = 0; i < tracklen; i++)
{ if (fread(&anno8,sizeof(int64),1,afile) != 1)
SYSTEM_ERROR
anno8 += trackoff;
fwrite(&anno8,sizeof(int64),1,aout);
}
if (fread(&anno8,sizeof(int64),1,afile) != 1)
SYSTEM_ERROR
dlen = anno8;
}
trackoff += dlen;
for (i = 1024; i < dlen; i += 1024)
{ if (fread(data,1024,1,dfile) != 1)
SYSTEM_ERROR
fwrite(data,1024,1,dout);
}
i -= 1024;
if (i < dlen)
{ if (fread(data,dlen-i,1,dfile) != 1)
SYSTEM_ERROR
fwrite(data,dlen-i,1,dout);
}
}
else
{ for (i = 0; i < tracklen; i++)
{ if (fread(anno,size,1,afile) != 1)
SYSTEM_ERROR
fwrite(anno,size,1,aout);
}
}
tracktot += tracklen;
nfiles += 1;
if (dfile != NULL) fclose(dfile);
fclose(afile);
}
if (nfiles == 0)
{ fprintf(stderr,"%s: Couldn't find first track block %s1.%s.anno\n",
Prog_Name,prefix,argv[2]);
goto error;
}
else
{ if (dout != NULL)
{ if (tracksiz == 4)
{ int anno4 = trackoff;
fwrite(&anno4,sizeof(int),1,aout);
}
else
{ int64 anno8 = trackoff;
fwrite(&anno8,sizeof(int64),1,aout);
}
}
else
{ fwrite(anno,tracksiz,1,aout);
free(anno);
}
rewind(aout);
fwrite(&tracktot,sizeof(int),1,aout);
fwrite(&tracksiz,sizeof(int),1,aout);
}
}
fclose(aout);
if (dout != NULL)
fclose(dout);
free(prefix);
exit (0);
error:
fclose(aout);
unlink(Catenate(prefix,argv[2],".","anno"));
if (dout != NULL)
{ fclose(dout);
unlink(Catenate(prefix,argv[2],".","data"));
}
free(prefix);
exit (1);
}
int main(int argc, char *argv[])
{ HITS_DB ablock, bblock, cblock;
char *afile, *bfile;
char *aroot, *broot;
Align_Spec *asettings;
int DUSTED;
int KMER_LEN;
int BIN_SHIFT;
int MAX_REPS;
int HIT_MIN;
double AVE_ERROR;
double MIN_ERROR;
int SPACING;
{ int i, j, k;
int flags[128];
char *eptr;
ARG_INIT("daligner")
KMER_LEN = 14;
HIT_MIN = 35;
BIN_SHIFT = 6;
MAX_REPS = 0;
AVE_ERROR = .70;
MIN_ERROR = .55;
SPACING = 100;
MINOVER = 1000; // Globally visible to filter.c
j = 1;
for (i = 1; i < argc; i++)
if (argv[i][0] == '-')
switch (argv[i][1])
{ default:
ARG_FLAGS("vbd")
break;
case 'k':
ARG_POSITIVE(KMER_LEN,"K-mer length")
break;
case 'w':
ARG_POSITIVE(BIN_SHIFT,"Log of bin width")
break;
case 'h':
ARG_POSITIVE(HIT_MIN,"Hit threshold (in bp.s)")
break;
case 't':
ARG_POSITIVE(MAX_REPS,"Tuple supression frequency")
break;
case 'e':
ARG_REAL(AVE_ERROR)
if (AVE_ERROR < .7 || AVE_ERROR >= 1.)
{ fprintf(stderr,"%s: Average correlation must be in [.7,1.) (%g)\n",
Prog_Name,AVE_ERROR);
exit (1);
}
break;
case 'm':
ARG_REAL(MIN_ERROR)
if (MIN_ERROR < .55 || MIN_ERROR >= 1.)
{ fprintf(stderr,"%s: Minimum correlation must be in [.55,1.) (%g)\n",
Prog_Name,MIN_ERROR);
exit (1);
}
break;
case 's':
ARG_POSITIVE(SPACING,"Trace spacing")
break;
case 'l':
ARG_POSITIVE(MINOVER,"Minimum alignment length")
break;
}
else
argv[j++] = argv[i];
argc = j;
VERBOSE = flags['v']; // Globally declared in filter.h
BIASED = flags['b']; // Globally declared in filter.h
DUSTED = flags['d'];
if (argc <= 2)
{ fprintf(stderr,"Usage: %s %s\n",Prog_Name,Usage[0]);
fprintf(stderr," %*s %s\n",(int) strlen(Prog_Name),"",Usage[1]);
fprintf(stderr," %*s %s\n",(int) strlen(Prog_Name),"",Usage[2]);
exit (1);
}
}
