static void error_cleaning_init(ErrorCleaning *ec)
{
ec->cleaned_tips = ec->cleaned_snodes = ec->cleaned_kmers = false;
ec->clean_snodes_thresh = ec->clean_kmers_thresh = 0;
ec->is_graph_intersection = false;
strbuf_set(&ec->intersection_name, "undefined");
}
// Remember to free the result
void futil_get_strbuf_of_dir_path(const char *path, StrBuf *dir)
{
char *tmp = strdup(path);
strbuf_set(dir, dirname(tmp));
strbuf_append_char(dir, '/');
ctx_free(tmp);
}
void graph_info_init(GraphInfo *ginfo)
{
strbuf_set(&ginfo->sample_name, "undefined");
ginfo->total_sequence = 0;
ginfo->mean_read_length = 0;
ginfo->seq_err = 0.01;
error_cleaning_init(&ginfo->cleaning);
}
void graph_info_cpy(GraphInfo *dst, const GraphInfo *src)
{
dst->mean_read_length = src->mean_read_length;
dst->total_sequence = src->total_sequence;
dst->seq_err = src->seq_err;
strbuf_set(&dst->sample_name, src->sample_name.buff);
error_cleaning_cpy(&dst->cleaning, &src->cleaning);
}
int main(int argc, char **argv)
{
(void)argc; (void)argv;
cortex_init();
cmd_init(argc, argv);
if(argc != 3) die("usage: ./debug <in.ctp> <in.ctx>");
const char *out_path = argv[2];
GPathReader pfile;
memset(&pfile, 0, sizeof(GPathReader));
gpath_reader_open(&pfile, argv[1], true);
status("Got file with %zu colours", pfile.ncolours);
size_t i, kmer_size = 7, ncols = 3;
gpath_reader_check(&pfile, kmer_size, ncols);
gzFile gzout = futil_gzopen_create(out_path, "w");
dBGraph db_graph;
db_graph_alloc(&db_graph, kmer_size, ncols, 1, 1024, DBG_ALLOC_EDGES);
// Create a path store that tracks path counts
gpath_store_alloc(&db_graph.gpstore,
db_graph.num_of_cols, db_graph.ht.capacity,
ONE_MEGABYTE, true, false);
// Create path hash table for fast lookup
gpath_hash_alloc(&db_graph.gphash, &db_graph.gpstore, ONE_MEGABYTE);
// Set sample names
for(i = 0; i < pfile.ncolours; i++) {
const char *sample_name = gpath_reader_get_sample_name(&pfile, i);
ctx_assert(sample_name != NULL);
strbuf_set(&db_graph.ginfo[i].sample_name, sample_name);
}
// Load path files, add kmers that are missing
gpath_reader_load(&pfile, GPATH_ADD_MISSING_KMERS, &db_graph);
hash_table_print_stats(&db_graph.ht);
// Write output file
gpath_save(gzout, out_path, 1, true, NULL, NULL, &pfile.json, 1, &db_graph);
gzclose(gzout);
// Checks
// gpath_checks_all_paths(&db_graph, 2); // use two threads
gpath_checks_counts(&db_graph);
// Clean up
gpath_reader_close(&pfile);
db_graph_dealloc(&db_graph);
cortex_destroy();
return EXIT_SUCCESS;
}
static int req_set_response_cb(lua_State *L)
{
lwan_request_t *request = userdata_as_request(L, 1);
size_t response_str_len;
const char *response_str = lua_tolstring(L, -1, &response_str_len);
strbuf_set(request->response.buffer, response_str, response_str_len);
return 0;
}
static void error_cleaning_cpy(ErrorCleaning *dst, const ErrorCleaning *src)
{
dst->cleaned_tips = src->cleaned_tips;
dst->cleaned_snodes = src->cleaned_snodes;
dst->cleaned_kmers = src->cleaned_kmers;
dst->clean_snodes_thresh = src->clean_snodes_thresh;
dst->clean_kmers_thresh = src->clean_kmers_thresh;
dst->is_graph_intersection = src->is_graph_intersection;
strbuf_set(&dst->intersection_name, src->intersection_name.buff);
}
void graph_info_append_intersect(ErrorCleaning *cleaning, const char *intersect_name)
{
if(!cleaning->is_graph_intersection)
{
strbuf_set(&cleaning->intersection_name, intersect_name);
}
else
{
strbuf_append_char(&cleaning->intersection_name, ',');
strbuf_append_str(&cleaning->intersection_name, intersect_name);
}
cleaning->is_graph_intersection = true;
}
// Parse path and create FileFilter, calls die() with msg on error
// fltr should be zero'd before call
void file_filter_open(FileFilter *fltr, const char *path)
{
const char *path_start, *path_end;
size_t path_len;
// Duplicate input string and file path
strbuf_set(&fltr->input, path);
file_filter_deconstruct_path(path, &path_start, &path_end);
path_len = path_end - path_start;
strbuf_ensure_capacity(&fltr->path, path_len);
memcpy(fltr->path.b, path_start, path_len);
fltr->path.b[fltr->path.end = path_len] = '\0';
}
void graph_info_merge(GraphInfo *dst, const GraphInfo *src)
{
// Update sample name
if(strcmp(src->sample_name.buff,"undefined") != 0) {
if(strcmp(dst->sample_name.buff,"undefined") == 0) {
strbuf_set(&dst->sample_name, src->sample_name.buff);
} else {
strbuf_append_char(&dst->sample_name, ',');
strbuf_append_str(&dst->sample_name, src->sample_name.buff);
}
}
uint64_t total_sequence = dst->total_sequence + src->total_sequence;
if(total_sequence > 0)
{
// Average error rates
dst->seq_err
= (dst->seq_err * dst->total_sequence +
src->seq_err * src->total_sequence) /
total_sequence;
// Update mean read length
size_t src_num_contigs = 0;
if(src->total_sequence && src->mean_read_length)
src_num_contigs = ((double)src->total_sequence/src->mean_read_length)+0.5;
graph_info_update_contigs(dst, src->total_sequence, src_num_contigs);
}
// Update error cleaning
error_cleaning_merge(&dst->cleaning, &src->cleaning);
dst->total_sequence = total_sequence;
}
// If seq2 is NULL, read pair of entries from first file
// Otherwise read an entry from each
void align_from_file(const char *path1, const char *path2,
void (align)(StrBuf*, StrBuf*, const char*, const char*))
{
SeqFile *sf1 = seq_file_open(path1);
SeqFile *sf2;
if(sf1 == NULL)
{
fprintf(stderr, "Alignment Error: couldn't open file %s\n", path1);
fflush(stderr);
return;
}
if(path2 != NULL)
{
sf2 = seq_file_open(path2);
if(sf2 == NULL)
{
fprintf(stderr, "Alignment Error: couldn't open file %s\n", path1);
fflush(stderr);
return;
}
}
else
{
sf2 = sf1;
}
StrBuf *entry1_title = strbuf_new();
StrBuf *entry2_title = strbuf_new();
StrBuf *entry1_seq = strbuf_new();
StrBuf *entry2_seq = strbuf_new();
char *title1 = NULL, *title2 = NULL;
// Loop while we can read a sequence from the first file
while(seq_next_read(sf1))
{
seq_read_all_bases(sf1, entry1_seq);
if(seq_file_get_type(sf1) != SEQ_PLAIN)
{
strbuf_set(entry1_title, seq_get_read_name(sf1));
title1 = entry1_title->buff;
}
if(!seq_next_read(sf2))
{
fprintf(stderr, "Alignment Error: Odd number of sequences - "
"I read in pairs!\n");
fflush(stderr);
break;
}
seq_read_all_bases(sf2, entry2_seq);
if(seq_file_get_type(sf2) != SEQ_PLAIN)
{
strbuf_set(entry2_title, seq_get_read_name(sf2));
title2 = entry2_title->buff;
}
(align)(entry1_seq, entry2_seq, title1, title2);
}
// warn if no bases read
if(seq_total_bases_passed(sf1) == 0)
{
fprintf(stderr, "Alignment Warning: empty input\n");
fflush(stderr);
}
// Close files
seq_file_close(sf1);
if(path2 != NULL)
seq_file_close(sf2);
// Free memory
strbuf_free(entry1_title);
strbuf_free(entry2_title);
strbuf_free(entry1_seq);
strbuf_free(entry2_seq);
}
