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); }