static FILE* _open_histogram_file(const char *path, const char *name)
{
FILE *fout;
status("[cleaning] Writing %s distribution to: %s", name, futil_outpath_str(path));
if(strcmp(path,"-") == 0) return stdout;
if((fout = fopen(path, "w")) == NULL)
warn("Couldn't write %s distribution to file: %s", name, path);
return fout;
}
// Open file
// if cannot open file returns 0
// if fatal is true, exits on error
// if !fatal, returns -1 on error
// if successful creates a new GraphFileReader and returns 1
int graph_file_open2(GraphFileReader *file, const char *input, const char *mode,
size_t into_offset)
{
GraphFileHeader *hdr = &file->hdr;
FileFilter *fltr = &file->fltr;
file_filter_open(fltr, input); // calls die() on error
const char *path = fltr->path.b;
// Stat will fail on streams, so file_size and num_of_kmers with both be -1
struct stat st;
file->file_size = -1;
file->num_of_kmers = -1;
if(strcmp(input,"-") != 0) {
if(stat(path, &st) == 0) file->file_size = st.st_size;
else warn("Couldn't get file size: %s", futil_outpath_str(path));
}
file->fh = futil_fopen(path, mode);
file->hdr_size = graph_file_read_header(file->fh, hdr, path);
file_filter_set_cols(fltr, hdr->num_of_cols, into_offset);
// Check we can handle the kmer size
db_graph_check_kmer_size(file->hdr.kmer_size, file->fltr.path.b);
size_t bytes_per_kmer, bytes_remaining;
// If reading from STDIN we don't know file size
if(file->file_size != -1)
{
// File header checks
// Get number of kmers
bytes_per_kmer = sizeof(BinaryKmer) +
hdr->num_of_cols * (sizeof(Covg) + sizeof(Edges));
bytes_remaining = (size_t)(file->file_size - file->hdr_size);
file->num_of_kmers = (bytes_remaining / bytes_per_kmer);
if(bytes_remaining % bytes_per_kmer != 0) {
warn("Truncated graph file: %s [bytes per kmer: %zu "
"remaining: %zu; fsize: %zu; header: %zu; nkmers: %zu]",
path, bytes_per_kmer, bytes_remaining,
(size_t)file->file_size, (size_t)file->hdr_size,
(size_t)file->num_of_kmers);
}
}
return 1;
}
/*!
@see futil_open()
*/
gzFile futil_gzopen(const char *path, const char *mode)
{
ctx_assert(strcmp(path, "-") != 0 || strcmp(mode,"w") == 0);
gzFile gzout = strcmp(path, "-") == 0 ? gzdopen(fileno(stdout), mode)
: gzopen(path, mode);
if(gzout == NULL)
die("Cannot open gzfile: %s [%s]", futil_outpath_str(path), strerror(errno));
// Set buffer size
#if ZLIB_VERNUM >= 0x1240
gzbuffer(gzout, DEFAULT_IO_BUFSIZE);
#endif
return gzout;
}
/*!
Open a file and set the buffer to be DEFAULT_IO_BUFSIZE. Call die() if cannot
open the file.
@param path If "-" return stdout
@param mode one of: "r","rw","rw+","a"
*/
FILE *futil_fopen(const char *path, const char *mode)
{
FILE *fout;
if(path == NULL || strcmp(path,"-") == 0) {
if(!strcmp(mode,"w")) fout = stdout;
else if(!strcmp(mode,"r")) fout = stdin;
else die("Cannot open pipe with mode: %s", mode);
}
else if((fout = fopen(path, mode)) == NULL) {
die("Cannot open file: %s [%s]", futil_outpath_str(path), strerror(errno));
}
// Set buffer size
setvbuf(fout, NULL, _IOFBF, DEFAULT_IO_BUFSIZE);
return fout;
}
int ctx_thread(int argc, char **argv)
{
struct ReadThreadCmdArgs args;
read_thread_args_alloc(&args);
read_thread_args_parse(&args, argc, argv, longopts, false);
GraphFileReader *gfile = &args.gfile;
GPathFileBuffer *gpfiles = &args.gpfiles;
CorrectAlnInputBuffer *inputs = &args.inputs;
size_t i;
if(args.zero_link_counts && gpfiles->len == 0)
cmd_print_usage("-0,--zero-paths without -p,--paths <in.ctp> has no meaning");
// Check each path file only loads one colour
gpaths_only_for_colour(gpfiles->b, gpfiles->len, 0);
//
// Decide on memory
//
size_t bits_per_kmer, kmers_in_hash, graph_mem, total_mem;
size_t path_hash_mem, path_store_mem, path_mem;
bool sep_path_list = (!args.use_new_paths && gpfiles->len > 0);
bits_per_kmer = sizeof(BinaryKmer)*8 + sizeof(Edges)*8 + sizeof(GPath*)*8 +
2 * args.nthreads; // Have traversed
// false -> don't use mem_to_use to decide how many kmers to store in hash
// since we need some of that memory for storing paths
kmers_in_hash = cmd_get_kmers_in_hash(args.memargs.mem_to_use,
args.memargs.mem_to_use_set,
args.memargs.num_kmers,
args.memargs.num_kmers_set,
bits_per_kmer,
gfile->num_of_kmers,
gfile->num_of_kmers,
false, &graph_mem);
// Paths memory
size_t min_path_mem = 0;
gpath_reader_sum_mem(gpfiles->b, gpfiles->len, 1, true, true, &min_path_mem);
if(graph_mem + min_path_mem > args.memargs.mem_to_use) {
char buf[50];
die("Require at least %s memory", bytes_to_str(graph_mem+min_path_mem, 1, buf));
}
path_mem = args.memargs.mem_to_use - graph_mem;
size_t pentry_hash_mem = sizeof(GPEntry)/0.7;
size_t pentry_store_mem = sizeof(GPath) + 8 + // struct + sequence
1 + // in colour
sizeof(uint8_t) + // counts
sizeof(uint32_t); // kmer length
size_t max_paths = path_mem / (pentry_store_mem + pentry_hash_mem);
path_store_mem = max_paths * pentry_store_mem;
path_hash_mem = max_paths * pentry_hash_mem;
cmd_print_mem(path_hash_mem, "paths hash");
cmd_print_mem(path_store_mem, "paths store");
total_mem = graph_mem + path_mem;
cmd_check_mem_limit(args.memargs.mem_to_use, total_mem);
//
// Open output file
//
gzFile gzout = futil_gzopen_create(args.out_ctp_path, "w");
status("Creating paths file: %s", futil_outpath_str(args.out_ctp_path));
//
// Allocate memory
//
dBGraph db_graph;
size_t kmer_size = gfile->hdr.kmer_size;
db_graph_alloc(&db_graph, kmer_size, 1, 1, kmers_in_hash,
DBG_ALLOC_EDGES | DBG_ALLOC_NODE_IN_COL);
// Split path memory 2:1 between store and hash
// Create a path store that tracks path counts
gpath_store_alloc(&db_graph.gpstore,
db_graph.num_of_cols, db_graph.ht.capacity,
0, path_store_mem, true, sep_path_list);
// Create path hash table for fast lookup
gpath_hash_alloc(&db_graph.gphash, &db_graph.gpstore, path_hash_mem);
if(args.use_new_paths) {
status("Using paths as they are added (risky)");
} else {
status("Not using new paths as they are added (safe)");
}
//
// Start up workers to add paths to the graph
//
GenPathWorker *workers;
workers = gen_paths_workers_alloc(args.nthreads, &db_graph);
// Setup for loading graphs graph
LoadingStats gstats;
loading_stats_init(&gstats);
// Path statistics
LoadingStats *load_stats = gen_paths_get_stats(workers);
CorrectAlnStats *aln_stats = gen_paths_get_aln_stats(workers);
// Load contig hist distribution
for(i = 0; i < gpfiles->len; i++) {
gpath_reader_load_contig_hist(gpfiles->b[i].json,
gpfiles->b[i].fltr.path.b,
file_filter_fromcol(&gpfiles->b[i].fltr, 0),
&aln_stats->contig_histgrm);
}
GraphLoadingPrefs gprefs = {.db_graph = &db_graph,
.boolean_covgs = false,
.must_exist_in_graph = false,
.must_exist_in_edges = NULL,
.empty_colours = false}; // already loaded paths
// Load graph, print stats, close file
graph_load(gfile, gprefs, &gstats);
hash_table_print_stats_brief(&db_graph.ht);
graph_file_close(gfile);
// Load existing paths
for(i = 0; i < gpfiles->len; i++)
gpath_reader_load(&gpfiles->b[i], GPATH_DIE_MISSING_KMERS, &db_graph);
// zero link counts of already loaded links
if(args.zero_link_counts) {
status("Zeroing link counts for loaded links");
gpath_set_zero_nseen(&db_graph.gpstore.gpset);
}
if(!args.use_new_paths)
gpath_store_split_read_write(&db_graph.gpstore);
// Deal with a set of files at once
// Can have different numbers of inputs vs threads
size_t start, end;
for(start = 0; start < inputs->len; start += MAX_IO_THREADS)
{
end = MIN2(inputs->len, start+MAX_IO_THREADS);
generate_paths(inputs->b+start, end-start, workers, args.nthreads);
}
// Print memory statistics
gpath_hash_print_stats(&db_graph.gphash);
gpath_store_print_stats(&db_graph.gpstore);
correct_aln_dump_stats(aln_stats, load_stats,
args.dump_seq_sizes,
args.dump_frag_sizes,
db_graph.ht.num_kmers);
// Don't need GPathHash anymore
gpath_hash_dealloc(&db_graph.gphash);
cJSON **hdrs = ctx_malloc(gpfiles->len * sizeof(cJSON*));
for(i = 0; i < gpfiles->len; i++) hdrs[i] = gpfiles->b[i].json;
size_t output_threads = MIN2(args.nthreads, MAX_IO_THREADS);
// Generate a cJSON header for all inputs
cJSON *thread_hdr = cJSON_CreateObject();
cJSON *inputs_hdr = cJSON_CreateArray();
cJSON_AddItemToObject(thread_hdr, "inputs", inputs_hdr);
for(i = 0; i < inputs->len; i++)
cJSON_AddItemToArray(inputs_hdr, correct_aln_input_json_hdr(&inputs->b[i]));
// Write output file
gpath_save(gzout, args.out_ctp_path, output_threads, true,
"thread", thread_hdr, hdrs, gpfiles->len,
&aln_stats->contig_histgrm, 1,
&db_graph);
gzclose(gzout);
ctx_free(hdrs);
// Optionally run path checks for debugging
// gpath_checks_all_paths(&db_graph, args.nthreads);
// ins_gap, err_gap no longer allocated after this line
gen_paths_workers_dealloc(workers, args.nthreads);
// Close and free input files etc.
read_thread_args_dealloc(&args);
db_graph_dealloc(&db_graph);
return EXIT_SUCCESS;
}
int ctx_calls2vcf(int argc, char **argv)
{
const char *in_path = NULL, *out_path = NULL, *out_type = NULL;
// Filtering parameters
int32_t min_mapq = -1, max_align_len = -1, max_allele_len = -1;
// Alignment parameters
int nwmatch = 1, nwmismatch = -2, nwgapopen = -4, nwgapextend = -1;
// ref paths
char const*const* ref_paths = NULL;
size_t nref_paths = 0;
// flank file
const char *sam_path = NULL;
//
// Things we figure out by looking at the input
//
bool isbubble = false;
// samples in VCF, (0 for bubble, does not include ref in breakpoint calls)
size_t i, kmer_size, num_samples;
//
// Reference genome
//
// Hash map of chromosome name -> sequence
ChromHash *genome;
ReadBuffer chroms;
// Arg parsing
char cmd[100];
char shortopts[300];
cmd_long_opts_to_short(longopts, shortopts, sizeof(shortopts));
int c;
// silence error messages from getopt_long
// opterr = 0;
while((c = getopt_long_only(argc, argv, shortopts, longopts, NULL)) != -1) {
cmd_get_longopt_str(longopts, c, cmd, sizeof(cmd));
switch(c) {
case 0: /* flag set */ break;
case 'h': cmd_print_usage(NULL); break;
case 'o': cmd_check(!out_path, cmd); out_path = optarg; break;
case 'O': cmd_check(!out_type, cmd); out_type = optarg; break;
case 'f': cmd_check(!futil_get_force(), cmd); futil_set_force(true); break;
case 'F': cmd_check(!sam_path,cmd); sam_path = optarg; break;
case 'Q': cmd_check(min_mapq < 0,cmd); min_mapq = cmd_uint32(cmd, optarg); break;
case 'A': cmd_check(max_align_len < 0,cmd); max_align_len = cmd_uint32(cmd, optarg); break;
case 'L': cmd_check(max_allele_len < 0,cmd); max_allele_len = cmd_uint32(cmd, optarg); break;
case 'm': nwmatch = cmd_int32(cmd, optarg); break;
case 'M': nwmismatch = cmd_int32(cmd, optarg); break;
case 'g': nwgapopen = cmd_int32(cmd, optarg); break;
case 'G': nwgapextend = cmd_int32(cmd, optarg); break;
case ':': /* BADARG */
case '?': /* BADCH getopt_long has already printed error */
die("`"CMD" "SUBCMD" -h` for help. Bad option: %s", argv[optind-1]);
default: ctx_assert2(0, "shouldn't reach here: %c", c);
}
}
// Defaults for unset values
if(out_path == NULL) out_path = "-";
if(max_align_len < 0) max_align_len = DEFAULT_MAX_ALIGN;
if(max_allele_len < 0) max_allele_len = DEFAULT_MAX_ALLELE;
if(optind+2 > argc)
cmd_print_usage("Require <in.txt.gz> and at least one reference");
in_path = argv[optind++];
ref_paths = (char const*const*)argv + optind;
nref_paths = argc - optind;
// These functions call die() on error
gzFile gzin = futil_gzopen(in_path, "r");
// Read call file header
cJSON *json = json_hdr_load(gzin, in_path);
// Check we can handle the kmer size
kmer_size = json_hdr_get_kmer_size(json, in_path);
db_graph_check_kmer_size(kmer_size, in_path);
// Get format (bubble or breakpoint file)
cJSON *json_fmt = json_hdr_get(json, "file_format", cJSON_String, in_path);
if(strcmp(json_fmt->valuestring,"CtxBreakpoints") == 0) isbubble = false;
else if(strcmp(json_fmt->valuestring,"CtxBubbles") == 0) isbubble = true;
else die("Unknown format: '%s'", json_fmt->valuestring);
status("Reading %s in %s format", futil_inpath_str(in_path),
isbubble ? "bubble" : "breakpoint");
if(isbubble) {
// bubble specific
if(sam_path == NULL)
cmd_print_usage("Require -F <flanks.sam> with bubble file");
if(min_mapq < 0) min_mapq = DEFAULT_MIN_MAPQ;
}
else {
// breakpoint specific
if(min_mapq >= 0)
cmd_print_usage("-Q,--min-mapq <Q> only valid with bubble calls");
}
// Open flank file if it exists
htsFile *samfh = NULL;
bam_hdr_t *bam_hdr = NULL;
bam1_t *mflank = NULL;
if(sam_path)
{
if((samfh = hts_open(sam_path, "r")) == NULL)
die("Cannot open SAM/BAM %s", sam_path);
// Load BAM header
bam_hdr = sam_hdr_read(samfh);
if(bam_hdr == NULL) die("Cannot load BAM header: %s", sam_path);
mflank = bam_init1();
}
// Output VCF has 0 samples if bubbles file, otherwise has N where N is
// number of samples/colours in the breakpoint graph
size_t num_graph_samples = json_hdr_get_ncols(json, in_path);
size_t num_graph_nonref = json_hdr_get_nonref_ncols(json, in_path);
num_samples = 0;
if(!isbubble) {
// If last colour has "is_ref", drop number of samples by one
num_samples = num_graph_nonref < num_graph_samples ? num_graph_samples-1
: num_graph_samples;
}
//
// Open output file
//
if(!out_path) out_path = "-";
int mode = vcf_misc_get_outtype(out_type, out_path);
futil_create_output(out_path);
htsFile *vcffh = hts_open(out_path, modes_htslib[mode]);
status("[calls2vcf] Reading %s call file with %zu samples",
isbubble ? "Bubble" : "Breakpoint", num_graph_samples);
status("[calls2vcf] %zu sample output to: %s format: %s",
num_samples, futil_outpath_str(out_path), hsmodes_htslib[mode]);
if(isbubble) status("[calls2vcf] min. MAPQ: %i", min_mapq);
status("[calls2vcf] max alignment length: %i", max_align_len);
status("[calls2vcf] max VCF allele length: %i", max_allele_len);
status("[calls2vcf] alignment match:%i mismatch:%i gap open:%i extend:%i",
nwmatch, nwmismatch, nwgapopen, nwgapextend);
// Load reference genome
read_buf_alloc(&chroms, 1024);
genome = chrom_hash_init();
chrom_hash_load(ref_paths, nref_paths, &chroms, genome);
// convert to upper case
char *s;
for(i = 0; i < chroms.len; i++)
for(s = chroms.b[i].seq.b; *s; s++) *s = toupper(*s);
if(!isbubble) brkpnt_check_refs_match(json, genome, in_path);
bcf_hdr_t *vcfhdr = make_vcf_hdr(json, in_path, !isbubble, kmer_size,
ref_paths, nref_paths,
chroms.b, chroms.len);
if(bcf_hdr_write(vcffh, vcfhdr) != 0) die("Cannot write VCF header");
AlignedCall *call = acall_init();
CallDecomp *aligner = call_decomp_init(vcffh, vcfhdr);
scoring_t *scoring = call_decomp_get_scoring(aligner);
scoring_init(scoring, nwmatch, nwmismatch, nwgapopen, nwgapextend,
false, false, 0, 0, 0, 0);
CallFileEntry centry;
call_file_entry_alloc(¢ry);
char kmer_str[50];
sprintf(kmer_str, ";K%zu", kmer_size);
if(isbubble)
{
// Bubble calls
DecompBubble *bubbles = decomp_bubble_init();
// Set scoring for aligning 3' flank
scoring = decomp_bubble_get_scoring(bubbles);
scoring_init(scoring, nwmatch, nwmismatch, nwgapopen, nwgapextend,
true, true, 0, 0, 0, 0);
while(call_file_read(gzin, in_path, ¢ry)) {
do {
if(sam_read1(samfh, bam_hdr, mflank) < 0)
die("We've run out of SAM entries!");
} while(mflank->core.flag & (BAM_FSECONDARY | BAM_FSUPPLEMENTARY));
// Align call
strbuf_reset(&call->info);
decomp_bubble_call(bubbles, genome, kmer_size, min_mapq,
¢ry, mflank, bam_hdr, call);
strbuf_append_str(&call->info, kmer_str);
acall_decompose(aligner, call, max_align_len, max_allele_len);
}
// print bubble stats
DecompBubbleStats *bub_stats = ctx_calloc(1, sizeof(*bub_stats));
decomp_bubble_cpy_stats(bub_stats, bubbles);
print_bubble_stats(bub_stats);
ctx_free(bub_stats);
decomp_bubble_destroy(bubbles);
}
else
{
// Breakpoint calls
DecompBreakpoint *breakpoints = decomp_brkpt_init();
while(call_file_read(gzin, in_path, ¢ry)) {
strbuf_reset(&call->info);
decomp_brkpt_call(breakpoints, genome, num_samples, ¢ry, call);
strbuf_append_str(&call->info, kmer_str);
acall_decompose(aligner, call, max_align_len, max_allele_len);
}
// print bubble stats
DecompBreakpointStats *brk_stats = ctx_calloc(1, sizeof(*brk_stats));
decomp_brkpt_cpy_stats(brk_stats, breakpoints);
print_breakpoint_stats(brk_stats);
ctx_free(brk_stats);
decomp_brkpt_destroy(breakpoints);
}
// Print stats
DecomposeStats *astats = ctx_calloc(1, sizeof(*astats));
call_decomp_cpy_stats(astats, aligner);
print_acall_stats(astats);
ctx_free(astats);
call_file_entry_dealloc(¢ry);
call_decomp_destroy(aligner);
acall_destroy(call);
// Finished - clean up
cJSON_Delete(json);
gzclose(gzin);
bcf_hdr_destroy(vcfhdr);
hts_close(vcffh);
for(i = 0; i < chroms.len; i++) seq_read_dealloc(&chroms.b[i]);
read_buf_dealloc(&chroms);
chrom_hash_destroy(genome);
if(sam_path) {
hts_close(samfh);
bam_hdr_destroy(bam_hdr);
bam_destroy1(mflank);
}
return EXIT_SUCCESS;
}
int ctx_rmsubstr(int argc, char **argv)
{
struct MemArgs memargs = MEM_ARGS_INIT;
size_t kmer_size = 0, nthreads = 0;
const char *output_file = NULL;
seq_format fmt = SEQ_FMT_FASTA;
bool invert = false;
// Arg parsing
char cmd[100], shortopts[100];
cmd_long_opts_to_short(longopts, shortopts, sizeof(shortopts));
int c;
while((c = getopt_long_only(argc, argv, shortopts, longopts, NULL)) != -1) {
cmd_get_longopt_str(longopts, c, cmd, sizeof(cmd));
switch(c) {
case 0: /* flag set */ break;
case 'h': cmd_print_usage(NULL); break;
case 'f': cmd_check(!futil_get_force(), cmd); futil_set_force(true); break;
case 'o': cmd_check(!output_file, cmd); output_file = optarg; break;
case 't': cmd_check(!nthreads, cmd); nthreads = cmd_uint32_nonzero(cmd, optarg); break;
case 'm': cmd_mem_args_set_memory(&memargs, optarg); break;
case 'n': cmd_mem_args_set_nkmers(&memargs, optarg); break;
case 'k': cmd_check(!kmer_size,cmd); kmer_size = cmd_uint32(cmd, optarg); break;
case 'F': cmd_check(fmt==SEQ_FMT_FASTA, cmd); fmt = cmd_parse_format(cmd, optarg); break;
case 'v': cmd_check(!invert,cmd); invert = true; break;
case ':': /* BADARG */
case '?': /* BADCH getopt_long has already printed error */
// cmd_print_usage(NULL);
cmd_print_usage("`"CMD" rmsubstr -h` for help. Bad option: %s", argv[optind-1]);
default: abort();
}
}
// Defaults
if(!nthreads) nthreads = DEFAULT_NTHREADS;
if(!kmer_size) kmer_size = DEFAULT_KMER;
if(!(kmer_size&1)) cmd_print_usage("Kmer size must be odd");
if(kmer_size < MIN_KMER_SIZE) cmd_print_usage("Kmer size too small (recompile)");
if(kmer_size > MAX_KMER_SIZE) cmd_print_usage("Kmer size too large (recompile?)");
if(optind >= argc)
cmd_print_usage("Please specify at least one input sequence file (.fq, .fq etc.)");
size_t i, num_seq_files = argc - optind;
char **seq_paths = argv + optind;
seq_file_t **seq_files = ctx_calloc(num_seq_files, sizeof(seq_file_t*));
for(i = 0; i < num_seq_files; i++)
if((seq_files[i] = seq_open(seq_paths[i])) == NULL)
die("Cannot read sequence file %s", seq_paths[i]);
// Estimate number of bases
// set to -1 if we cannot calc
int64_t est_num_bases = seq_est_seq_bases(seq_files, num_seq_files);
if(est_num_bases < 0) {
warn("Cannot get file sizes, using pipes");
est_num_bases = memargs.num_kmers * IDEAL_OCCUPANCY;
}
status("[memory] Estimated number of bases: %li", (long)est_num_bases);
// Use file sizes to decide on memory
//
// Decide on memory
//
size_t bits_per_kmer, kmers_in_hash, graph_mem;
bits_per_kmer = sizeof(BinaryKmer)*8 +
sizeof(KONodeList) + sizeof(KOccur) + // see kmer_occur.h
8; // 1 byte per kmer for each base to load sequence files
kmers_in_hash = cmd_get_kmers_in_hash(memargs.mem_to_use,
memargs.mem_to_use_set,
memargs.num_kmers,
memargs.num_kmers_set,
bits_per_kmer,
est_num_bases, est_num_bases,
false, &graph_mem);
cmd_check_mem_limit(memargs.mem_to_use, graph_mem);
//
// Open output file
//
if(output_file == NULL) output_file = "-";
FILE *fout = futil_fopen_create(output_file, "w");
//
// Set up memory
//
dBGraph db_graph;
db_graph_alloc(&db_graph, kmer_size, 1, 0, kmers_in_hash, DBG_ALLOC_BKTLOCKS);
//
// Load reference sequence into a read buffer
//
ReadBuffer rbuf;
read_buf_alloc(&rbuf, 1024);
seq_load_all_reads(seq_files, num_seq_files, &rbuf);
// Check for reads too short
for(i = 0; i < rbuf.len && rbuf.b[i].seq.end >= kmer_size; i++) {}
if(i < rbuf.len)
warn("Reads shorter than kmer size (%zu) will not be filtered", kmer_size);
KOGraph kograph = kograph_create(rbuf.b, rbuf.len, true, 0,
nthreads, &db_graph);
size_t num_reads = rbuf.len, num_reads_printed = 0, num_bad_reads = 0;
// Loop over reads printing those that are not substrings
int ret;
for(i = 0; i < rbuf.len; i++) {
ret = _is_substr(&rbuf, i, &kograph, &db_graph);
if(ret == -1) num_bad_reads++;
else if((ret && invert) || (!ret && !invert)) {
seqout_print_read(&rbuf.b[i], fmt, fout);
num_reads_printed++;
}
}
char num_reads_str[100], num_reads_printed_str[100], num_bad_reads_str[100];
ulong_to_str(num_reads, num_reads_str);
ulong_to_str(num_reads_printed, num_reads_printed_str);
ulong_to_str(num_bad_reads, num_bad_reads_str);
status("Printed %s / %s (%.1f%%) to %s",
num_reads_printed_str, num_reads_str,
!num_reads ? 0.0 : (100.0 * num_reads_printed) / num_reads,
futil_outpath_str(output_file));
if(num_bad_reads > 0) {
status("Bad reads: %s / %s (%.1f%%) - no kmer {ACGT} of length %zu",
num_bad_reads_str, num_reads_str,
(100.0 * num_bad_reads) / num_reads,
kmer_size);
}
fclose(fout);
kograph_dealloc(&kograph);
// Free sequence memory
for(i = 0; i < rbuf.len; i++) seq_read_dealloc(&rbuf.b[i]);
read_buf_dealloc(&rbuf);
ctx_free(seq_files);
db_graph_dealloc(&db_graph);
return EXIT_SUCCESS;
}
// Returns 0 on success, otherwise != 0
int ctx_unitigs(int argc, char **argv)
{
size_t nthreads = 0;
struct MemArgs memargs = MEM_ARGS_INIT;
const char *out_path = NULL;
UnitigSyntax syntax = PRINT_FASTA;
bool dot_use_points = false;
// Arg parsing
char cmd[100];
char shortopts[300];
cmd_long_opts_to_short(longopts, shortopts, sizeof(shortopts));
int c;
// silence error messages from getopt_long
// opterr = 0;
while((c = getopt_long_only(argc, argv, shortopts, longopts, NULL)) != -1) {
cmd_get_longopt_str(longopts, c, cmd, sizeof(cmd));
switch(c) {
case 0: /* flag set */ break;
case 'h': cmd_print_usage(NULL); break;
case 'f': cmd_check(!futil_get_force(), cmd); futil_set_force(true); break;
case 'o': cmd_check(!out_path, cmd); out_path = optarg; break;
case 't': cmd_check(!nthreads, cmd); nthreads = cmd_uint32_nonzero(cmd, optarg); break;
case 'm': cmd_mem_args_set_memory(&memargs, optarg); break;
case 'n': cmd_mem_args_set_nkmers(&memargs, optarg); break;
case 'F': cmd_check(!syntax, cmd); syntax = PRINT_FASTA; break;
case 'g': cmd_check(!syntax, cmd); syntax = PRINT_GFA; break;
case 'd': cmd_check(!syntax, cmd); syntax = PRINT_DOT; break;
case 'P': cmd_check(!dot_use_points, cmd); dot_use_points = true; break;
case ':': /* BADARG */
case '?': /* BADCH getopt_long has already printed error */
die("`"CMD" unitigs -h` for help. Bad option: %s", argv[optind-1]);
default: abort();
}
}
if(dot_use_points && syntax == PRINT_FASTA)
cmd_print_usage("--point is only for use with --dot");
// Defaults for unset values
if(out_path == NULL) out_path = "-";
if(nthreads == 0) nthreads = DEFAULT_NTHREADS;
if(optind >= argc) cmd_print_usage(NULL);
size_t i, num_gfiles = (size_t)(argc - optind);
char **gfile_paths = argv + optind;
if(dot_use_points && syntax != PRINT_DOT)
cmd_print_usage("--points only valid with --graphviz / --dot");
ctx_assert(num_gfiles > 0);
// Open graph files
GraphFileReader *gfiles = ctx_calloc(num_gfiles, sizeof(GraphFileReader));
size_t ctx_max_kmers = 0, ctx_sum_kmers = 0;
graph_files_open(gfile_paths, gfiles, num_gfiles,
&ctx_max_kmers, &ctx_sum_kmers);
//
// Decide on memory
//
size_t bits_per_kmer, kmers_in_hash, graph_mem;
bits_per_kmer = sizeof(BinaryKmer)*8 + sizeof(Edges)*8 + 1;
if(syntax != PRINT_FASTA) bits_per_kmer += sizeof(UnitigEnd) * 8;
kmers_in_hash = cmd_get_kmers_in_hash(memargs.mem_to_use,
memargs.mem_to_use_set,
memargs.num_kmers,
memargs.num_kmers_set,
bits_per_kmer,
ctx_max_kmers, ctx_sum_kmers,
true, &graph_mem);
cmd_check_mem_limit(memargs.mem_to_use, graph_mem);
status("Output in %s format to %s\n", syntax_strs[syntax],
futil_outpath_str(out_path));
//
// Open output file
//
// Print to stdout unless --out <out> is specified
FILE *fout = futil_fopen_create(out_path, "w");
//
// Allocate memory
//
dBGraph db_graph;
db_graph_alloc(&db_graph, gfiles[0].hdr.kmer_size, 1, 1, kmers_in_hash,
DBG_ALLOC_EDGES);
UnitigPrinter printer;
unitig_printer_init(&printer, &db_graph, nthreads, syntax, fout);
if(syntax == PRINT_DOT || syntax == PRINT_GFA)
unitig_graph_alloc(&printer.ugraph, &db_graph);
// Load graphs
GraphLoadingPrefs gprefs = {.db_graph = &db_graph,
.boolean_covgs = false,
.must_exist_in_graph = false,
.empty_colours = false};
for(i = 0; i < num_gfiles; i++) {
file_filter_flatten(&gfiles[i].fltr, 0);
graph_load(&gfiles[i], gprefs, NULL);
graph_file_close(&gfiles[i]);
}
ctx_free(gfiles);
hash_table_print_stats(&db_graph.ht);
switch(syntax)
{
case PRINT_FASTA:
status("Printing unitgs in FASTA using %zu threads", nthreads);
supernodes_iterate(nthreads, printer.visited, &db_graph,
print_unitig_fasta, &printer);
break;
case PRINT_GFA:
print_gfa_syntax(&printer);
break;
case PRINT_DOT:
print_dot_syntax(&printer, dot_use_points);
break;
default:
die("Invalid print syntax: %i", syntax);
}
char num_unitigs_str[50];
ulong_to_str(printer.num_unitigs, num_unitigs_str);
status("Dumped %s unitigs\n", num_unitigs_str);
fclose(fout);
unitig_printer_destroy(&printer);
db_graph_dealloc(&db_graph);
return EXIT_SUCCESS;
}
int ctx_calls2vcf(int argc, char **argv)
{
parse_cmdline_args(argc, argv);
size_t i;
// These functions call die() on error
gzFile gzin = futil_gzopen(input_path, "r");
nw_aligner_setup();
// Read file header
cJSON *json = read_input_header(gzin);
// Get format (bubble or breakpoint file)
cJSON *json_fmt = json_hdr_get(json, "file_format", cJSON_String, input_path);
if(strcmp(json_fmt->valuestring,"CtxBreakpoints") == 0) input_bubble_format = false;
else if(strcmp(json_fmt->valuestring,"CtxBubbles") == 0) input_bubble_format = true;
else die("Unknown format: '%s'", json_fmt->valuestring);
status("Reading %s in %s format", futil_inpath_str(input_path),
input_bubble_format ? "bubble" : "breakpoint");
if(input_bubble_format && sam_path == NULL)
cmd_print_usage("Require -F <flanks.sam> with bubble file");
// Open flank file if it exists
if(sam_path) flanks_sam_open();
// Open output file
FILE *fout = futil_fopen_create(out_path, "w");
// Load reference genome
read_buf_alloc(&chroms, 1024);
genome = kh_init(ChromHash);
seq_reader_load_ref_genome(ref_paths, num_ref_paths, &chroms, genome);
// convert to upper case
char *s;
for(i = 0; i < chroms.len; i++)
for(s = chroms.b[i].seq.b; *s; s++) *s = toupper(*s);
if(!input_bubble_format) brkpnt_check_refs_match(json, input_path);
// Output VCF has 0 samples if bubbles file, otherwise has N where N is
// number of samples/colours in the breakpoint graph
size_t num_graph_samples = json_hdr_get_ncols(json, input_path);
size_t num_graph_nonref = json_hdr_get_nonref_ncols(json, input_path);
num_samples = 0;
if(!input_bubble_format) {
// If last colour has "is_ref", drop number of samples by one
num_samples = num_graph_nonref < num_graph_samples ? num_graph_samples-1
: num_graph_samples;
}
print_vcf_header(json, !input_bubble_format, fout);
status("Reading %s call file with %zu samples",
input_bubble_format ? "Bubble" : "Breakpoint", num_graph_samples);
status("Writing a VCF with %zu samples", num_samples);
parse_entries(gzin, fout);
// Print stats
char num_entries_read_str[50];
char num_vars_printed_str[50];
ulong_to_str(num_entries_read, num_entries_read_str);
ulong_to_str(num_vars_printed, num_vars_printed_str);
status("Read %s entries, printed %s vcf entries to: %s",
num_entries_read_str, num_vars_printed_str, futil_outpath_str(out_path));
if(input_bubble_format) {
char msg[200];
// Bubble caller specific
print_stat(num_flank5p_unmapped, num_entries_read, "flank 5p unmapped");
sprintf(msg, "flank 5p low mapq (<%zu)", min_mapq);
print_stat(num_flank5p_lowqual, num_entries_read, msg);
print_stat(num_flank3p_not_found, num_entries_read, "flank 3p not found");
print_stat(num_flank3p_multihits, num_entries_read, "flank 3p multiple hits");
print_stat(num_flank3p_approx_match,num_entries_read, "flank 3p approx match used");
print_stat(num_flank3p_exact_match, num_entries_read, "flank 3p exact match");
} else {
// Breakpoint caller specific
print_stat(num_flanks_not_uniquely_mapped, num_entries_read, "flank pairs contain one flank not mapped uniquely");
print_stat(num_flanks_diff_chroms, num_entries_read, "flank pairs map to diff chroms");
print_stat(num_flanks_diff_strands, num_entries_read, "flank pairs map to diff strands");
}
print_stat(num_flanks_too_far_apart, num_entries_read, "flank pairs too far apart");
print_stat(num_flanks_overlap_too_large, num_entries_read, "flank pairs overlap too much");
print_stat(num_entries_well_mapped, num_entries_read, "flank pairs map well");
status("Aligned %zu allele pairs and %zu flanks", num_nw_allele, num_nw_flank);
// Finished - clean up
cJSON_Delete(json);
gzclose(gzin);
fclose(fout);
for(i = 0; i < chroms.len; i++) seq_read_dealloc(&chroms.b[i]);
read_buf_dealloc(&chroms);
kh_destroy_ChromHash(genome);
nw_aligner_destroy();
if(sam_path) flanks_sam_close();
// hide unused method warnings
(void)kh_del_ChromHash;
(void)kh_put_ChromHash;
(void)kh_get_ChromHash;
(void)kh_clear_ChromHash;
(void)kh_destroy_ChromHash;
(void)kh_init_ChromHash;
return EXIT_SUCCESS;
}
int ctx_vcfcov(int argc, char **argv)
{
struct MemArgs memargs = MEM_ARGS_INIT;
const char *out_path = NULL, *out_type = NULL;
uint32_t max_allele_len = 0, max_gt_vars = 0;
char *ref_path = NULL;
bool low_mem = false;
// Arg parsing
char cmd[100];
char shortopts[300];
cmd_long_opts_to_short(longopts, shortopts, sizeof(shortopts));
int c;
size_t i;
// silence error messages from getopt_long
// opterr = 0;
while((c = getopt_long_only(argc, argv, shortopts, longopts, NULL)) != -1) {
cmd_get_longopt_str(longopts, c, cmd, sizeof(cmd));
switch(c) {
case 0: /* flag set */ break;
case 'h': cmd_print_usage(NULL); break;
case 'o': cmd_check(!out_path, cmd); out_path = optarg; break;
case 'O': cmd_check(!out_type, cmd); out_type = optarg; break;
case 'f': cmd_check(!futil_get_force(), cmd); futil_set_force(true); break;
case 'm': cmd_mem_args_set_memory(&memargs, optarg); break;
case 'n': cmd_mem_args_set_nkmers(&memargs, optarg); break;
case 'r': cmd_check(!ref_path, cmd); ref_path = optarg; break;
case 'L': cmd_check(!max_allele_len,cmd); max_allele_len = cmd_uint32(cmd,optarg); break;
case 'N': cmd_check(!max_gt_vars,cmd); max_gt_vars = cmd_uint32(cmd,optarg); break;
case 'M': cmd_check(!low_mem, cmd); low_mem = true; break;
case ':': /* BADARG */
case '?': /* BADCH getopt_long has already printed error */
// cmd_print_usage(NULL);
die("`"CMD" "SUBCMD" -h` for help. Bad option: %s", argv[optind-1]);
default: abort();
}
}
// Defaults for unset values
if(out_path == NULL) out_path = "-";
if(ref_path == NULL) cmd_print_usage("Require a reference (-r,--ref <ref.fa>)");
if(optind+2 > argc) cmd_print_usage("Require VCF and graph files");
if(!max_allele_len) max_allele_len = DEFAULT_MAX_ALLELE_LEN;
if(!max_gt_vars) max_gt_vars = DEFAULT_MAX_GT_VARS;
status("[vcfcov] max allele length: %u; max number of variants: %u",
max_allele_len, max_gt_vars);
// open ref
// index fasta with: samtools faidx ref.fa
faidx_t *fai = fai_load(ref_path);
if(fai == NULL) die("Cannot load ref index: %s / %s.fai", ref_path, ref_path);
// Open input VCF file
const char *vcf_path = argv[optind++];
htsFile *vcffh = hts_open(vcf_path, "r");
if(vcffh == NULL) die("Cannot open VCF file: %s", vcf_path);
bcf_hdr_t *vcfhdr = bcf_hdr_read(vcffh);
if(vcfhdr == NULL) die("Cannot read VCF header: %s", vcf_path);
// Test we can close and reopen files
if(low_mem) {
if((vcffh = hts_open(vcf_path, "r")) == NULL)
die("Cannot re-open VCF file: %s", vcf_path);
if((vcfhdr = bcf_hdr_read(vcffh)) == NULL)
die("Cannot re-read VCF header: %s", vcf_path);
}
//
// Open graph files
//
const size_t num_gfiles = argc - optind;
char **graph_paths = argv + optind;
ctx_assert(num_gfiles > 0);
GraphFileReader *gfiles = ctx_calloc(num_gfiles, sizeof(GraphFileReader));
size_t ncols, ctx_max_kmers = 0, ctx_sum_kmers = 0;
ncols = graph_files_open(graph_paths, gfiles, num_gfiles,
&ctx_max_kmers, &ctx_sum_kmers);
// Check graph + paths are compatible
graphs_gpaths_compatible(gfiles, num_gfiles, NULL, 0, -1);
//
// Decide on memory
//
size_t bits_per_kmer, kmers_in_hash, graph_mem;
bits_per_kmer = sizeof(BinaryKmer)*8 + sizeof(Covg)*8 * ncols;
kmers_in_hash = cmd_get_kmers_in_hash(memargs.mem_to_use,
memargs.mem_to_use_set,
memargs.num_kmers,
memargs.num_kmers_set,
bits_per_kmer,
low_mem ? -1 : (int64_t)ctx_max_kmers,
ctx_sum_kmers,
true, &graph_mem);
cmd_check_mem_limit(memargs.mem_to_use, graph_mem);
//
// Open output file
//
// v=>vcf, z=>compressed vcf, b=>bcf, bu=>uncompressed bcf
int mode = vcf_misc_get_outtype(out_type, out_path);
futil_create_output(out_path);
htsFile *outfh = hts_open(out_path, modes_htslib[mode]);
status("[vcfcov] Output format: %s", hsmodes_htslib[mode]);
// Allocate memory
dBGraph db_graph;
db_graph_alloc(&db_graph, gfiles[0].hdr.kmer_size, ncols, 1, kmers_in_hash,
DBG_ALLOC_COVGS);
//
// Set up tag names
//
// *R => ref, *A => alt
sprintf(kcov_ref_tag, "K%zuR", db_graph.kmer_size); // mean coverage
sprintf(kcov_alt_tag, "K%zuA", db_graph.kmer_size);
// #SAMPLE=<ID=...,K29KCOV=...,K29NK=...,K29RLK>
// - K29_kcov is empirical kmer coverage
// - K29_nkmers is the number of kmers in the sample
// - mean_read_length is the mean read length in bases
char sample_kcov_tag[20], sample_nk_tag[20], sample_rlk_tag[20];
sprintf(sample_kcov_tag, "K%zu_kcov", db_graph.kmer_size); // mean coverage
sprintf(sample_nk_tag, "K%zu_nkmers", db_graph.kmer_size);
sprintf(sample_rlk_tag, "mean_read_length");
//
// Load kmers if we are using --low-mem
//
VcfCovStats st;
memset(&st, 0, sizeof(st));
VcfCovPrefs prefs = {.kcov_ref_tag = kcov_ref_tag,
.kcov_alt_tag = kcov_alt_tag,
.max_allele_len = max_allele_len,
.max_gt_vars = max_gt_vars,
.load_kmers_only = false};
if(low_mem)
{
status("[vcfcov] Loading kmers from VCF+ref");
prefs.load_kmers_only = true;
vcfcov_file(vcffh, vcfhdr, NULL, NULL, vcf_path, fai,
NULL, &prefs, &st, &db_graph);
// Close files
hts_close(vcffh);
bcf_hdr_destroy(vcfhdr);
// Re-open files
if((vcffh = hts_open(vcf_path, "r")) == NULL)
die("Cannot re-open VCF file: %s", vcf_path);
if((vcfhdr = bcf_hdr_read(vcffh)) == NULL)
die("Cannot re-read VCF header: %s", vcf_path);
prefs.load_kmers_only = false;
}
//
// Load graphs
//
GraphLoadingStats gstats;
memset(&gstats, 0, sizeof(gstats));
GraphLoadingPrefs gprefs = graph_loading_prefs(&db_graph);
gprefs.must_exist_in_graph = low_mem;
for(i = 0; i < num_gfiles; i++) {
graph_load(&gfiles[i], gprefs, &gstats);
graph_file_close(&gfiles[i]);
}
ctx_free(gfiles);
hash_table_print_stats(&db_graph.ht);
//
// Set up VCF header / graph matchup
//
size_t *samplehdrids = ctx_malloc(db_graph.num_of_cols * sizeof(size_t));
// Add samples to vcf header
bcf_hdr_t *outhdr = bcf_hdr_dup(vcfhdr);
bcf_hrec_t *hrec;
int sid;
char hdrstr[200];
for(i = 0; i < db_graph.num_of_cols; i++) {
char *sname = db_graph.ginfo[i].sample_name.b;
if((sid = bcf_hdr_id2int(outhdr, BCF_DT_SAMPLE, sname)) < 0) {
bcf_hdr_add_sample(outhdr, sname);
sid = bcf_hdr_id2int(outhdr, BCF_DT_SAMPLE, sname);
}
samplehdrids[i] = sid;
// Add SAMPLE field
hrec = bcf_hdr_get_hrec(outhdr, BCF_HL_STR, "ID", sname, "SAMPLE");
if(hrec == NULL) {
sprintf(hdrstr, "##SAMPLE=<ID=%s,%s=%"PRIu64",%s=%"PRIu64",%s=%zu>", sname,
sample_kcov_tag,
gstats.nkmers[i] ? gstats.sumcov[i] / gstats.nkmers[i] : 0,
sample_nk_tag, gstats.nkmers[i],
sample_rlk_tag, (size_t)db_graph.ginfo[i].mean_read_length);
bcf_hdr_append(outhdr, hdrstr);
}
else {
// mean kcovg
sprintf(hdrstr, "%"PRIu64, gstats.sumcov[i] / gstats.nkmers[i]);
vcf_misc_add_update_hrec(hrec, sample_kcov_tag, hdrstr);
// num kmers
sprintf(hdrstr, "%"PRIu64, gstats.nkmers[i]);
vcf_misc_add_update_hrec(hrec, sample_nk_tag, hdrstr);
// mean read length in kmers
sprintf(hdrstr, "%zu", (size_t)db_graph.ginfo[i].mean_read_length);
vcf_misc_add_update_hrec(hrec, sample_rlk_tag, hdrstr);
}
status("[vcfcov] Colour %zu: %s [VCF column %zu]", i, sname, samplehdrids[i]);
}
// Add genotype format fields
// One field per alternative allele
sprintf(hdrstr, "##FORMAT=<ID=%s,Number=A,Type=Integer,"
"Description=\"Coverage on ref (k=%zu): sum(kmer_covs) / exp_num_kmers\">\n",
kcov_ref_tag, db_graph.kmer_size);
bcf_hdr_append(outhdr, hdrstr);
sprintf(hdrstr, "##FORMAT=<ID=%s,Number=A,Type=Integer,"
"Description=\"Coverage on alt (k=%zu): sum(kmer_covs) / exp_num_kmers\">\n",
kcov_alt_tag, db_graph.kmer_size);
bcf_hdr_append(outhdr, hdrstr);
bcf_hdr_set_version(outhdr, "VCFv4.2");
// Add command string to header
vcf_misc_hdr_add_cmd(outhdr, cmd_get_cmdline(), cmd_get_cwd());
if(bcf_hdr_write(outfh, outhdr) != 0)
die("Cannot write header to: %s", futil_outpath_str(out_path));
status("[vcfcov] Reading %s and adding coverage", vcf_path);
// Reset stats and get coverage
memset(&st, 0, sizeof(st));
vcfcov_file(vcffh, vcfhdr, outfh, outhdr, vcf_path, fai,
samplehdrids, &prefs, &st, &db_graph);
// Print statistics
char ns0[50], ns1[50];
status("[vcfcov] Read %s VCF lines", ulong_to_str(st.nvcf_lines, ns0));
status("[vcfcov] Read %s ALTs", ulong_to_str(st.nalts_read, ns0));
status("[vcfcov] Used %s kmers", ulong_to_str(st.ngt_kmers, ns0));
status("[vcfcov] ALTs used: %s / %s (%.2f%%)",
ulong_to_str(st.nalts_loaded, ns0), ulong_to_str(st.nalts_read, ns1),
st.nalts_read ? (100.0*st.nalts_loaded) / st.nalts_read : 0.0);
status("[vcfcov] ALTs too long (>%ubp): %s / %s (%.2f%%)", max_allele_len,
ulong_to_str(st.nalts_too_long, ns0), ulong_to_str(st.nalts_read, ns1),
st.nalts_read ? (100.0*st.nalts_too_long) / st.nalts_read : 0.0);
status("[vcfcov] ALTs too dense (>%u within %zubp): %s / %s (%.2f%%)",
max_gt_vars, db_graph.kmer_size,
ulong_to_str(st.nalts_no_covg, ns0), ulong_to_str(st.nalts_read, ns1),
st.nalts_read ? (100.0*st.nalts_no_covg) / st.nalts_read : 0.0);
status("[vcfcov] ALTs printed with coverage: %s / %s (%.2f%%)",
ulong_to_str(st.nalts_with_covg, ns0), ulong_to_str(st.nalts_read, ns1),
st.nalts_read ? (100.0*st.nalts_with_covg) / st.nalts_read : 0.0);
status("[vcfcov] Saved to: %s\n", out_path);
ctx_free(samplehdrids);
graph_loading_stats_destroy(&gstats);
bcf_hdr_destroy(vcfhdr);
bcf_hdr_destroy(outhdr);
hts_close(vcffh);
hts_close(outfh);
fai_destroy(fai);
db_graph_dealloc(&db_graph);
return EXIT_SUCCESS;
}