int
main(int argc, char **argv) {
int illegal;
argc = AS_configure(argc, argv);
G.initialize();
int err=0;
int arg=1;
while (arg < argc) {
if (strcmp(argv[arg], "-G") == 0) {
G.Doing_Partial_Overlaps = TRUE;
} else if (strcmp(argv[arg], "-h") == 0) {
AS_UTL_decodeRange(argv[++arg], G.bgnHashID, G.endHashID);
} else if (strcmp(argv[arg], "-H") == 0) {
AS_UTL_decodeRange(argv[++arg], G.minLibToHash, G.maxLibToHash);
} else if (strcmp(argv[arg], "-r") == 0) {
AS_UTL_decodeRange(argv[++arg], G.bgnRefID, G.endRefID);
} else if (strcmp(argv[arg], "-R") == 0) {
AS_UTL_decodeRange(argv[++arg], G.minLibToRef, G.maxLibToRef);
} else if (strcmp(argv[arg], "-k") == 0) {
arg++;
if ((isdigit(argv[arg][0]) && (argv[arg][1] == 0)) ||
(isdigit(argv[arg][0]) && isdigit(argv[arg][1]) && (argv[arg][2] == 0))) {
G.Kmer_Len = strtoull(argv[arg], NULL, 10);
} else {
errno = 0;
G.Kmer_Skip_File = fopen(argv[arg], "r");
if (errno)
fprintf(stderr, "ERROR: Failed to open -k '%s': %s\n", argv[arg], strerror(errno)), exit(1);
}
} else if (strcmp(argv[arg], "-l") == 0) {
G.Frag_Olap_Limit = strtol(argv[++arg], NULL, 10);
if (G.Frag_Olap_Limit < 1)
G.Frag_Olap_Limit = UINT64_MAX;
} else if (strcmp(argv[arg], "-m") == 0) {
G.Unique_Olap_Per_Pair = FALSE;
} else if (strcmp(argv[arg], "-u") == 0) {
G.Unique_Olap_Per_Pair = TRUE;
} else if (strcmp(argv[arg], "--hashbits") == 0) {
G.Hash_Mask_Bits = strtoull(argv[++arg], NULL, 10);
} else if (strcmp(argv[arg], "--hashstrings") == 0) {
G.Max_Hash_Strings = strtoull(argv[++arg], NULL, 10);
} else if (strcmp(argv[arg], "--hashdatalen") == 0) {
G.Max_Hash_Data_Len = strtoull(argv[++arg], NULL, 10);
} else if (strcmp(argv[arg], "--hashload") == 0) {
G.Max_Hash_Load = atof(argv[++arg]);
} else if (strcmp(argv[arg], "--maxreadlen") == 0) {
// Quite the gross way to do this, but simple.
uint32 desired = strtoul(argv[++arg], NULL, 10);
OFFSET_BITS = 1;
while (((uint32)1 << OFFSET_BITS) < desired)
OFFSET_BITS++;
STRING_NUM_BITS = 30 - OFFSET_BITS;
STRING_NUM_MASK = (1 << STRING_NUM_BITS) - 1;
OFFSET_MASK = (1 << OFFSET_BITS) - 1;
MAX_STRING_NUM = STRING_NUM_MASK;
} else if (strcmp(argv[arg], "-o") == 0) {
G.Outfile_Name = argv[++arg];
} else if (strcmp(argv[arg], "-s") == 0) {
G.Outstat_Name = argv[++arg];
} else if (strcmp(argv[arg], "-t") == 0) {
G.Num_PThreads = strtoull(argv[++arg], NULL, 10);
} else if (strcmp(argv[arg], "--minlength") == 0) {
G.Min_Olap_Len = strtol (argv[++arg], NULL, 10);
} else if (strcmp(argv[arg], "--maxerate") == 0) {
G.maxErate = ceil(strtof(argv[++arg], NULL) * 100) / 100;
} else if (strcmp(argv[arg], "-w") == 0) {
G.Use_Window_Filter = TRUE;
} else if (strcmp(argv[arg], "-z") == 0) {
G.Use_Hopeless_Check = FALSE;
} else {
if (G.Frag_Store_Path == NULL) {
G.Frag_Store_Path = argv[arg];
} else {
fprintf(stderr, "Unknown option '%s'\n", argv[arg]);
err++;
}
}
arg++;
}
// Fix up some flags if we're allowing high error rates.
//
if (G.maxErate > 0.06) {
if (G.Use_Window_Filter)
fprintf(stderr, "High error rates requested -- window-filter turned off despite -w flag!\n");
G.Use_Window_Filter = FALSE;
G.Use_Hopeless_Check = FALSE;
}
if (G.Max_Hash_Strings == 0)
fprintf(stderr, "* No memory model supplied; -M needed!\n"), err++;
if (G.Kmer_Len == 0)
fprintf(stderr, "* No kmer length supplied; -k needed!\n"), err++;
if (G.Max_Hash_Strings > MAX_STRING_NUM)
fprintf(stderr, "Too many strings (--hashstrings), must be less than "F_U64"\n", MAX_STRING_NUM), err++;
if (G.Outfile_Name == NULL)
fprintf (stderr, "ERROR: No output file name specified\n"), err++;
if ((err) || (G.Frag_Store_Path == NULL)) {
fprintf(stderr, "USAGE: %s [options] <gkpStorePath>\n", argv[0]);
fprintf(stderr, "\n");
fprintf(stderr, "-b <fn> in contig mode, specify the output file\n");
fprintf(stderr, "-c contig mode. Use 2 frag stores. First is\n");
fprintf(stderr, " for reads; second is for contigs\n");
fprintf(stderr, "-G do partial overlaps\n");
fprintf(stderr, "-h <range> to specify fragments to put in hash table\n");
fprintf(stderr, " Implies LSF mode (no changes to frag store)\n");
fprintf(stderr, "-I designate a file of frag iids to limit olaps to\n");
fprintf(stderr, " (Contig mode only)\n");
fprintf(stderr, "-k if one or two digits, the length of a kmer, otherwise\n");
fprintf(stderr, " the filename containing a list of kmers to ignore in\n");
fprintf(stderr, " the hash table\n");
fprintf(stderr, "-l specify the maximum number of overlaps per\n");
fprintf(stderr, " fragment-end per batch of fragments.\n");
fprintf(stderr, "-m allow multiple overlaps per oriented fragment pair\n");
fprintf(stderr, "-M specify memory size. Valid values are '8GB', '4GB',\n");
fprintf(stderr, " '2GB', '1GB', '256MB'. (Not for Contig mode)\n");
fprintf(stderr, "-o specify output file name\n");
fprintf(stderr, "-P write protoIO output (if not -G)\n");
fprintf(stderr, "-r <range> specify old fragments to overlap\n");
fprintf(stderr, "-t <n> use <n> parallel threads\n");
fprintf(stderr, "-u allow only 1 overlap per oriented fragment pair\n");
fprintf(stderr, "-w filter out overlaps with too many errors in a window\n");
fprintf(stderr, "-z skip the hopeless check\n");
fprintf(stderr, "\n");
fprintf(stderr, "--maxerate <n> only output overlaps with fraction <n> or less error (e.g., 0.06 == 6%%)\n");
fprintf(stderr, "--minlength <n> only output overlaps of <n> or more bases\n");
fprintf(stderr, "\n");
fprintf(stderr, "--hashbits n Use n bits for the hash mask.\n");
fprintf(stderr, "--hashstrings n Load at most n strings into the hash table at one time.\n");
fprintf(stderr, "--hashdatalen n Load at most n bytes into the hash table at one time.\n");
fprintf(stderr, "--hashload f Load to at most 0.0 < f < 1.0 capacity (default 0.7).\n");
fprintf(stderr, "\n");
fprintf(stderr, "--maxreadlen n For batches with all short reads, pack bits differently to\n");
fprintf(stderr, " process more reads per batch.\n");
fprintf(stderr, " all reads must be shorter than n\n");
fprintf(stderr, " --hashstrings limited to 2^(30-m)\n");
fprintf(stderr, " Common values:\n");
fprintf(stderr, " maxreadlen 2048->hashstrings 524288 (default)\n");
fprintf(stderr, " maxreadlen 512->hashstrings 2097152\n");
fprintf(stderr, " maxreadlen 128->hashstrings 8388608\n");
fprintf(stderr, "\n");
fprintf(stderr, "--readsperbatch n Force batch size to n.\n");
fprintf(stderr, "--readsperthread n Force each thread to process n reads.\n");
fprintf(stderr, "\n");
exit(1);
}
Out_BOF = new ovFile(G.Outfile_Name, ovFileFullWrite);
// We know enough now to set the hash function variables, and some other random variables.
HSF1 = G.Kmer_Len - (G.Hash_Mask_Bits / 2);
HSF2 = 2 * G.Kmer_Len - G.Hash_Mask_Bits;
SV1 = HSF1 + 2;
SV2 = (HSF1 + HSF2) / 2;
SV3 = HSF2 - 2;
// Log parameters.
fprintf(stderr, "\n");
fprintf(stderr, "STRING_NUM_BITS "F_U32"\n", STRING_NUM_BITS);
fprintf(stderr, "OFFSET_BITS "F_U32"\n", OFFSET_BITS);
fprintf(stderr, "STRING_NUM_MASK "F_U64"\n", STRING_NUM_MASK);
fprintf(stderr, "OFFSET_MASK "F_U64"\n", OFFSET_MASK);
fprintf(stderr, "MAX_STRING_NUM "F_U64"\n", MAX_STRING_NUM);
fprintf(stderr, "\n");
fprintf(stderr, "Hash_Mask_Bits "F_U32"\n", G.Hash_Mask_Bits);
fprintf(stderr, "Max_Hash_Strings "F_U32"\n", G.Max_Hash_Strings);
fprintf(stderr, "Max_Hash_Data_Len "F_U64"\n", G.Max_Hash_Data_Len);
fprintf(stderr, "Max_Hash_Load %f\n", G.Max_Hash_Load);
fprintf(stderr, "Kmer Length "F_U64"\n", G.Kmer_Len);
fprintf(stderr, "Min Overlap Length %d\n", G.Min_Olap_Len);
fprintf(stderr, "Max Error Rate %f\n", G.maxErate);
fprintf(stderr, "\n");
fprintf(stderr, "Num_PThreads "F_U32"\n", G.Num_PThreads);
assert (8 * sizeof (uint64) > 2 * G.Kmer_Len);
Bit_Equivalent['a'] = Bit_Equivalent['A'] = 0;
Bit_Equivalent['c'] = Bit_Equivalent['C'] = 1;
Bit_Equivalent['g'] = Bit_Equivalent['G'] = 2;
Bit_Equivalent['t'] = Bit_Equivalent['T'] = 3;
for (int i = 0; i < 256; i ++) {
char ch = tolower ((char) i);
if (ch == 'a' || ch == 'c' || ch == 'g' || ch == 't')
Char_Is_Bad[i] = 0;
else
Char_Is_Bad[i] = 1;
}
fprintf(stderr, "\n");
fprintf(stderr, "HASH_TABLE_SIZE "F_U32"\n", HASH_TABLE_SIZE);
fprintf(stderr, "sizeof(Hash_Bucket_t) "F_SIZE_T"\n", sizeof(Hash_Bucket_t));
fprintf(stderr, "hash table size: "F_SIZE_T" MB\n", (HASH_TABLE_SIZE * sizeof(Hash_Bucket_t)) >> 20);
fprintf(stderr, "\n");
Hash_Table = new Hash_Bucket_t [HASH_TABLE_SIZE];
fprintf(stderr, "check "F_SIZE_T" MB\n", (HASH_TABLE_SIZE * sizeof (Check_Vector_t) >> 20));
fprintf(stderr, "info "F_SIZE_T" MB\n", (G.Max_Hash_Strings * sizeof (Hash_Frag_Info_t) >> 20));
fprintf(stderr, "start "F_SIZE_T" MB\n", (G.Max_Hash_Strings * sizeof (int64) >> 20));
fprintf(stderr, "\n");
Hash_Check_Array = new Check_Vector_t [HASH_TABLE_SIZE];
String_Info = new Hash_Frag_Info_t [G.Max_Hash_Strings];
String_Start = new int64 [G.Max_Hash_Strings];
String_Start_Size = G.Max_Hash_Strings;
memset(Hash_Check_Array, 0, sizeof(Check_Vector_t) * HASH_TABLE_SIZE);
memset(String_Info, 0, sizeof(Hash_Frag_Info_t) * G.Max_Hash_Strings);
memset(String_Start, 0, sizeof(int64) * G.Max_Hash_Strings);
OverlapDriver();
delete [] basesData;
delete [] qualsData;
delete [] nextRef;
delete [] String_Start;
delete [] String_Info;
delete [] Hash_Check_Array;
delete [] Hash_Table;
delete Out_BOF;
FILE *stats = stderr;
if (G.Outstat_Name != NULL) {
errno = 0;
stats = fopen(G.Outstat_Name, "w");
if (errno) {
fprintf(stderr, "WARNING: failed to open '%s' for writing: %s\n", G.Outstat_Name, strerror(errno));
stats = stderr;
}
}
fprintf(stats, " Kmer hits without olaps = "F_S64"\n", Kmer_Hits_Without_Olap_Ct);
fprintf(stats, " Kmer hits with olaps = "F_S64"\n", Kmer_Hits_With_Olap_Ct);
fprintf(stats, " Multiple overlaps/pair = "F_S64"\n", Multi_Overlap_Ct);
fprintf(stats, " Total overlaps produced = "F_S64"\n", Total_Overlaps);
fprintf(stats, " Contained overlaps = "F_S64"\n", Contained_Overlap_Ct);
fprintf(stats, " Dovetail overlaps = "F_S64"\n", Dovetail_Overlap_Ct);
fprintf(stats, "Rejected by short window = "F_S64"\n", Bad_Short_Window_Ct);
fprintf(stats, " Rejected by long window = "F_S64"\n", Bad_Long_Window_Ct);
if (stats != stderr)
fclose(stats);
return(0);
}
int
main(int argc, char **argv) {
char bolfile_name[FILENAME_MAX] = {0};
char Outfile_Name[FILENAME_MAX] = {0};
int illegal;
char * p;
argc = AS_configure(argc, argv);
Min_Olap_Len = AS_OVERLAP_MIN_LEN; // set after configure
int err=0;
int arg=1;
while (arg < argc) {
if (strcmp(argv[arg], "-G") == 0) {
Doing_Partial_Overlaps = TRUE;
} else if (strcmp(argv[arg], "-h") == 0) {
AS_UTL_decodeRange(argv[++arg], Lo_Hash_Frag, Hi_Hash_Frag);
} else if (strcmp(argv[arg], "-H") == 0) {
AS_UTL_decodeRange(argv[++arg], minLibToHash, maxLibToHash);
} else if (strcmp(argv[arg], "-R") == 0) {
AS_UTL_decodeRange(argv[++arg], minLibToRef, maxLibToRef);
} else if (strcmp(argv[arg], "-k") == 0) {
arg++;
if ((isdigit(argv[arg][0]) && (argv[arg][1] == 0)) ||
(isdigit(argv[arg][0]) && isdigit(argv[arg][1]) && (argv[arg][2] == 0))) {
Kmer_Len = strtoull(argv[arg], NULL, 10);
} else {
errno = 0;
Kmer_Skip_File = fopen(argv[arg], "r");
if (errno)
fprintf(stderr, "ERROR: Failed to open -k '%s': %s\n", argv[arg], strerror(errno)), exit(1);
}
} else if (strcmp(argv[arg], "-l") == 0) {
Frag_Olap_Limit = strtol(argv[++arg], NULL, 10);
if (Frag_Olap_Limit < 1)
Frag_Olap_Limit = INT_MAX;
} else if (strcmp(argv[arg], "-m") == 0) {
Unique_Olap_Per_Pair = FALSE;
} else if (strcmp(argv[arg], "--hashbits") == 0) {
Hash_Mask_Bits = strtoull(argv[++arg], NULL, 10);
} else if (strcmp(argv[arg], "--hashstrings") == 0) {
Max_Hash_Strings = strtoull(argv[++arg], NULL, 10);
} else if (strcmp(argv[arg], "--hashdatalen") == 0) {
Max_Hash_Data_Len = strtoull(argv[++arg], NULL, 10);
} else if (strcmp(argv[arg], "--hashload") == 0) {
Max_Hash_Load = atof(argv[++arg]);
} else if (strcmp(argv[arg], "--maxreadlen") == 0) {
// Quite the gross way to do this, but simple.
uint32 desired = strtoul(argv[++arg], NULL, 10);
OFFSET_BITS = 1;
while (((uint32)1 << OFFSET_BITS) < desired)
OFFSET_BITS++;
STRING_NUM_BITS = 30 - OFFSET_BITS;
STRING_NUM_MASK = (1 << STRING_NUM_BITS) - 1;
OFFSET_MASK = (1 << OFFSET_BITS) - 1;
MAX_STRING_NUM = STRING_NUM_MASK;
} else if (strcmp(argv[arg], "--readsperbatch") == 0) {
Max_Reads_Per_Batch = strtoul(argv[++arg], NULL, 10);
} else if (strcmp(argv[arg], "--readsperthread") == 0) {
Max_Reads_Per_Thread = strtoul(argv[++arg], NULL, 10);
} else if (strcmp(argv[arg], "-o") == 0) {
strcpy(Outfile_Name, argv[++arg]);
} else if (strcmp(argv[arg], "-r") == 0) {
AS_UTL_decodeRange(argv[++arg], Lo_Old_Frag, Hi_Old_Frag);
} else if (strcmp(argv[arg], "-t") == 0) {
Num_PThreads = strtoull(argv[++arg], NULL, 10);
} else if (strcmp(argv[arg], "-u") == 0) {
Unique_Olap_Per_Pair = TRUE;
} else if (strcmp(argv[arg], "-v") == 0) {
Min_Olap_Len = (int) strtol (argv[++arg], & p, 10);
} else if (strcmp(argv[arg], "-w") == 0) {
Use_Window_Filter = TRUE;
} else if (strcmp(argv[arg], "-x") == 0) {
Ignore_Clear_Range = TRUE;
} else if (strcmp(argv[arg], "-z") == 0) {
Use_Hopeless_Check = FALSE;
} else {
if (Frag_Store_Path == NULL) {
Frag_Store_Path = argv[arg];
} else {
fprintf(stderr, "Unknown option '%s'\n", argv[arg]);
err++;
}
}
arg++;
}
// Fix up some flags if we're allowing high error rates.
//
if (AS_OVL_ERROR_RATE > 0.06) {
if (Use_Window_Filter)
fprintf(stderr, "High error rates requested -- window-filter turned off despite -w flag!\n");
Use_Window_Filter = FALSE;
Use_Hopeless_Check = FALSE;
}
if (Max_Hash_Strings == 0)
fprintf(stderr, "* No memory model supplied; -M needed!\n"), err++;
if (Kmer_Len == 0)
fprintf(stderr, "* No kmer length supplied; -k needed!\n"), err++;
if (Max_Hash_Strings > MAX_STRING_NUM)
fprintf(stderr, "Too many strings (--hashstrings), must be less than "F_U64"\n", MAX_STRING_NUM), err++;
if (Outfile_Name[0] == 0)
fprintf (stderr, "ERROR: No output file name specified\n"), err++;
if ((err) || (Frag_Store_Path == NULL)) {
fprintf(stderr, "USAGE: %s [options] <gkpStorePath>\n", argv[0]);
fprintf(stderr, "\n");
fprintf(stderr, "-b <fn> in contig mode, specify the output file\n");
fprintf(stderr, "-c contig mode. Use 2 frag stores. First is\n");
fprintf(stderr, " for reads; second is for contigs\n");
fprintf(stderr, "-G do partial overlaps\n");
fprintf(stderr, "-h <range> to specify fragments to put in hash table\n");
fprintf(stderr, " Implies LSF mode (no changes to frag store)\n");
fprintf(stderr, "-I designate a file of frag iids to limit olaps to\n");
fprintf(stderr, " (Contig mode only)\n");
fprintf(stderr, "-k if one or two digits, the length of a kmer, otherwise\n");
fprintf(stderr, " the filename containing a list of kmers to ignore in\n");
fprintf(stderr, " the hash table\n");
fprintf(stderr, "-l specify the maximum number of overlaps per\n");
fprintf(stderr, " fragment-end per batch of fragments.\n");
fprintf(stderr, "-m allow multiple overlaps per oriented fragment pair\n");
fprintf(stderr, "-M specify memory size. Valid values are '8GB', '4GB',\n");
fprintf(stderr, " '2GB', '1GB', '256MB'. (Not for Contig mode)\n");
fprintf(stderr, "-o specify output file name\n");
fprintf(stderr, "-P write protoIO output (if not -G)\n");
fprintf(stderr, "-r <range> specify old fragments to overlap\n");
fprintf(stderr, "-s ignore screen information with fragments\n");
fprintf(stderr, "-t <n> use <n> parallel threads\n");
fprintf(stderr, "-u allow only 1 overlap per oriented fragment pair\n");
fprintf(stderr, "-v <n> only output overlaps of <n> or more bases\n");
fprintf(stderr, "-w filter out overlaps with too many errors in a window\n");
fprintf(stderr, "-x ignore the clear ranges on reads and use the \n");
fprintf(stderr, " full sequence\n");
fprintf(stderr, "-z skip the hopeless check\n");
fprintf(stderr, "\n");
fprintf(stderr, "--hashbits n Use n bits for the hash mask.\n");
fprintf(stderr, "--hashstrings n Load at most n strings into the hash table at one time.\n");
fprintf(stderr, "--hashdatalen n Load at most n bytes into the hash table at one time.\n");
fprintf(stderr, "--hashload f Load to at most 0.0 < f < 1.0 capacity (default 0.7).\n");
fprintf(stderr, "\n");
fprintf(stderr, "--maxreadlen n For batches with all short reads, pack bits differently to\n");
fprintf(stderr, " process more reads per batch.\n");
fprintf(stderr, " all reads must be shorter than n\n");
fprintf(stderr, " --hashstrings limited to 2^(30-m)\n");
fprintf(stderr, " Common values:\n");
fprintf(stderr, " maxreadlen 2048 -> hashstrings 524288 (default)\n");
fprintf(stderr, " maxreadlen 512 -> hashstrings 2097152\n");
fprintf(stderr, " maxreadlen 128 -> hashstrings 8388608\n");
fprintf(stderr, "\n");
fprintf(stderr, "--readsperbatch n Force batch size to n.\n");
fprintf(stderr, "--readsperthread n Force each thread to process n reads.\n");
fprintf(stderr, "\n");
exit(1);
}
assert(NULL == Out_BOF);
Out_BOF = AS_OVS_createBinaryOverlapFile(Outfile_Name, FALSE);
// Adjust the number of reads to load into memory at once (for processing, not the hash table),
if (Max_Reads_Per_Batch == 0)
Max_Reads_Per_Batch = (Max_Hash_Strings < 100000) ? Max_Hash_Strings : 100000;
//if (Max_Hash_Strings < Max_Reads_Per_Batch)
// Max_Reads_Per_Batch = Max_Hash_Strings;
// Adjust the number of reads processed per thread. Default to having four blocks per thread,
// but make sure that (a) all threads have work to do, and (b) batches are not minuscule.
if (Max_Reads_Per_Thread == 0)
Max_Reads_Per_Thread = Max_Reads_Per_Batch / (4 * Num_PThreads);
if (Max_Reads_Per_Thread * Num_PThreads > Max_Reads_Per_Batch)
Max_Reads_Per_Thread = Max_Reads_Per_Batch / Num_PThreads + 1;
if (Max_Reads_Per_Thread < 10)
Max_Reads_Per_Thread = 10;
// We know enough now to set the hash function variables, and some other random variables.
HSF1 = Kmer_Len - (Hash_Mask_Bits / 2);
HSF2 = 2 * Kmer_Len - Hash_Mask_Bits;
SV1 = HSF1 + 2;
SV2 = (HSF1 + HSF2) / 2;
SV3 = HSF2 - 2;
Branch_Match_Value = (Doing_Partial_Overlaps) ? PARTIAL_BRANCH_MATCH_VAL : DEFAULT_BRANCH_MATCH_VAL;
Branch_Error_Value = Branch_Match_Value - 1.0;
fprintf(stderr, "\n");
fprintf(stderr, "STRING_NUM_BITS "F_U32"\n", STRING_NUM_BITS);
fprintf(stderr, "OFFSET_BITS "F_U32"\n", OFFSET_BITS);
fprintf(stderr, "STRING_NUM_MASK "F_U64"\n", STRING_NUM_MASK);
fprintf(stderr, "OFFSET_MASK "F_U64"\n", OFFSET_MASK);
fprintf(stderr, "MAX_STRING_NUM "F_U64"\n", MAX_STRING_NUM);
fprintf(stderr, "\n");
fprintf(stderr, "Hash_Mask_Bits "F_U32"\n", Hash_Mask_Bits);
fprintf(stderr, "Max_Hash_Strings "F_U32"\n", Max_Hash_Strings);
fprintf(stderr, "Max_Hash_Data_Len "F_U64"\n", Max_Hash_Data_Len);
fprintf(stderr, "Max_Hash_Load %f\n", Max_Hash_Load);
fprintf(stderr, "Kmer Length %d\n", (int)Kmer_Len);
fprintf(stderr, "Min Overlap Length %d\n", Min_Olap_Len);
fprintf(stderr, "MAX_ERRORS %d\n", MAX_ERRORS);
fprintf(stderr, "ERRORS_FOR_FREE %d\n", ERRORS_FOR_FREE);
fprintf(stderr, "\n");
fprintf(stderr, "Num_PThreads "F_U32"\n", Num_PThreads);
fprintf(stderr, "Max_Reads_Per_Batch "F_U32"\n", Max_Reads_Per_Batch);
fprintf(stderr, "Max_Reads_Per_Thread "F_U32"\n", Max_Reads_Per_Thread);
assert (8 * sizeof (uint64) > 2 * Kmer_Len);
Initialize_Globals ();
OldFragStore = new gkStore(Frag_Store_Path, FALSE, FALSE);
/****************************************/
OverlapDriver();
/****************************************/
fprintf (stderr, " Kmer hits without olaps = "F_S64"\n", Kmer_Hits_Without_Olap_Ct);
fprintf (stderr, " Kmer hits with olaps = "F_S64"\n", Kmer_Hits_With_Olap_Ct);
fprintf (stderr, " Multiple overlaps/pair = "F_S64"\n", Multi_Overlap_Ct);
fprintf (stderr, " Total overlaps produced = "F_S64"\n", Total_Overlaps);
fprintf (stderr, " Contained overlaps = "F_S64"\n", Contained_Overlap_Ct);
fprintf (stderr, " Dovetail overlaps = "F_S64"\n", Dovetail_Overlap_Ct);
fprintf (stderr, "Rejected by short window = "F_S64"\n", Bad_Short_Window_Ct);
fprintf (stderr, " Rejected by long window = "F_S64"\n", Bad_Long_Window_Ct);
delete OldFragStore;
AS_OVS_closeBinaryOverlapFile(Out_BOF);
return(0);
}
