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