void gt_typecheck_info_register_options_with_default(GtTypecheckInfo *tci,
GtOptionParser *op,
const char *default_v)
{
GtOption *typecheck_option, *built_in_option;
gt_assert(tci && op);
gt_assert(!tci->typecheck_option); /* can only called once */
/* -typecheck */
typecheck_option =
gt_option_new_string("typecheck", "use an ontology given in an OBO file "
"to validate parent-child relationships.\n"
"If no argument is given, "
"the sofa.obo file from the gtdata/obo_files "
"directory is used.\nIf an argument is given, it is "
"used as an OBO filename.\nIn the case that such a "
"file does not exist '.obo' is added to the argument "
"and loading the resulting filename from the "
"gtdata/obo_files directory is attempted.",
tci->typecheck, default_v);
gt_option_argument_is_optional(typecheck_option);
gt_option_parser_add_option(op, typecheck_option);
tci->typecheck_option = gt_option_ref(typecheck_option);
/* -typecheck-built-in */
built_in_option = gt_option_new_bool("typecheck-built-in",
"use built-in type checker",
&tci->typecheck_built_in, false);
gt_option_is_development_option(built_in_option);
gt_option_parser_add_option(op, built_in_option);
gt_option_exclude(typecheck_option, built_in_option);
}
void gt_typecheck_info_register_options(GtTypecheckInfo *tci,
GtOptionParser *op)
{
GtOption *typecheck_option, *built_in_option;
gt_assert(tci && op);
gt_assert(!tci->typecheck_option); /* can only called once */
/* -typecheck */
typecheck_option =
gt_option_new_string("typecheck", "check GFF3 types against \"id\" and "
"\"name\" tags in given OBO file and validate parent "
"(part-of) relationships.\nIf no argument is given, "
"the sofa.obo file from the gtdata/obo_files "
"directory is used.\nIf an argument is given, it is "
"used as an OBO filename.\nIn the case that such a "
"file does not exist '.obo' is added to the argument "
"and loading the resulting filename from the "
"gtdata/obo_files directory is attempted.",
tci->typecheck, NULL);
gt_option_argument_is_optional(typecheck_option);
gt_option_parser_add_option(op, typecheck_option);
tci->typecheck_option = gt_option_ref(typecheck_option);
/* -typecheck-built-in */
built_in_option = gt_option_new_bool("typecheck-built-in",
"use built-in type checker",
&tci->typecheck_built_in, false);
gt_option_is_development_option(built_in_option);
gt_option_parser_add_option(op, built_in_option);
gt_option_exclude(typecheck_option, built_in_option);
}
void gt_xrfcheck_info_register_options(GtXRFCheckInfo *xci,
GtOptionParser *op)
{
GtOption *xrfcheck_option;
gt_assert(xci && op);
gt_assert(!xci->xrfcheck_option); /* can only called once */
/* -xrfcheck */
xrfcheck_option =
gt_option_new_string("xrfcheck", "check Dbxref and Ontology_term "
"attributes for correct syntax according to a "
"abbreviation definition file.\nIf no argument is "
"given, the GO.xrf_abbs file from the "
"gtdata/xrf_abbr directory is used.\nIf an argument "
"is given, it is used as an specific filename for an "
"abbreviation file.\nIn the case that such a "
"file does not exist, '.xrf_abbr' is added to the "
"argument and loading the resulting filename from the "
"gtdata/xrf_abbr directory is attempted.",
xci->xrfcheck, NULL);
gt_option_argument_is_optional(xrfcheck_option);
gt_option_parser_add_option(op, xrfcheck_option);
xci->xrfcheck_option = gt_option_ref(xrfcheck_option);
}
static GtOptionParser* gt_seed_extend_option_parser_new(void *tool_arguments)
{
GtSeedExtendArguments *arguments = tool_arguments;
GtOptionParser *op;
GtOption *option, *op_gre, *op_xdr, *op_cam, *op_his, *op_dif, *op_pmh,
*op_len, *op_err, *op_xbe, *op_sup, *op_frq, *op_mem, *op_ali, *op_bia;
gt_assert(arguments != NULL);
/* init */
op = gt_option_parser_new("[option ...] encseq_basename [encseq_basename]",
"Calculate local alignments using the seed and "
"extend algorithm.");
/* DIAGBANDSEED OPTIONS */
/* -ii */
option = gt_option_new_string("ii",
"Input index for encseq encoded sequences",
arguments->dbs_indexname,
"");
gt_option_is_mandatory(option);
gt_option_parser_add_option(op, option);
/* -qii */
option = gt_option_new_string("qii",
"Query input index (encseq)",
arguments->dbs_queryname,
"");
gt_option_parser_add_option(op, option);
/* -seedlength */
op_len = gt_option_new_uint_min_max("seedlength",
"Minimum length of a seed",
&arguments->dbs_seedlength,
14UL, 1UL, 32UL);
gt_option_parser_add_option(op, op_len);
/* -diagbandwidth */
option = gt_option_new_uword("diagbandwidth",
"Logarithm of diagonal band width (for filter)",
&arguments->dbs_logdiagbandwidth,
6UL);
gt_option_parser_add_option(op, option);
/* -mincoverage */
option = gt_option_new_uword("mincoverage",
"Minimum coverage in two neighbouring diagonal "
"bands (for filter)",
&arguments->dbs_mincoverage,
35UL);
gt_option_parser_add_option(op, option);
/* -maxfreq */
op_frq = gt_option_new_uword_min("maxfreq",
"Maximum frequency of a k-mer (for filter)",
&arguments->dbs_maxfreq,
GT_UWORD_MAX, 1UL);
gt_option_parser_add_option(op, op_frq);
/* -t */
op_sup = gt_option_new_uword_min("t",
"Suppress k-mers occurring at least t times "
"(for filter)",
&arguments->dbs_suppress,
GT_UWORD_MAX, 2UL);
gt_option_exclude(op_sup, op_frq);
gt_option_is_development_option(op_sup);
gt_option_parser_add_option(op, op_sup);
/* -memlimit */
op_mem = gt_option_new_string("memlimit",
"Maximum memory usage to determine the maximum "
"frequency of a k-mer (for filter)",
arguments->dbs_memlimit_str,
"");
gt_option_parser_add_option(op, op_mem);
/* -debug-kmer */
option = gt_option_new_bool("debug-kmer",
"Output KmerPos lists",
&arguments->dbs_debug_kmer,
false);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
/* -debug-seedpair */
option = gt_option_new_bool("debug-seedpair",
"Output SeedPair lists",
&arguments->dbs_debug_seedpair,
false);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
/* -verify */
option = gt_option_new_bool("verify",
"Check that k-mer seeds occur in the sequences",
&arguments->dbs_verify,
false);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
/* SEED EXTENSION OPTIONS */
/* -extendxdrop */
op_xdr = gt_option_new_uword_min_max("extendxdrop",
"Extend seed to both sides using xdrop "
"algorithm, optional parameter "
"specifies sensitivity",
&arguments->se_extendxdrop,
97UL, 90UL, 100UL);
gt_option_argument_is_optional(op_xdr);
gt_option_parser_add_option(op, op_xdr);
arguments->se_option_xdrop = gt_option_ref(op_xdr);
/* -xdropbelow */
op_xbe = gt_option_new_word("xdropbelow",
"Specify xdrop cutoff score (0 means "
"automatically defined depending on minidentity)",
&arguments->se_xdropbelowscore,
0L);
gt_option_imply(op_xbe, op_xdr);
gt_option_parser_add_option(op, op_xbe);
/* -extendgreedy */
op_gre = gt_option_new_uword_min_max("extendgreedy",
"Extend seed to both sides using greedy "
"algorithm, optional parameter "
"specifies sensitivity",
&arguments->se_extendgreedy,
97UL, 90UL, 100UL);
gt_option_argument_is_optional(op_gre);
gt_option_exclude(op_gre, op_xdr);
gt_option_parser_add_option(op, op_gre);
arguments->se_option_greedy = gt_option_ref(op_gre);
/* -history */
op_his = gt_option_new_uword_min_max("history",
"Size of (mis)match history in range [1"
"..64] (trimming for greedy extension)",
&arguments->se_historysize,
60UL, 1UL, 64UL);
gt_option_imply(op_his, op_gre);
gt_option_parser_add_option(op, op_his);
/* -maxalilendiff */
op_dif = gt_option_new_uword("maxalilendiff",
"Maximum difference of alignment length "
"(trimming for greedy extension)",
&arguments->se_maxalilendiff, 0UL);
gt_option_imply(op_dif, op_gre);
gt_option_is_development_option(op_dif);
gt_option_parser_add_option(op, op_dif);
/* -percmathistory */
op_pmh = gt_option_new_uword_min_max("percmathistory",
"percentage of matches required in "
"history (for greedy extension)",
&arguments->se_perc_match_hist,
0UL, 1UL, 100UL);
gt_option_imply(op_pmh, op_gre);
gt_option_is_development_option(op_pmh);
gt_option_parser_add_option(op, op_pmh);
/* -bias-parameters */
op_bia = gt_option_new_bool("bias-parameters",
"Use -maxalilendiff 30 and let percmathistory "
"depend on minidentiy and DNA base distribution",
&arguments->bias_parameters,
false);
gt_option_imply(op_bia, op_gre);
gt_option_exclude(op_bia, op_pmh);
gt_option_exclude(op_bia, op_dif);
gt_option_is_development_option(op_bia);
gt_option_parser_add_option(op, op_bia);
/* -cam */
op_cam = gt_option_new_string("cam",
gt_cam_extendgreedy_comment(),
arguments->se_char_access_mode,
"");
gt_option_is_development_option(op_cam);
gt_option_parser_add_option(op, op_cam);
/* -l */
op_len = gt_option_new_uword_min("l",
"Minimum alignment length "
"(for seed extension)",
&arguments->se_alignlength,
20UL, 1UL);
gt_option_imply_either_2(op_len, op_xdr, op_gre);
gt_option_parser_add_option(op, op_len);
/* -minidentity */
op_err = gt_option_new_uword_min_max("minidentity",
"Minimum identity of matches "
"(for seed extension)",
&arguments->se_minidentity,
80UL, GT_EXTEND_MIN_IDENTITY_PERCENTAGE,
99UL);
gt_option_imply_either_2(op_err, op_xdr, op_gre);
gt_option_parser_add_option(op, op_err);
/* -a */
op_ali = gt_option_new_uword_min("a",
"show alignments/sequences (optional "
"argument is number of columns per line)",
&arguments->se_alignmentwidth,
70, 20);
gt_option_argument_is_optional(op_ali);
gt_option_parser_add_option(op, op_ali);
arguments->se_option_withali = gt_option_ref(op_ali);
/* -mirror */
option = gt_option_new_bool("mirror",
"Add reverse complement reads",
&arguments->mirror,
false);
gt_option_parser_add_option(op, option);
/* -overlappingseeds */
option = gt_option_new_bool("overlappingseeds",
"Allow overlapping SeedPairs",
&arguments->overlappingseeds,
false);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
/* -benchmark */
option = gt_option_new_bool("benchmark",
"Measure total running time and be silent",
&arguments->benchmark,
false);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
/* -seed-display */
option = gt_option_new_bool("seed-display",
"Display seeds in #-line",
&arguments->seed_display,
false);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
/* -v */
option = gt_option_new_verbose(&arguments->verbose);
gt_option_parser_add_option(op, option);
return op;
}
static GtIndexOptions* gt_index_options_register_generic_create(
GtOptionParser *op,
GtIndexOptionsIndexType t)
{
GtIndexOptions *idxo;
gt_assert(op != NULL && t != GT_INDEX_OPTIONS_UNDEFINED);
idxo = gt_index_options_new();
idxo->type = t;
idxo->optionprefixlength = gt_option_new_uint_min("pl",
"specify prefix length for bucket sort\n"
"recommendation: use without argument;\n"
"then a reasonable prefix length is "
"automatically determined.",
&idxo->prefixlength,
GT_PREFIXLENGTH_AUTOMATIC,
1U);
gt_option_argument_is_optional(idxo->optionprefixlength);
gt_option_parser_add_option(op, idxo->optionprefixlength);
idxo->optionuserdefinedsortmaxdepth
= gt_option_new_uint_min("sortmaxdepth","sort only up to the given depth.",
&idxo->sfxstrategy.userdefinedsortmaxdepth,
0,
1U);
gt_option_parser_add_option(op, idxo->optionuserdefinedsortmaxdepth);
gt_option_is_development_option(idxo->optionuserdefinedsortmaxdepth);
idxo->optiondifferencecover = gt_option_new_uint_min("dc",
"specify difference cover value",
&idxo->sfxstrategy.differencecover,
0,
4U);
gt_option_parser_add_option(op, idxo->optiondifferencecover);
gt_option_exclude(idxo->optionuserdefinedsortmaxdepth,
idxo->optiondifferencecover);
idxo->optioncmpcharbychar = gt_option_new_bool("cmpcharbychar",
"compare suffixes character "
"by character",
&idxo->sfxstrategy.cmpcharbychar,
false);
gt_option_is_development_option(idxo->optioncmpcharbychar);
gt_option_parser_add_option(op, idxo->optioncmpcharbychar);
idxo->optionnoshortreadsort = gt_option_new_bool("noshortreadsort",
"do not use short read sort",
&idxo->sfxstrategy.noshortreadsort,
false);
gt_option_is_development_option(idxo->optionnoshortreadsort);
gt_option_parser_add_option(op, idxo->optionnoshortreadsort);
idxo->optionmaxwidthrealmedian = gt_option_new_uword("maxwidthrealmedian",
"compute real median for "
"intervals of at most the "
"given widthprefixes",
&idxo->sfxstrategy.
maxwidthrealmedian,
1UL);
gt_option_is_development_option(idxo->optionmaxwidthrealmedian);
gt_option_parser_add_option(op, idxo->optionmaxwidthrealmedian);
idxo->optionalgbounds
= gt_option_new_string_array("algbds",
"length boundaries for the different "
"algorithms to sort buckets of suffixes\n"
"first number: maxbound for insertion sort\n"
"second number: maxbound for blindtrie sort\n"
"third number: maxbound for counting sort",
idxo->algbounds);
gt_option_is_development_option(idxo->optionalgbounds);
gt_option_parser_add_option(op, idxo->optionalgbounds);
idxo->optionstorespecialcodes
= gt_option_new_bool("storespecialcodes",
"store special codes (this may speed up the program)",
&idxo->sfxstrategy.storespecialcodes,false);
gt_option_is_development_option(idxo->optionstorespecialcodes);
gt_option_parser_add_option(op, idxo->optionstorespecialcodes);
idxo->optionparts
= gt_option_new_uint_max("parts",
"specify number of parts in which the index "
"construction is performed",
&idxo->numofparts, 1U, (unsigned) ((1 << 22) - 1));
gt_option_is_development_option(idxo->optionparts);
gt_option_parser_add_option(op, idxo->optionparts);
if (idxo->type == GT_INDEX_OPTIONS_ESA)
{
idxo->optionspmopt = gt_option_new_uint_min("spmopt",
"optimize esa-construction for "
"suffix-prefix matching",
&idxo->sfxstrategy.spmopt_minlength,
0,1U);
gt_option_parser_add_option(op, idxo->optionspmopt);
gt_option_exclude(idxo->optionspmopt, idxo->optiondifferencecover);
idxo->optionmemlimit = gt_option_new_string("memlimit",
"specify maximal amount of memory to be used during "
"index construction (in bytes, the keywords 'MB' "
"and 'GB' are allowed)",
idxo->memlimit, NULL);
gt_option_parser_add_option(op, idxo->optionmemlimit);
gt_option_exclude(idxo->optionmemlimit, idxo->optionparts);
}
idxo->option = gt_option_new_bool("iterscan",
"use iteratorbased-kmer scanning",
&idxo->sfxstrategy.iteratorbasedkmerscanning,
false);
gt_option_is_development_option(idxo->option);
gt_option_parser_add_option(op, idxo->option);
idxo->option = gt_option_new_bool("samplewithprefixlengthnull",
"sort sample with prefixlength=0",
&idxo->sfxstrategy.samplewithprefixlengthnull,
false);
gt_option_is_development_option(idxo->option);
gt_option_parser_add_option(op, idxo->option);
idxo->option = gt_option_new_bool("suftabuint",
"use uint32_t for suftab",
&idxo->sfxstrategy.suftabuint,
false);
gt_option_is_development_option(idxo->option);
gt_option_parser_add_option(op, idxo->option);
idxo->option = gt_option_new_bool("onlybucketinsertion",
"perform only bucket insertion",
&idxo->sfxstrategy.onlybucketinsertion,
false);
gt_option_is_development_option(idxo->option);
gt_option_parser_add_option(op, idxo->option);
idxo->option = gt_option_new_bool("kmerswithencseqreader",
"always perform kmerscanning with encseq-reader",
&idxo->sfxstrategy.kmerswithencseqreader,
false);
gt_option_is_development_option(idxo->option);
gt_option_parser_add_option(op, idxo->option);
idxo->option = gt_option_new_bool("dccheck",
"check intermediate results in difference cover",
&idxo->sfxstrategy.dccheck,
false);
gt_option_is_development_option(idxo->option);
gt_option_parser_add_option(op, idxo->option);
idxo->option = gt_option_new_bool("withradixsort",
"use radixsort to sort the buckets",
&idxo->sfxstrategy.withradixsort,
false);
gt_option_is_development_option(idxo->option);
gt_option_parser_add_option(op, idxo->option);
idxo->option = gt_option_new_bool("compressedoutput",
"output suftab and lcptab in compressed "
"form",
&idxo->sfxstrategy.compressedoutput,
false);
gt_option_is_development_option(idxo->option);
gt_option_parser_add_option(op, idxo->option);
gt_option_parser_register_hook(op, gt_index_options_check_set_create_opts,
idxo);
return idxo;
}
static GtIndexOptions*
gt_index_options_register_generic_output(GtOptionParser *op,
GtIndexOptions *idxo,
GtStr *indexname,
GtEncseqOptions *encopts)
{
gt_assert(idxo != NULL);
gt_assert(op != NULL && idxo->type != GT_INDEX_OPTIONS_UNDEFINED &&
encopts != NULL);
idxo->encopts = encopts;
idxo->indexname = indexname != NULL ? gt_str_ref(indexname) : NULL;
idxo->optionkys = gt_option_new_string("kys",
"output/sort according to keys of the form "
"|key| in fasta header",
idxo->kysargumentstring,
"nosort");
gt_option_argument_is_optional(idxo->optionkys);
gt_option_imply(idxo->optionkys, gt_encseq_options_sds_option(idxo->encopts));
gt_option_parser_add_option(op, idxo->optionkys);
gt_encseq_options_add_readmode_option(op, idxo->dir);
if (idxo->type == GT_INDEX_OPTIONS_ESA)
{
idxo->optionoutsuftab = gt_option_new_bool("suf",
"output suffix array (suftab) to file",
&idxo->outsuftab,
false);
gt_option_parser_add_option(op, idxo->optionoutsuftab);
idxo->optionoutlcptab = gt_option_new_bool("lcp",
"output lcp table (lcptab) to file",
&idxo->outlcptab,
false);
gt_option_parser_add_option(op, idxo->optionoutlcptab);
idxo->option = gt_option_new_bool("lcpdist",
"output distributions of values in lcptab",
&idxo->lcpdist,
false);
gt_option_is_extended_option(idxo->option);
gt_option_imply(idxo->option, idxo->optionoutlcptab);
gt_option_parser_add_option(op, idxo->option);
idxo->option = gt_option_new_bool("swallow-tail",
"swallow the tail of the suffix array and lcptab",
&idxo->swallow_tail,
false);
gt_option_is_development_option(idxo->option);
gt_option_parser_add_option(op, idxo->option);
idxo->optionoutbwttab = gt_option_new_bool("bwt",
"output Burrows-Wheeler Transformation "
"(bwttab) to file",
&idxo->outbwttab,
false);
gt_option_exclude(idxo->optionspmopt, idxo->optionoutbwttab);
gt_option_parser_add_option(op, idxo->optionoutbwttab);
idxo->optionoutbcktab = gt_option_new_bool("bck",
"output bucket table to file",
&idxo->outbcktab,
false);
gt_option_parser_add_option(op, idxo->optionoutbcktab);
} else {
idxo->optionoutsuftab
= idxo->optionoutlcptab = idxo->optionoutbwttab = NULL;
idxo->sfxstrategy.spmopt_minlength = 0;
#ifndef S_SPLINT_S
gt_registerPackedIndexOptions(op,
&idxo->bwtIdxParams,
BWTDEFOPT_CONSTRUCTION,
idxo->indexname);
#endif
}
gt_option_parser_register_hook(op, gt_index_options_check_set_out_opts, idxo);
return idxo;
}
static GtOptionParser *gt_tyr_mkindex_option_parser_new(void *tool_arguments)
{
GtOptionParser *op;
GtOption *option,
*optionminocc,
*optionmaxocc,
*optionpl,
*optionstoreindex,
*optionstorecounts,
*optionscan,
*optionesa;
Tyr_mkindex_options *arguments = tool_arguments;
op = gt_option_parser_new("[options] -esa suffixerator-index [options]",
"Count and index k-mers in the given enhanced "
"suffix array for a fixed value of k.");
gt_option_parser_set_mailaddress(op,"<*****@*****.**>");
optionesa = gt_option_new_string("esa","specify suffixerator-index\n"
"(mandatory option)",
arguments->str_inputindex,
NULL);
gt_option_is_mandatory(optionesa);
gt_option_parser_add_option(op, optionesa);
option = gt_option_new_ulong("mersize",
"Specify the mer size.",
&arguments->mersize,
20UL);
gt_option_parser_add_option(op, option);
optionminocc
= gt_option_new_ulong("minocc",
"Specify the minimum occurrence number for "
"the mers to output/index",
&arguments->userdefinedminocc,
0);
gt_option_parser_add_option(op, optionminocc);
optionmaxocc
= gt_option_new_ulong("maxocc",
"Specify the maximum occurrence number for "
"the mers to output/index",
&arguments->userdefinedmaxocc,
0);
gt_option_parser_add_option(op, optionmaxocc);
optionpl = gt_option_new_uint_min("pl",
"specify prefix length for bucket boundary construction\n"
"recommendation: use without argument;\n"
"then a reasonable prefix length is automatically determined",
&arguments->userdefinedprefixlength,
0,
1U);
gt_option_argument_is_optional(optionpl);
gt_option_parser_add_option(op, optionpl);
arguments->refoptionpl = gt_option_ref(optionpl);
optionstoreindex = gt_option_new_string("indexname",
"store the mers specified by options "
"-maxocc and -minocc in an index",
arguments->str_storeindex, NULL);
gt_option_parser_add_option(op, optionstoreindex);
optionstorecounts = gt_option_new_bool("counts", "store counts of the mers",
&arguments->storecounts,false);
gt_option_parser_add_option(op, optionstorecounts);
option = gt_option_new_bool("test", "perform tests to verify program "
"correctness", &arguments->performtest,
false);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
optionscan = gt_option_new_bool("scan",
"read enhanced suffix array sequentially "
"instead of mapping it to memory",
&arguments->scanfile,
false);
gt_option_parser_add_option(op, optionscan);
option = gt_option_new_verbose(&arguments->verbose);
gt_option_parser_add_option(op, option);
gt_option_imply(optionpl, optionstoreindex);
gt_option_imply(optionstorecounts, optionstoreindex);
gt_option_imply_either_2(optionstoreindex,optionminocc,optionmaxocc);
return op;
}