static int encseq_loader_lua_disable_autosupport(lua_State *L)
{
GtEncseqLoader **loader;
loader = check_encseq_loader(L, 1);
gt_assert(*loader);
gt_encseq_loader_disable_autosupport(*loader);
return 0;
}
static int gt_readjoiner_assembly_paths2seq(const char *readset,
GtUword lengthcutoff, bool showpaths, bool astat,
double coverage, bool load_copynum, GtUword buffersize,
GtLogger *default_logger, GtTimer **timer, GtError *err)
{
int had_err;
GtEncseqLoader *el = gt_encseq_loader_new();
GtEncseq *reads;
if (gt_showtime_enabled())
{
gt_assert(timer != NULL);
if (*timer == NULL) /* paths2seq */
{
*timer = gt_timer_new_with_progress_description(
GT_READJOINER_ASSEMBLY_MSG_PUMPENCSEQ);
gt_timer_show_cpu_time_by_progress(*timer);
gt_timer_start(*timer);
}
else
gt_timer_show_progress(*timer, GT_READJOINER_ASSEMBLY_MSG_PUMPENCSEQ,
stdout);
}
gt_logger_log(default_logger, GT_READJOINER_ASSEMBLY_MSG_PUMPENCSEQ);
gt_encseq_loader_drop_description_support(el);
gt_encseq_loader_disable_autosupport(el);
gt_encseq_loader_mirror(el);
reads = gt_encseq_loader_load(el, readset, err);
gt_assert(reads != NULL);
gt_readjoiner_assembly_pump_encseq_through_cache(reads);
if (gt_showtime_enabled())
gt_timer_show_progress(*timer, GT_READJOINER_ASSEMBLY_MSG_OUTPUTCONTIGS,
stdout);
gt_logger_log(default_logger, GT_READJOINER_ASSEMBLY_MSG_OUTPUTCONTIGS);
had_err = gt_contigpaths_to_fasta(readset, GT_READJOINER_SUFFIX_CONTIG_PATHS,
GT_READJOINER_SUFFIX_CONTIGS, reads, lengthcutoff, showpaths,
astat, coverage, load_copynum, (size_t)buffersize, default_logger, err);
gt_encseq_delete(reads);
gt_encseq_loader_delete(el);
return had_err;
}
static int bioseq_fill(GtBioseq *bs, bool recreate, GtError *err)
{
GtStr *bioseq_index_file = NULL,
*bioseq_ois_file = NULL,
*bioseq_sds_file = NULL,
*bioseq_md5_file = NULL,
*bioseq_des_file = NULL;
int had_err = 0;
GtStr *bioseq_basename;
gt_assert(!bs->encseq);
if (bs->use_stdin)
bioseq_basename = gt_str_new_cstr("stdin");
else
bioseq_basename = bs->sequence_file;
/* construct file names */
bioseq_index_file = gt_str_clone(bioseq_basename);
gt_str_append_cstr(bioseq_index_file, GT_ENCSEQFILESUFFIX);
bioseq_ois_file = gt_str_clone(bioseq_basename);
gt_str_append_cstr(bioseq_ois_file, GT_OISTABFILESUFFIX);
bioseq_sds_file = gt_str_clone(bioseq_basename);
gt_str_append_cstr(bioseq_sds_file, GT_SDSTABFILESUFFIX);
bioseq_md5_file = gt_str_clone(bioseq_basename);
gt_str_append_cstr(bioseq_md5_file, GT_MD5TABFILESUFFIX);
bioseq_des_file = gt_str_clone(bioseq_basename);
gt_str_append_cstr(bioseq_des_file, GT_DESTABFILESUFFIX);
/* construct the bioseq files if necessary */
if (recreate || bs->use_stdin ||
!gt_file_exists(gt_str_get(bioseq_index_file)) ||
!gt_file_exists(gt_str_get(bioseq_ois_file)) ||
!gt_file_exists(gt_str_get(bioseq_sds_file)) ||
!gt_file_exists(gt_str_get(bioseq_md5_file)) ||
!gt_file_exists(gt_str_get(bioseq_des_file)) ||
gt_file_is_newer(gt_str_get(bs->sequence_file),
gt_str_get(bioseq_index_file))) {
had_err = construct_bioseq_files(bs, bioseq_basename, err);
}
if (!had_err) {
GtEncseqLoader *el = gt_encseq_loader_new();
gt_encseq_loader_disable_autosupport(el);
gt_encseq_loader_require_lossless_support(el);
gt_encseq_loader_require_description_support(el);
gt_encseq_loader_require_md5_support(el);
gt_encseq_loader_require_multiseq_support(el);
bs->encseq = gt_encseq_loader_load(el, gt_str_get(bioseq_basename), err);
if (bs->encseq == NULL) {
had_err = -1;
gt_assert(gt_error_is_set(err));
}
gt_encseq_loader_delete(el);
}
if (!had_err) {
gt_assert(bs->encseq);
}
/* free */
if (bs->use_stdin)
gt_str_delete(bioseq_basename);
gt_str_delete(bioseq_index_file);
gt_str_delete(bioseq_ois_file);
gt_str_delete(bioseq_md5_file);
gt_str_delete(bioseq_sds_file);
gt_str_delete(bioseq_des_file);
return had_err;
}
/*read condenseq data structure from file*/
GtCondenseq *gt_condenseq_new_from_file(const char *indexname,
GtLogger *logger, GtError *err)
{
int had_err = 0;
FILE* fp;
GtEncseqLoader *esl;
GtEncseq *unique_es;
GtCondenseq *condenseq = NULL;
/*load unique_es*/
esl = gt_encseq_loader_new();
gt_encseq_loader_disable_autosupport(esl);
gt_encseq_loader_drop_md5_support(esl);
gt_encseq_loader_require_ssp_tab(esl);
unique_es = gt_encseq_loader_load(esl, indexname, err);
if (!unique_es)
had_err = -1;
if (!had_err) {
gt_encseq_loader_delete(esl);
condenseq = condenseq_new_empty(gt_encseq_alphabet(unique_es));
condenseq->filename = gt_cstr_dup(indexname);
condenseq->unique_es = unique_es;
fp = gt_fa_fopen_with_suffix(indexname, GT_CONDENSEQ_FILE_SUFFIX,
"rb", err);
if (fp == NULL) {
had_err = -1;
}
else {
had_err = condenseq_io(condenseq, fp, gt_io_error_fread, err);
if (!had_err) {
GtUword i;
gt_assert(condenseq->uniques);
gt_assert(condenseq->links);
gt_fa_fclose(fp);
/*create link array for each unique entry*/
for (i = 0; i < condenseq->udb_nelems; i++) {
GT_INITARRAY(&(condenseq->uniques[i].links),uint32_t);
}
/* check for overflows */
if (condenseq->ldb_nelems > (GtUword) ((uint32_t) 0 - (uint32_t) 1)) {
gt_error_set(err, "Overflow, to many link-elements. Can't be stored");
had_err = -1;
}
/* iterate through link entrys and store ids in corresponding unique
entry array */
for (i = 0; !had_err && (GtUword) i < condenseq->ldb_nelems; i++) {
GtUword uid = condenseq->links[i].unique_id;
gt_assert(uid < condenseq->udb_nelems);
GT_STOREINARRAY(&(condenseq->uniques[uid].links),
uint32_t,
10,
(uint32_t) i);
}
}
}
}
if (!had_err) {
gt_assert(condenseq != NULL);
if (condenseq->id_len != GT_UNDEF_UWORD)
gt_logger_log(logger, "IDs const len: " GT_WU, condenseq->id_len);
else
gt_logger_log(logger, "using sdstab to access IDs");
}
if (had_err) {
gt_condenseq_delete(condenseq);
condenseq = NULL;
}
return (condenseq);
}
static int gt_readjoiner_assembly_runner(GT_UNUSED int argc,
GT_UNUSED const char **argv, GT_UNUSED int parsed_args,
void *tool_arguments, GtError *err)
{
GtReadjoinerAssemblyArguments *arguments = tool_arguments;
GtLogger *verbose_logger, *default_logger;
GtEncseqLoader *el;
GtEncseq *reads;
GtTimer *timer = NULL;
GtStrgraph *strgraph = NULL;
GtBitsequence *contained = NULL;
const char *readset = gt_str_get(arguments->readset);
bool eqlen = true;
GtUword nreads, tlen, rlen;
int had_err = 0;
gt_assert(arguments);
gt_error_check(err);
default_logger = gt_logger_new(!arguments->quiet, GT_LOGGER_DEFLT_PREFIX,
stdout);
gt_logger_log(default_logger,
"gt readjoiner assembly (version "GT_READJOINER_VERSION")");
verbose_logger = gt_logger_new(arguments->verbose, GT_LOGGER_DEFLT_PREFIX,
stdout);
gt_logger_log(verbose_logger, "verbose output activated");
gt_logger_log(verbose_logger, "readset name = %s", readset);
if (gt_showtime_enabled())
{
timer = gt_timer_new_with_progress_description(
GT_READJOINER_ASSEMBLY_MSG_COUNTSPM);
gt_timer_start(timer);
gt_timer_show_cpu_time_by_progress(timer);
}
if (!arguments->paths2seq)
{
el = gt_encseq_loader_new();
gt_encseq_loader_drop_description_support(el);
gt_encseq_loader_disable_autosupport(el);
reads = gt_encseq_loader_load(el, readset, err);
if (reads == NULL)
{
had_err = -1;
}
if (had_err == 0)
{
eqlen = gt_encseq_accesstype_get(reads) == GT_ACCESS_TYPE_EQUALLENGTH;
nreads = gt_encseq_num_of_sequences(reads);
gt_logger_log(default_logger, "number of reads in filtered readset = "
GT_WU, nreads);
tlen = gt_encseq_total_length(reads) - nreads + 1;
gt_logger_log(verbose_logger, "total length of filtered readset = " GT_WU,
tlen);
if (eqlen)
{
rlen = gt_encseq_seqlength(reads, 0);
gt_logger_log(verbose_logger, "read length = " GT_WU, rlen);
gt_encseq_delete(reads);
reads = NULL;
}
else
{
had_err = gt_readjoiner_assembly_build_contained_reads_list(
arguments, &contained, err);
rlen = 0;
gt_logger_log(verbose_logger, "read length = variable");
gt_assert(reads != NULL);
}
}
if (had_err == 0)
{
if (!arguments->load)
{
had_err = gt_readjoiner_assembly_build_graph(arguments, &strgraph,
reads, readset, eqlen, rlen, nreads, contained, default_logger,
verbose_logger, timer, err);
}
else
{
gt_readjoiner_assembly_load_graph(&strgraph, reads, readset, rlen,
default_logger, timer);
}
}
if (!eqlen && reads != NULL && !arguments->errors)
{
gt_encseq_delete(reads);
reads = NULL;
if (had_err == 0)
gt_strgraph_set_encseq(strgraph, NULL);
}
if (had_err == 0 && arguments->redtrans)
{
if (gt_showtime_enabled())
gt_timer_show_progress(timer, GT_READJOINER_ASSEMBLY_MSG_REDTRANS,
stdout);
gt_strgraph_sort_edges_by_len(strgraph, false);
(void)gt_strgraph_redtrans(strgraph, false);
(void)gt_strgraph_redself(strgraph, false);
(void)gt_strgraph_redwithrc(strgraph, false);
gt_strgraph_log_stats(strgraph, verbose_logger);
}
if (had_err == 0 && arguments->errors)
{
if (gt_showtime_enabled())
gt_timer_show_progress(timer, GT_READJOINER_ASSEMBLY_MSG_CLEANSG,
stdout);
gt_logger_log(default_logger, GT_READJOINER_ASSEMBLY_MSG_CLEANSG);
had_err = gt_readjoiner_assembly_error_correction(strgraph,
arguments->bubble, arguments->deadend, arguments->deadend_depth,
verbose_logger);
}
if (had_err == 0 && arguments->save)
{
if (gt_showtime_enabled())
gt_timer_show_progress(timer, GT_READJOINER_ASSEMBLY_MSG_SAVESG,
stdout);
gt_logger_log(default_logger, GT_READJOINER_ASSEMBLY_MSG_SAVESG);
gt_strgraph_show(strgraph, GT_STRGRAPH_BIN,
gt_str_get(arguments->readset), GT_READJOINER_SUFFIX_SG, false);
}
if (!eqlen && reads != NULL)
{
gt_encseq_delete(reads);
reads = NULL;
if (had_err == 0)
gt_strgraph_set_encseq(strgraph, NULL);
}
if (had_err == 0)
{
if (gt_showtime_enabled())
gt_timer_show_progress(timer, GT_READJOINER_ASSEMBLY_MSG_TRAVERSESG,
stdout);
gt_logger_log(default_logger, GT_READJOINER_ASSEMBLY_MSG_TRAVERSESG);
gt_readjoiner_assembly_show_current_space("(before traversal)");
gt_strgraph_spell(strgraph, (GtUword)arguments->depthcutoff,
(GtUword)arguments->lengthcutoff, arguments->vd, readset,
GT_READJOINER_SUFFIX_CONTIG_PATHS, NULL, true,
arguments->show_contigs_info, false, verbose_logger);
}
if (contained != NULL)
gt_free(contained);
gt_strgraph_delete(strgraph);
strgraph = NULL;
gt_assert(reads == NULL);
gt_encseq_loader_delete(el);
}
if (had_err == 0)
{
gt_readjoiner_assembly_show_current_space("(before paths2seq)");
had_err = gt_readjoiner_assembly_paths2seq(readset,
(GtUword)arguments->lengthcutoff, arguments->vd,
arguments->astat, arguments->coverage, arguments->copynum,
arguments->buffersize, default_logger, &timer, err);
}
if (gt_showtime_enabled())
{
gt_timer_show_progress_final(timer, stdout);
gt_timer_delete(timer);
}
gt_logger_delete(default_logger);
gt_logger_delete(verbose_logger);
return had_err;
}
static int gt_encseq2spm_runner(GT_UNUSED int argc,
GT_UNUSED const char **argv,
GT_UNUSED int parsed_args,
void *tool_arguments,
GtError *err)
{
GtEncseq2spmArguments *arguments = tool_arguments;
GtEncseqLoader *el = NULL;
GtEncseq *encseq = NULL;
bool haserr = false;
gt_error_check(err);
gt_assert(arguments);
el = gt_encseq_loader_new();
gt_encseq_loader_drop_description_support(el);
gt_encseq_loader_disable_autosupport(el);
encseq = gt_encseq_loader_load(el, gt_str_get(arguments->encseqinput),
err);
if (encseq == NULL)
{
haserr = true;
}
if (!haserr)
{
if (arguments->singlestrand)
{
gt_error_set(err,"option -singlestand is not implemented");
haserr = true;
} else
{
if (gt_encseq_mirror(encseq, err) != 0)
{
haserr = true;
}
}
}
if (!haserr && arguments->singlescan > 0)
{
GtTimer *timer = NULL;
if (gt_showtime_enabled())
{
char *outmsg;
switch (arguments->singlescan)
{
case 1:
outmsg = "to run fast scanning";
break;
case 2:
outmsg = "to run fast scanning with check";
break;
case 3:
outmsg = "to run fast scanning with output";
break;
case 4:
outmsg = "to run old scanning code";
break;
default:
gt_error_set(err,"argument %u to option -singlescan not allowed",
arguments->singlescan);
haserr = true;
}
if (!haserr)
{
timer = gt_timer_new_with_progress_description(outmsg);
gt_timer_start(timer);
}
}
if (!haserr)
{
unsigned int kmersize = 0;
haserr = gt_encseq2spm_kmersize(arguments, &kmersize, err);
if (!haserr)
{
if (arguments->singlescan == 4U)
{
gt_rungetencseqkmers(encseq,kmersize);
} else
{
if (arguments->singlescan > 0)
{
gt_firstcode_runkmerscan(encseq,arguments->singlescan - 1,kmersize,
arguments->minmatchlength);
}
}
}
}
if (timer != NULL)
{
gt_timer_show_progress_final(timer, stdout);
gt_timer_delete(timer);
}
}
if (!haserr && arguments->singlescan == 0)
{
GtLogger *logger;
const GtReadmode readmode = GT_READMODE_FORWARD;
GtBUstate_spmsk **spmsk_states = NULL;
unsigned int kmersize, threadcount;
#ifdef GT_THREADS_ENABLED
const unsigned int threads = gt_jobs;
#else
const unsigned int threads = 1U;
#endif
if (arguments->countspms || arguments->outputspms)
{
spmsk_states = gt_malloc(sizeof (*spmsk_states) * threads);
for (threadcount = 0; threadcount < threads; threadcount++)
{
spmsk_states[threadcount]
= gt_spmsk_inl_new(encseq,
readmode,
(unsigned long) arguments->minmatchlength,
arguments->countspms,
arguments->outputspms,
gt_str_get(arguments->encseqinput));
}
}
logger = gt_logger_new(arguments->verbose,GT_LOGGER_DEFLT_PREFIX, stdout);
haserr = gt_encseq2spm_kmersize(arguments, &kmersize, err);
if (!haserr)
{
if (storefirstcodes_getencseqkmers_twobitencoding(encseq,
kmersize,
arguments->numofparts,
arguments->maximumspace,
arguments->minmatchlength,
/* use false */ arguments->checksuftab,
/* use false */ arguments->onlyaccum,
/* use false */ arguments->
onlyallfirstcodes,
/* use 5U */ arguments->
addbscache_depth,
/* specify the extra space needed for
the function processing the interval */
arguments->phase2extra,
/* use true */ arguments->radixlarge ?
false : true,
/* use 2 without threads and
use 1 with threads */
arguments->radixparts,
spmsk_states != NULL
? gt_spmsk_inl_process
: NULL,
gt_spmsk_inl_process_end,
spmsk_states,
logger,
err) != 0)
{
haserr = true;
}
}
if (spmsk_states != NULL)
{
unsigned long countmatches = 0;
for (threadcount = 0; threadcount < threads; threadcount++)
{
countmatches += gt_spmsk_inl_delete(spmsk_states[threadcount]);
}
if (arguments->countspms)
{
printf("number of suffix-prefix matches=%lu\n",countmatches);
}
gt_free(spmsk_states);
}
gt_logger_delete(logger);
}
gt_encseq_delete(encseq);
gt_encseq_loader_delete(el);
return haserr ? -1 : 0;
}
static int gt_ltrdigest_runner(GT_UNUSED int argc, const char **argv,
int parsed_args, void *tool_arguments,
GtError *err)
{
GtLTRdigestOptions *arguments = tool_arguments;
GtNodeStream *gff3_in_stream = NULL,
*gff3_out_stream = NULL,
*pdom_stream = NULL,
*ppt_stream = NULL,
*pbs_stream = NULL,
*tab_out_stream = NULL,
*sa_stream = NULL,
*last_stream = NULL;
int had_err = 0,
tests_to_run = 0,
arg = parsed_args;
GtRegionMapping *rmap = NULL;
GtPdomModelSet *ms = NULL;
gt_error_check(err);
gt_assert(arguments);
/* determine and open sequence source */
if (gt_seqid2file_option_used(arguments->s2fi)) {
/* create region mapping */
rmap = gt_seqid2file_region_mapping_new(arguments->s2fi, err);
if (!rmap)
had_err = -1;
} else {
GtEncseqLoader *el;
GtEncseq *encseq;
/* no new-style sequence source option given, fall back to legacy syntax */
if (argc < 3) {
gt_error_set(err, "missing mandatory argument(s)");
had_err = -1;
}
if (!had_err) {
el = gt_encseq_loader_new();
gt_encseq_loader_disable_autosupport(el);
gt_encseq_loader_require_md5_support(el);
gt_encseq_loader_require_description_support(el);
encseq = gt_encseq_loader_load(el, argv[argc-1], err);
/* XXX: clip off terminal argument */
gt_free((char*) argv[argc-1]);
argv[argc-1] = NULL;
argc--;
gt_encseq_loader_delete(el);
if (!encseq)
had_err = -1;
else {
rmap = gt_region_mapping_new_encseq_seqno(encseq);
gt_encseq_delete(encseq);
}
}
}
gt_assert(had_err || rmap);
/* Always search for PPT. */
tests_to_run |= GT_LTRDIGEST_RUN_PPT;
/* Open tRNA library if given. */
if (!had_err && arguments->trna_lib
&& gt_str_length(arguments->trna_lib) > 0)
{
tests_to_run |= GT_LTRDIGEST_RUN_PBS;
arguments->trna_lib_bs = gt_bioseq_new(gt_str_get(arguments->trna_lib),
err);
if (gt_error_is_set(err))
had_err = -1;
}
/* Set HMMER cutoffs. */
if (!had_err && gt_str_array_size(arguments->hmm_files) > 0)
{
tests_to_run |= GT_LTRDIGEST_RUN_PDOM;
if (!strcmp(gt_str_get(arguments->cutoffs), "GA")) {
arguments->cutoff = GT_PHMM_CUTOFF_GA;
} else if (!strcmp(gt_str_get(arguments->cutoffs), "TC")) {
arguments->cutoff = GT_PHMM_CUTOFF_TC;
} else if (!strcmp(gt_str_get(arguments->cutoffs), "NONE")) {
arguments->cutoff = GT_PHMM_CUTOFF_NONE;
} else {
gt_error_set(err, "invalid cutoff setting!");
had_err = -1;
}
}
if (!had_err) {
last_stream = gff3_in_stream = gt_gff3_in_stream_new_sorted(argv[arg]);
}
if (!had_err && gt_str_array_size(arguments->hmm_files) > 0) {
GtNodeVisitor *pdom_v;
ms = gt_pdom_model_set_new(arguments->hmm_files, err);
if (ms != NULL) {
pdom_v = gt_ltrdigest_pdom_visitor_new(ms, arguments->evalue_cutoff,
arguments->chain_max_gap_length,
arguments->cutoff, rmap, err);
if (pdom_v == NULL)
had_err = -1;
if (!had_err) {
gt_ltrdigest_pdom_visitor_set_source_tag((GtLTRdigestPdomVisitor*)
pdom_v,
GT_LTRDIGEST_TAG);
if (arguments->output_all_chains)
gt_ltrdigest_pdom_visitor_output_all_chains((GtLTRdigestPdomVisitor*)
pdom_v);
last_stream = pdom_stream = gt_visitor_stream_new(last_stream, pdom_v);
}
} else had_err = -1;
}
if (!had_err && arguments->trna_lib_bs) {
GtNodeVisitor *pbs_v;
pbs_v = gt_ltrdigest_pbs_visitor_new(rmap, arguments->pbs_radius,
arguments->max_edist,
arguments->alilen,
arguments->offsetlen,
arguments->trnaoffsetlen,
arguments->ali_score_match,
arguments->ali_score_mismatch,
arguments->ali_score_insertion,
arguments->ali_score_deletion,
arguments->trna_lib_bs, err);
if (pbs_v != NULL)
last_stream = pbs_stream = gt_visitor_stream_new(last_stream, pbs_v);
else
had_err = -1;
}
if (!had_err) {
GtNodeVisitor *ppt_v;
ppt_v = gt_ltrdigest_ppt_visitor_new(rmap, arguments->ppt_len,
arguments->ubox_len,
arguments->ppt_pyrimidine_prob,
arguments->ppt_purine_prob,
arguments->bkg_a_prob,
arguments->bkg_g_prob,
arguments->bkg_t_prob,
arguments->bkg_c_prob,
arguments->ubox_u_prob,
arguments->ppt_radius,
arguments->max_ubox_dist, err);
if (ppt_v != NULL)
last_stream = ppt_stream = gt_visitor_stream_new(last_stream, ppt_v);
else
had_err = -1;
}
if (!had_err) {
GtNodeVisitor *sa_v;
sa_v = gt_ltrdigest_strand_assign_visitor_new();
gt_assert(sa_v);
last_stream = sa_stream = gt_visitor_stream_new(last_stream, sa_v);
}
if (!had_err)
{
/* attach tabular output stream, if requested */
if (gt_str_length(arguments->prefix) > 0)
{
last_stream = tab_out_stream = gt_ltrdigest_file_out_stream_new(
last_stream,
tests_to_run,
rmap,
gt_str_get(arguments->prefix),
arguments->seqnamelen,
err);
if (!tab_out_stream)
had_err = -1;
if (!had_err && arguments->print_metadata)
{
had_err = gt_ltrdigest_file_out_stream_write_metadata(
(GtLTRdigestFileOutStream*)
tab_out_stream,
tests_to_run,
gt_str_get(arguments->trna_lib),
argv[arg],
arguments->ppt_len,
arguments->ubox_len,
arguments->ppt_radius,
arguments->alilen,
arguments->max_edist,
arguments->offsetlen,
arguments->trnaoffsetlen,
arguments->pbs_radius,
arguments->hmm_files,
arguments->chain_max_gap_length,
arguments->evalue_cutoff,
err);
}
if (!had_err)
{
if (arguments->write_alignments)
gt_ltrdigest_file_out_stream_enable_pdom_alignment_output(
tab_out_stream);
if (arguments->write_aaseqs)
gt_ltrdigest_file_out_stream_enable_aa_sequence_output(
tab_out_stream);
}
}
last_stream = gff3_out_stream = gt_gff3_out_stream_new(last_stream,
arguments->outfp);
/* pull the features through the stream and free them afterwards */
had_err = gt_node_stream_pull(last_stream, err);
}
gt_pdom_model_set_delete(ms);
gt_node_stream_delete(gff3_out_stream);
gt_node_stream_delete(ppt_stream);
gt_node_stream_delete(pbs_stream);
gt_node_stream_delete(sa_stream);
gt_node_stream_delete(pdom_stream);
gt_node_stream_delete(tab_out_stream);
gt_node_stream_delete(gff3_in_stream);
gt_bioseq_delete(arguments->trna_lib_bs);
gt_region_mapping_delete(rmap);
return had_err;
}
static int gt_readjoiner_cnttest_runner(GT_UNUSED int argc,
GT_UNUSED const char **argv, GT_UNUSED int parsed_args,
void *tool_arguments, GT_UNUSED GtError *err)
{
GtReadjoinerCnttestArguments *arguments = tool_arguments;
GtEncseqLoader *el = NULL;
GtEncseq *reads = NULL;
GtBitsequence *bits = NULL;
GtUword nofreads;
int had_err = 0;
gt_error_check(err);
gt_assert(arguments);
if (arguments->test == GT_READJOINER_CNTTEST_SHOWLIST)
{
GtStr *fn = NULL;
fn = gt_str_clone(arguments->readset);
gt_str_append_cstr(fn, GT_READJOINER_SUFFIX_CNTLIST);
had_err = gt_cntlist_parse(gt_str_get(fn), true, &bits, &nofreads, err);
gt_str_delete(fn);
}
else if (arguments->test == GT_READJOINER_CNTTEST_BRUTEFORCE ||
arguments->test == GT_READJOINER_CNTTEST_KMP)
{
el = gt_encseq_loader_new();
gt_encseq_loader_drop_description_support(el);
gt_encseq_loader_disable_autosupport(el);
if (!arguments->singlestrand)
gt_encseq_loader_mirror(el);
reads = gt_encseq_loader_load(el, gt_str_get(arguments->readset), err);
if (reads == NULL)
had_err = -1;
else
{
gt_rdj_pairwise_exact(GT_OVLFIND_CNT, reads, !arguments->singlestrand,
false, arguments->test == GT_READJOINER_CNTTEST_KMP, 1UL, true,
NULL, NULL, false, NULL, &bits, &nofreads);
}
gt_encseq_delete(reads);
gt_encseq_loader_delete(el);
}
else if (arguments->test == GT_READJOINER_CNTTEST_ESA)
{
Sequentialsuffixarrayreader *ssar = NULL;
GtUword readlength = 0, firstrevcompl = 0;
GtLogger *verbose_logger = gt_logger_new(arguments->verbose,
GT_LOGGER_DEFLT_PREFIX, stderr);
ssar = gt_newSequentialsuffixarrayreaderfromfile(gt_str_get(
arguments->readset), SARR_LCPTAB | SARR_SUFTAB | SARR_SSPTAB,
true, verbose_logger, err);
if (gt_error_is_set(err))
had_err = -1;
else
{
nofreads = gt_encseq_num_of_sequences(ssar->encseq);
if (!arguments->singlestrand)
{
nofreads = GT_DIV2(nofreads);
firstrevcompl = nofreads;
}
GT_INITBITTAB(bits, nofreads);
if (!arguments->singlestrand)
if (gt_encseq_accesstype_get(ssar->encseq) == GT_ACCESS_TYPE_EQUALLENGTH)
readlength = gt_encseq_seqlength(ssar->encseq, 0);
(void)gt_contfind_bottomup(ssar, false, bits, arguments->singlestrand ? 0
: firstrevcompl, readlength);
}
if (ssar != NULL)
gt_freeSequentialsuffixarrayreader(&ssar);
gt_logger_delete(verbose_logger);
}
else
{
gt_assert(false);
}
if (!had_err)
had_err = gt_cntlist_show(bits, nofreads, NULL, false, err);
gt_free(bits);
return had_err;
}
