static GtOptionParser* gt_compressedbits_option_parser_new(void *tool_arguments) { GtCompressdbitsArguments *arguments = tool_arguments; GtOptionParser *op; GtOption *option; gt_assert(arguments); /* init */ op = gt_option_parser_new("[option ...]", "Testing compressed bitsequence, save to disk, reload."); /* -size */ option = gt_option_new_ulong("size", "size of GtBitsequence to create " "(words 32/64 bit)", &arguments->size, 20UL); gt_option_parser_add_option(op, option); arguments->size_op = gt_option_ref(option); /* -samplerate */ option = gt_option_new_uint("samplerate", "samplerate of random GtBitsequence to test", &arguments->samplerate, 32U); gt_option_parser_add_option(op, option); /* -rand */ option = gt_option_new_bool("rand", "create random bitvector", &arguments->fill_random, false); gt_option_parser_add_option(op, option); arguments->rand_op = gt_option_ref(option); /* -check */ option = gt_option_new_bool("check", "compare original with compressed and " "loaded from file", &arguments->check_consistency, false); gt_option_parser_add_option(op, option); arguments->rand_op = gt_option_ref(option); /* -input */ option = gt_option_new_filename( "input", "load vector from file, format is as follows:\n" "[ULL size in bits][[ULL bits]...]\n" " not usable with -size and -rand", arguments->filename); gt_option_parser_add_option(op, option); arguments->filename_op = gt_option_ref(option); gt_option_exclude(arguments->filename_op, arguments->size_op); gt_option_exclude(arguments->filename_op, arguments->rand_op); /* -benches */ option = gt_option_new_ulong("benches", "number of function calls to benchmark", &arguments->benches, 100000UL); gt_option_parser_add_option(op, option); return op; }
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); }
static GtOptionParser *gt_cge_spacedseed_option_parser_new(void *tool_arguments) { GtOptionParser *op; GtOption *option, *optionesaindex, *optionpckindex; Cge_spacedseed_options *arguments = tool_arguments; op = gt_option_parser_new("[options]", "Match spaced seeds."); gt_option_parser_set_mailaddress(op,"<*****@*****.**>"); optionesaindex = gt_option_new_string("esa", "Specify index (enhanced suffix array)", arguments->str_inputindex, NULL); gt_option_parser_add_option(op, optionesaindex); arguments->refoptionesaindex = gt_option_ref(optionesaindex); optionpckindex = gt_option_new_string("pck", "Specify index (packed index)", arguments->str_inputindex, NULL); gt_option_parser_add_option(op, optionpckindex); arguments->refoptionpckindex = gt_option_ref(optionpckindex); gt_option_exclude(optionesaindex,optionpckindex); gt_option_is_mandatory_either(optionesaindex,optionpckindex); option = gt_option_new_filenamearray("q", "Specify files containing the " "query sequences", arguments->queryfilenames); gt_option_parser_add_option(op, option); gt_option_is_mandatory(option); option = gt_option_new_bool("cmp","compare results of offline and online " "searches",&arguments->docompare,false); gt_option_parser_add_option(op, option); gt_option_is_development_option(option); option = gt_option_new_verbose(&arguments->verbose); gt_option_parser_add_option(op, option); return op; }
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_genomediff_option_parser_new(void *tool_arguments) { GtGenomediffArguments *arguments = tool_arguments; GtOptionParser *op; GtOption *option, *option_unitfile; static const char *indextypes[] = { "esa", "pck", "encseq", NULL }; gt_assert(arguments); /* init */ op = gt_option_parser_new("[option ...] " "(INDEX | -indexname NAME SEQFILE SEQFILE [...]) ", "Calculates Kr: pairwise distances between genomes."); /* options */ option = gt_option_new_choice("indextype", "specify type of index, one of: " "esa|pck|encseq. Where encseq is an encoded " "sequence and an enhanced suffix array will be " "constructed only in memory.", arguments->indextype, indextypes[2], indextypes); gt_option_parser_add_option(op, option); option = gt_option_new_string("indexname", "Basename of encseq to construct.", arguments->indexname, NULL); gt_option_parser_add_option(op, option); /*-unitfile*/ option_unitfile = gt_option_new_filename("unitfile", "specifies genomic units, " "see below for description.", arguments->unitfile); gt_option_parser_add_option(op, option_unitfile); arguments->ref_unitfile = gt_option_ref(option_unitfile); /* encseq options */ arguments->loadopts = gt_encseq_options_register_loading(op, arguments->indexname); gt_option_is_development_option( gt_encseq_options_lossless_option(arguments->loadopts)); /* esa options */ arguments->idxopts = gt_index_options_register_esa_noout(op); gt_option_is_development_option( gt_index_options_spmopt_option(arguments->idxopts)); /* scan */ option = gt_option_new_bool("scan", "do not load esa index but scan " "it sequentially.", &arguments->scanfile, true); gt_option_is_extended_option(option); gt_option_parser_add_option(op, option); /* dev options */ /* -max_n */ option = gt_option_new_uword("max_n", "Number of precalculated values " "for ln(n!) and pmax(x).", &arguments->max_ln_n_fac, 1000UL); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); /* -maxdepth */ option = gt_option_new_int("maxdepth", "max depth of .pbi-file, use with " "-indextype pck.", &arguments->user_max_depth, -1); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); /* thresholds */ /* divergence error */ option = gt_option_new_double("thr", "Threshold for difference (du, dl) in " "divergence calculation.\n" "default: 1e-9", &arguments->divergence_threshold, 1e-9); gt_option_is_extended_option(option); gt_option_hide_default(option); gt_option_parser_add_option(op, option); /* expected shulen error */ option = gt_option_new_double("abs_err", "absolute error for expected shulen " "calculation.\n" "default: 1e-5", &arguments->divergence_abs_err, 1e-5); gt_option_is_extended_option(option); gt_option_hide_default(option); gt_option_parser_add_option(op, option); /* relative expected shulen error */ option = gt_option_new_double("rel_err", "relative error for expected shulen " "calculation.\n" "default: 1e-3", &arguments->divergence_rel_err, 1e-3); gt_option_is_extended_option(option); gt_option_hide_default(option); gt_option_parser_add_option(op, option); /* M */ option = gt_option_new_double("M", "threshold for minimum logarithm.\n" "default: DBL_MIN", &arguments->divergence_m, DBL_MIN); gt_option_is_extended_option(option); gt_option_hide_default(option); gt_option_parser_add_option(op, option); /* -v */ option = gt_option_new_verbose(&arguments->verbose); gt_option_parser_add_option(op, option); /* mail */ gt_option_parser_set_mail_address(op, "<*****@*****.**>"); /* doc */ gt_option_parser_set_comment_func(op, gt_gtdata_show_help, NULL); return op; }
static GtOptionParser* gt_condenseq_extract_option_parser_new(void *tool_arguments) { GtCondenserExtractArguments *arguments = tool_arguments; GtOptionParser *op; GtOption *option, *optionrange, *optionseq, *optionseqrange, *optionmode; static const char *modes[] = {"fasta", "concat", NULL}; gt_assert(arguments); /* init */ op = gt_option_parser_new("[options] archive", "Decompresses condenseq archive."); /* -seq */ optionseq = gt_option_new_uword("seq", "only extract sequence identified by its " "number", &arguments->seq, GT_UNDEF_UWORD); gt_option_parser_add_option(op, optionseq); /* -seqrange */ optionseqrange = gt_option_new_range("seqrange", "only extract (inclusive) range of " "consecutive sequences identified by " "their zero based index numbers", &arguments->seqrange, NULL); gt_option_parser_add_option(op, optionseqrange); gt_option_exclude(optionseq, optionseqrange); /* -range */ optionrange = gt_option_new_range("range", "only extract (inclusive) range of zero " "based positions " "(implies option -output concat)", &arguments->range, NULL); gt_option_parser_add_option(op, optionrange); gt_option_exclude(optionseq, optionrange); gt_option_exclude(optionseqrange, optionrange); /* -output */ optionmode = gt_option_new_choice("output", "specify output format " "(choose from fasta|concat)", arguments->mode, modes[0], modes); gt_option_parser_add_option(op, optionmode); gt_option_imply(optionrange, optionmode); /* -sepchar */ option = gt_option_new_string("sepchar", "specify character to print as SEPARATOR " "(implies option -output concat", arguments->sepchar, "|"); gt_option_parser_add_option(op, option); gt_option_imply(option, optionmode); arguments->sepchar_opt = gt_option_ref(option); gt_output_file_info_register_options(arguments->ofi, op, &arguments->outfp); /* -width */ option = gt_option_new_width(&arguments->width); gt_option_parser_add_option(op, option); /* -verbose */ option = gt_option_new_bool("verbose", "Print out verbose output to stderr.", &arguments->verbose, false); gt_option_parser_add_option(op, option); return op; }
static GtOptionParser* gt_readjoiner_assembly_option_parser_new( void *tool_arguments) { GtReadjoinerAssemblyArguments *arguments = tool_arguments; GtOptionParser *op; GtOption *option, *errors_option, *deadend_option, *v_option, *q_option, *bubble_option, *deadend_depth_option; gt_assert(arguments); /* init */ op = gt_option_parser_new("[option ...]", "Construct string graph and output contigs."); /* -readset */ option = gt_option_new_string("readset", "specify the readset name", arguments->readset, NULL); gt_option_parser_add_option(op, option); gt_option_is_mandatory(option); /* -spmfiles */ option = gt_option_new_uint_min("spmfiles", "number of SPM files to read\n" "this must be equal to the value of -j for the overlap phase", &arguments->nspmfiles, 1U, 1U); gt_option_is_extended_option(option); gt_option_parser_add_option(op, option); /* -l */ option = gt_option_new_uint_min("l", "specify the minimum SPM length", &arguments->minmatchlength, 0, 2U); gt_option_is_extended_option(option); gt_option_parser_add_option(op, option); /* -depthcutoff */ option = gt_option_new_uint_min("depthcutoff", "specify the minimal " "number of nodes in a contig", &arguments->depthcutoff, 3U, 1U); gt_option_is_extended_option(option); gt_option_parser_add_option(op, option); /* -lengthcutoff */ option = gt_option_new_uint_min("lengthcutoff", "specify the minimal " "length of a contig", &arguments->lengthcutoff, 100U, 1U); gt_option_is_extended_option(option); gt_option_parser_add_option(op, option); /* -redtrans */ option = gt_option_new_bool("redtrans", "reduce transitive edges", &arguments->redtrans, false); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); /* -errors */ errors_option = gt_option_new_bool("errors", "search graph features which " "may originate from sequencing errors and remove them", &arguments->errors, false); gt_option_is_extended_option(errors_option); gt_option_parser_add_option(op, errors_option); /* -bubble */ bubble_option = gt_option_new_uint("bubble", "number of rounds of p-bubble " "removal to perform", &arguments->bubble, 3U); gt_option_is_extended_option(bubble_option); gt_option_imply(bubble_option, errors_option); gt_option_parser_add_option(op, bubble_option); /* -deadend */ deadend_option = gt_option_new_uint("deadend", "number of rounds of " "dead end removal to perform a dead end", &arguments->deadend, 10U); gt_option_is_extended_option(deadend_option); gt_option_imply(deadend_option, errors_option); gt_option_parser_add_option(op, deadend_option); /* -deadend-depth */ deadend_depth_option = gt_option_new_uint_min("deadend-depth", "specify the " "maximal depth of a path to an end-vertex by which the path shall be " "considered a dead end", &arguments->deadend_depth, 10U, 1U); gt_option_is_extended_option(deadend_depth_option); gt_option_imply(deadend_depth_option, errors_option); gt_option_parser_add_option(op, deadend_depth_option); /* -paths2seq */ option = gt_option_new_bool("paths2seq", "read <indexname>" GT_READJOINER_SUFFIX_CONTIG_PATHS " and write " "<indexname>" GT_READJOINER_SUFFIX_CONTIGS, &arguments->paths2seq, false); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); /* -buffersize */ option = gt_option_new_string("buffersize", "specify size for read buffer" " of paths2seq phase (in bytes, the keywords 'MB' and 'GB' are allowed)", arguments->buffersizearg, NULL); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); arguments->refoptionbuffersize = gt_option_ref(option); /* -vd */ option = gt_option_new_bool("vd", "use verbose descriptions for contigs", &arguments->vd, false); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); /* -astat */ option = gt_option_new_bool("astat", "calculate A-statistics for each contig", &arguments->astat, false); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); /* -cov */ option = gt_option_new_double("cov", "average coverage value to use for the " "A-statistics calculation", &arguments->coverage, (double)0); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); /* -copynum */ option = gt_option_new_bool("copynum", "load reads copy numbers list from " "file for the A-statistics calculation", &arguments->copynum, false); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); /* -v */ v_option = gt_option_new_verbose(&arguments->verbose); gt_option_parser_add_option(op, v_option); /* -q */ q_option = gt_option_new_bool("q", "suppress standard output messages", &arguments->quiet, false); gt_option_parser_add_option(op, q_option); gt_option_exclude(q_option, v_option); /* -load */ option = gt_option_new_bool("load", "save the string graph from file", &arguments->load, false); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); /* -save */ option = gt_option_new_bool("save", "save the string graph to file", &arguments->save, false); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); /* -show_contigs_info */ option = gt_option_new_bool("cinfo", "output additional files required " "for contigs graph construction (eqlen only)", &arguments->show_contigs_info, false); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); gt_option_parser_set_version_func(op, gt_readjoiner_show_version); gt_option_parser_set_max_args(op, 0); return op; }
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; }
static GtOptionParser* gt_tir_option_parser_new(void *tool_arguments) { GtTirArguments *arguments = tool_arguments; GtOptionParser *op; GtOption *optionindex, /* index */ *optionseed, /* minseedlength */ *optionminlentir, /* minimal length of TIR */ *optionmaxlentir, /* maximal length of TIR */ *optionmindisttir, /* minimal distance of TIRs */ *optionmaxdisttir, /* maximal distance of TIRs */ *optionmat, /* arbitrary scores */ *optionmis, *optionins, *optiondel, *optionxdrop, /* xdropbelowscore for extension alignment */ *optionsimilar, /* similarity threshold */ *optionoverlaps, /* for overlaps */ *optionmintsd, /* minimal length for Target Site Duplication */ *optionmaxtsd, /* maximal length for Target Site Duplication */ *optionvicinity; /* vicinity around TIRs to be searched for TSDs */ static const char *overlaps[] = { "best", /* default */ "no", "all", NULL }; gt_assert(arguments); /* init */ op = gt_option_parser_new("[option ...] -index INDEXNAME", "Identify Terminal Inverted Repeat (TIR) elements," "such as DNA transposons."); /* -index */ optionindex = gt_option_new_string("index", "specify the name of the enhanced suffix " "array index (mandatory)", arguments->str_indexname, NULL); gt_option_is_mandatory(optionindex); gt_option_parser_add_option(op, optionindex); /* -seed */ optionseed = gt_option_new_ulong_min("seed", "specify minimum seed length for " "exact repeats", &arguments->min_seed_length, 20UL, 2UL); gt_option_parser_add_option(op, optionseed); /* -minlentir */ optionminlentir = gt_option_new_ulong_min_max("mintirlen", "specify minimum length for " "each TIR", &arguments->min_TIR_length, 27UL, 1UL, GT_UNDEF_ULONG); gt_option_parser_add_option(op, optionminlentir); /* -maxlentir */ optionmaxlentir = gt_option_new_ulong_min_max("maxtirlen", "specify maximum length for " "each TIR", &arguments->max_TIR_length, 1000UL, 1UL, GT_UNDEF_ULONG); gt_option_parser_add_option(op, optionmaxlentir); /* -mindisttir */ optionmindisttir = gt_option_new_ulong_min_max("mintirdist", "specify minimum distance of " "TIRs", &arguments->min_TIR_distance, 100UL, 1UL, GT_UNDEF_ULONG); gt_option_parser_add_option(op, optionmindisttir); /* -maxdisttir */ optionmaxdisttir = gt_option_new_ulong_min_max("maxtirdist", "specify maximum distance of " "TIRs", &arguments->max_TIR_distance, 10000UL, 1UL, GT_UNDEF_ULONG); gt_option_parser_add_option(op, optionmaxdisttir); optionmat = gt_option_new_int_min("mat", "specify matchscore for " "extension-alignment", &arguments->arbit_scores.mat, 2, 1); gt_option_parser_add_option(op, optionmat); /* -mis */ optionmis = gt_option_new_int_max("mis", "specify mismatchscore for " "extension-alignment", &arguments->arbit_scores.mis, -2, -1); gt_option_parser_add_option(op, optionmis); /* -ins */ optionins = gt_option_new_int_max("ins", "specify insertionscore for " "extension-alignment", &arguments->arbit_scores.ins, -3, -1); gt_option_parser_add_option(op, optionins); /* -del */ optiondel = gt_option_new_int_max("del", "specify deletionscore for " "extension-alignment", &arguments->arbit_scores.del, -3, -1); gt_option_parser_add_option(op, optiondel); /* -xdrop */ optionxdrop = gt_option_new_int_min("xdrop", "specify xdropbelowscore for " "extension-alignment", &arguments->xdrop_belowscore, (int) 5, (int) 0); gt_option_parser_add_option(op, optionxdrop); /* -similar */ optionsimilar = gt_option_new_double_min_max("similar", "specify similaritythreshold in " "range [1..100%]", &arguments->similarity_threshold, (double) 85.0, (double) 0.0, 100.0); gt_option_parser_add_option(op, optionsimilar); /* -overlaps */ optionoverlaps = gt_option_new_choice("overlaps", "specify no|best|all", arguments->str_overlaps, overlaps[0], overlaps); gt_option_parser_add_option(op, optionoverlaps); arguments->optionoverlaps = gt_option_ref(optionoverlaps); /* -mintsd */ optionmintsd = gt_option_new_ulong_min_max("mintsd", "specify minimum length for each " "TSD", &arguments->min_TSD_length, 2U, 0, GT_UNDEF_UINT); gt_option_parser_add_option(op, optionmintsd); /* -maxtsd */ optionmaxtsd = gt_option_new_ulong_min_max("maxtsd", "specify maximum length for each " "TSD", &arguments->max_TSD_length, 11U, 0, GT_UNDEF_UINT); gt_option_parser_add_option(op, optionmaxtsd); gt_option_imply(optionmaxtsd, optionmintsd); /* -vicinity */ optionvicinity = gt_option_new_ulong_min_max("vic", "specify the number of " "nucleotides (to the left and " "to the right) that will be " "searched for TSDs around 5' " "and 3' boundary of predicted " "TIRs", &arguments->vicinity, 60U, 1U, 500U); gt_option_parser_add_option(op, optionvicinity); return op; }
static GtOptionParser *gt_idxlocali_option_parser_new (void *tool_arguments) { IdxlocaliOptions *arguments = tool_arguments; GtOptionParser *op; GtOption *option, *optionesaindex, *optionpckindex, *optiononline, *optioncmp; gt_assert (arguments != NULL); arguments->indexname = gt_str_new (); arguments->queryfiles = gt_str_array_new (); op = gt_option_parser_new ("[options] -q query-file-names [-esa|-pck] indexname", "Find all local alignments using suffix tree."); gt_option_parser_set_mailaddress (op, "<*****@*****.**>"); option = gt_option_new_filenamearray ("q","Specify files containing the " "query sequences", arguments->queryfiles); gt_option_parser_add_option (op, option); option = gt_option_new_long ("match", "Specify match score", &arguments->matchscore, 1L); gt_option_parser_add_option (op, option); option = gt_option_new_long ("mismatch", "Specify mismatch score", &arguments->mismatchscore, -3L); gt_option_parser_add_option (op, option); option = gt_option_new_long ("gapstart", "Specify gap start score", &arguments->gapstart, -5L); gt_option_parser_add_option (op, option); option = gt_option_new_long ("gapextend", "Specify gap extension score", &arguments->gapextend, -2L); gt_option_parser_add_option (op, option); option = gt_option_new_ulong_min ("th", "Specify the threshold", &arguments->threshold, 0, 1UL); gt_option_parser_add_option (op, option); gt_option_is_mandatory (option); optionesaindex = gt_option_new_string ("esa", "Specify index " "(enhanced suffix array)", arguments->indexname, NULL); gt_option_parser_add_option (op, optionesaindex); arguments->refoptionesaindex = gt_option_ref (optionesaindex); optionpckindex = gt_option_new_string ("pck", "Specify index (packed index)", arguments->indexname, NULL); gt_option_parser_add_option (op, optionpckindex); arguments->refoptionpckindex = gt_option_ref (optionpckindex); gt_option_exclude (optionesaindex, optionpckindex); gt_option_is_mandatory_either (optionesaindex, optionpckindex); optiononline = gt_option_new_bool("online","Perform online searches", &arguments->doonline, false); gt_option_parser_add_option(op, optiononline); gt_option_is_development_option(optiononline); optioncmp = gt_option_new_bool("cmp","Compare results of offline and online " "searches", &arguments->docompare, false); gt_option_parser_add_option(op,optioncmp); gt_option_exclude(optiononline,optioncmp); option = gt_option_new_bool("s", "Show alignments", &arguments->showalignment, false); gt_option_parser_add_option (op, option); option = gt_option_new_verbose(&arguments->verbose); gt_option_parser_add_option(op, option); return op; }
static GtOptionParser* gt_encseq2spm_option_parser_new(void *tool_arguments) { GtEncseq2spmArguments *arguments = tool_arguments; GtOptionParser *op; GtOption *option, *optionparts, *optionmemlimit; gt_assert(arguments); /* init */ op = gt_option_parser_new("[option ...] [file]", "Compute suffix prefix matches " "from encoded sequence."); /* -l */ option = gt_option_new_uint_min("l", "specify the minimum length", &arguments->minmatchlength, 0, 1U); gt_option_parser_add_option(op, option); gt_option_is_mandatory(option); /* -parts */ optionparts = gt_option_new_uint("parts", "specify the number of parts", &arguments->numofparts, 0U); gt_option_parser_add_option(op, optionparts); /* -memlimit */ 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)", arguments->memlimitarg, NULL); gt_option_parser_add_option(op, optionmemlimit); gt_option_exclude(optionmemlimit, optionparts); arguments->refoptionmemlimit = gt_option_ref(optionmemlimit); /* -checksuftab */ option = gt_option_new_bool("checksuftab", "check the suffix table", &arguments->checksuftab, false); gt_option_parser_add_option(op, option); gt_option_is_development_option(option); /* -singlestrand */ option = gt_option_new_bool("singlestrand", "use only the forward strand " "of the sequence", &arguments->singlestrand, false); gt_option_parser_add_option(op, option); /* -spm */ option = gt_option_new_string("spm", "specify output for spms", arguments->spmspec, NULL); gt_option_parser_add_option(op, option); /* -ii */ option = gt_option_new_string("ii", "specify the input sequence", arguments->encseqinput, NULL); gt_option_parser_add_option(op, option); gt_option_is_mandatory(option); /* -onlyaccum */ option = gt_option_new_bool("onlyaccum", "only accumulate codes", &arguments->onlyaccum, false); gt_option_parser_add_option(op, option); gt_option_is_development_option(option); /* -onlyallfirstcodes */ option = gt_option_new_bool("onlyallfirstcodes", "only determines allcodes", &arguments->onlyallfirstcodes, false); gt_option_parser_add_option(op, option); gt_option_is_development_option(option); /* -addbscachedepth */ option = gt_option_new_uint("addbscachedepth", "only determines allcodes", &arguments->addbscache_depth, 5U); gt_option_parser_add_option(op, option); gt_option_is_development_option(option); /* -phase2extra */ option = gt_option_new_string("phase2extra", "specify amount of additional space required for " "the second phase of the computation involving the " "processing of the intervals (in bytes, " "the keywords 'MB' and 'GB' are allowed)", arguments->phase2extraarg, NULL); gt_option_parser_add_option(op, option); arguments->refoptionphase2extra = gt_option_ref(option); gt_option_is_development_option(option); /* -radixlarge */ option = gt_option_new_bool("radixlarge", "use large tables for radixsort", &arguments->radixlarge, false); gt_option_parser_add_option(op, option); gt_option_is_development_option(option); /* -radixparts */ option = gt_option_new_uint("radixparts", "specify the number of parts " "for radixsort", &arguments->radixparts, 1U); gt_option_parser_add_option(op, option); gt_option_is_development_option(option); /* -singlescan */ option = gt_option_new_uint("singlescan", "run a single scan: 1=fast; " "2=fast with check; 3=fast with output; " "4=sfx-mapped4-version", &arguments->singlescan, 0); gt_option_parser_add_option(op, option); gt_option_is_development_option(option); /* -forcek */ option = gt_option_new_uint("forcek", "specify the value of k", &arguments->forcek, 0); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); option = gt_option_new_verbose(&arguments->verbose); gt_option_parser_add_option(op, option); return op; }
static GtOptionParser* gt_tir_option_parser_new(void *tool_arguments) { GtTirArguments *arguments = tool_arguments; GtOptionParser *op; GtOption *optionindex, /* index */ *optionseed, /* minseedlength */ *optionminlentir, /* minimal length of TIR */ *optionmaxlentir, /* maximal length of TIR */ *optionmindisttir, /* minimal distance of TIRs */ *optionmaxdisttir, /* maximal distance of TIRs */ *optionmat, /* arbitrary scores */ *optionmis, *optionins, *optiondel, *optionxdrop, /* xdropbelowscore for extension alignment */ *optionsimilar, /* similarity threshold */ *optionoverlaps, /* for overlaps */ *optionmintsd, /* minimal length for Target Site Duplication */ *optionmaxtsd, /* maximal length for Target Site Duplication */ *optionvicinity, /* vicinity around TIRs to be searched for TSDs */ *optionhmms, *optionevalcutoff, *optionpdomcutoff, *optionmaxgap; static const char *overlaps[] = { "best", /* default */ "no", "all", NULL }; static const char *cutoffs[] = { "NONE", "GA", "TC", NULL }; gt_assert(arguments); /* init */ op = gt_option_parser_new("[option ...] -index INDEXNAME", "Identify Terminal Inverted Repeat (TIR) elements," "such as DNA transposons."); /* -index */ optionindex = gt_option_new_string("index", "specify the name of the enhanced suffix " "array index (mandatory)", arguments->str_indexname, NULL); gt_option_is_mandatory(optionindex); gt_option_parser_add_option(op, optionindex); /* -seed */ optionseed = gt_option_new_uword_min("seed", "specify minimum seed length for " "exact repeats", &arguments->min_seed_length, 20UL, 2UL); gt_option_parser_add_option(op, optionseed); /* -minlentir */ optionminlentir = gt_option_new_uword_min_max("mintirlen", "specify minimum length for " "each TIR", &arguments->min_TIR_length, 27UL, 1UL, GT_UNDEF_UWORD); gt_option_parser_add_option(op, optionminlentir); /* -maxlentir */ optionmaxlentir = gt_option_new_uword_min_max("maxtirlen", "specify maximum length for " "each TIR", &arguments->max_TIR_length, 1000UL, 1UL, GT_UNDEF_UWORD); gt_option_parser_add_option(op, optionmaxlentir); /* -mindisttir */ optionmindisttir = gt_option_new_uword_min_max("mintirdist", "specify minimum distance of " "TIRs", &arguments->min_TIR_distance, 100UL, 1UL, GT_UNDEF_UWORD); gt_option_parser_add_option(op, optionmindisttir); /* -maxdisttir */ optionmaxdisttir = gt_option_new_uword_min_max("maxtirdist", "specify maximum distance of " "TIRs", &arguments->max_TIR_distance, 10000UL, 1UL, GT_UNDEF_UWORD); gt_option_parser_add_option(op, optionmaxdisttir); optionmat = gt_option_new_int_min("mat", "specify matchscore for " "extension-alignment", &arguments->arbit_scores.mat, 2, 1); gt_option_parser_add_option(op, optionmat); /* -mis */ optionmis = gt_option_new_int_max("mis", "specify mismatchscore for " "extension-alignment", &arguments->arbit_scores.mis, -2, -1); gt_option_parser_add_option(op, optionmis); /* -ins */ optionins = gt_option_new_int_max("ins", "specify insertionscore for " "extension-alignment", &arguments->arbit_scores.ins, -3, -1); gt_option_parser_add_option(op, optionins); /* -del */ optiondel = gt_option_new_int_max("del", "specify deletionscore for " "extension-alignment", &arguments->arbit_scores.del, -3, -1); gt_option_parser_add_option(op, optiondel); /* -xdrop */ optionxdrop = gt_option_new_int_min("xdrop", "specify xdropbelowscore for " "extension-alignment", &arguments->xdrop_belowscore, (int) 5, (int) 0); gt_option_parser_add_option(op, optionxdrop); /* -similar */ optionsimilar = gt_option_new_double_min_max("similar", "specify similaritythreshold in " "range [1..100%]", &arguments->similarity_threshold, (double) 85.0, (double) 0.0, 100.0); gt_option_parser_add_option(op, optionsimilar); /* -overlaps */ optionoverlaps = gt_option_new_choice("overlaps", "specify no|best|all", arguments->str_overlaps, overlaps[0], overlaps); gt_option_parser_add_option(op, optionoverlaps); arguments->optionoverlaps = gt_option_ref(optionoverlaps); /* -mintsd */ optionmintsd = gt_option_new_uword_min_max("mintsd", "specify minimum length for each " "TSD", &arguments->min_TSD_length, 2U, 0, GT_UNDEF_UINT); gt_option_parser_add_option(op, optionmintsd); /* -maxtsd */ optionmaxtsd = gt_option_new_uword_min_max("maxtsd", "specify maximum length for each " "TSD", &arguments->max_TSD_length, 11U, 0, GT_UNDEF_UINT); gt_option_parser_add_option(op, optionmaxtsd); gt_option_imply(optionmaxtsd, optionmintsd); /* -vicinity */ optionvicinity = gt_option_new_uword_min_max("vic", "specify the number of " "nucleotides (to the left and " "to the right) that will be " "searched for TSDs around 5' " "and 3' boundary of predicted " "TIRs", &arguments->vicinity, 60U, 1U, 500U); gt_option_parser_add_option(op, optionvicinity); optionhmms = gt_option_new_filename_array("hmms", "profile HMM models for domain detection " "(separate by spaces, finish with --) in " "HMMER3 format\n" "Omit this option to disable pHMM search.", arguments->hmm_files); gt_option_parser_add_option(op, optionhmms); optionevalcutoff = gt_option_new_probability("pdomevalcutoff", "global E-value cutoff for pHMM search\n" "default 1E-6", &arguments->evalue_cutoff, 0.000001); gt_option_parser_add_option(op, optionevalcutoff); gt_option_hide_default(optionevalcutoff); gt_option_imply(optionevalcutoff, optionhmms); optionpdomcutoff = gt_option_new_choice("pdomcutoff", "model-specific score cutoff\n" "choose from TC (trusted cutoff) | " "GA (gathering cutoff) | " "NONE (no cutoffs)", arguments->cutoffs, cutoffs[1], cutoffs); gt_option_parser_add_option(op, optionpdomcutoff); gt_option_imply(optionpdomcutoff, optionhmms); /* XXX: make -pdomcutoff and -pdomevalcutoff mutually exclusive */ optionmaxgap = gt_option_new_uint("maxgaplen", "maximal allowed gap size between fragments (in amino " "acids) when chaining pHMM hits for a protein domain", &arguments->chain_max_gap_length, 50U); gt_option_parser_add_option(op, optionmaxgap); gt_option_is_extended_option(optionmaxgap); gt_option_imply(optionmaxgap, optionhmms); return op; }
static GtOptionParser* gt_gdiffcalc_option_parser_new(void *tool_arguments) { GtGenomediffArguments *arguments = tool_arguments; GtOptionParser *op; GtOption *option, *option_unitfile; gt_assert(arguments); /* init */ op = gt_option_parser_new("[option ...] " "-indexname NAME AVGSHULEN) ", "Calculates Kr: pairwise distances between genomes."); /* options */ option = gt_option_new_string("indexname", "Basename of encseq to construct.", arguments->indexname, NULL); gt_option_is_mandatory(option); gt_option_parser_add_option(op, option); /*-unitfile*/ option_unitfile = gt_option_new_filename("unitfile", "specifies genomic units, see below for description", arguments->unitfile); gt_option_parser_add_option(op, option_unitfile); arguments->ref_unitfile = gt_option_ref(option_unitfile); /* encseq options */ arguments->loadopts = gt_encseq_options_register_loading(op, arguments->indexname); gt_option_is_development_option( gt_encseq_options_lossless_option(arguments->loadopts)); /* dev options */ /* -max_n */ option = gt_option_new_uword("max_n", "Number of precalculated values " "for ln(n!) and pmax(x)", &arguments->max_ln_n_fac, 1000UL); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); /* thresholds */ /* divergence error */ option = gt_option_new_double("thr", "Threshold for difference (du, dl) in " "divergence calculation.\n" "default: 1e-9", &arguments->divergence_threshold, 1e-9); gt_option_is_extended_option(option); gt_option_hide_default(option); gt_option_parser_add_option(op, option); /* expected shulen error */ option = gt_option_new_double("abs_err", "absolute error for expected shulen " "calculation.\n" "default: 1e-5", &arguments->divergence_abs_err, 1e-5); gt_option_is_extended_option(option); gt_option_hide_default(option); gt_option_parser_add_option(op, option); /* relative expected shulen error */ option = gt_option_new_double("rel_err", "relative error for expected shulen " "calculation.\n" "default: 1e-3", &arguments->divergence_rel_err, 1e-3); gt_option_is_extended_option(option); gt_option_hide_default(option); gt_option_parser_add_option(op, option); /* M */ option = gt_option_new_double("M", "threshold for minimum logarithm.\n" "default: DBL_MIN", &arguments->divergence_m, DBL_MIN); gt_option_is_extended_option(option); gt_option_hide_default(option); gt_option_parser_add_option(op, option); /* -v */ option = gt_option_new_verbose(&arguments->verbose); gt_option_parser_add_option(op, option); /* mail */ gt_option_parser_set_mail_address(op, "<*****@*****.**>"); /* doc */ gt_option_parser_set_comment_func(op, gt_gtdata_show_help, NULL); return op; }
static GtOptionParser *gt_repfind_option_parser_new(void *tool_arguments) { GtOptionParser *op; GtOption *option, *reverseoption, *queryoption, *extendseedoption, *scanoption, *sampleoption, *forwardoption, *spmoption; Maxpairsoptions *arguments = tool_arguments; op = gt_option_parser_new("[options] -ii indexname", "Compute maximal repeats."); gt_option_parser_set_mail_address(op,"<*****@*****.**>"); option = gt_option_new_uint_min("l","Specify minimum length of repeats", &arguments->userdefinedleastlength, 20U, 1U); gt_option_parser_add_option(op, option); forwardoption = gt_option_new_bool("f","Compute maximal forward repeats", &arguments->forward, true); gt_option_parser_add_option(op, forwardoption); arguments->refforwardoption = gt_option_ref(forwardoption); reverseoption = gt_option_new_bool("r","Compute maximal reverse matches", &arguments->reverse, false); gt_option_parser_add_option(op, reverseoption); sampleoption = gt_option_new_uword_min("samples","Specify number of samples", &arguments->samples, 0, 1UL); gt_option_is_development_option(sampleoption); gt_option_parser_add_option(op, sampleoption); spmoption = gt_option_new_bool("spm","Search for suffix prefix matches", &arguments->searchspm, false); gt_option_is_development_option(spmoption); gt_option_parser_add_option(op, spmoption); extendseedoption = gt_option_new_bool("extend","Extend seed to both sides", &arguments->extendseed, false); gt_option_is_development_option(extendseedoption); gt_option_parser_add_option(op, extendseedoption); scanoption = gt_option_new_bool("scan","scan index rather than mapping " "it to main memory", &arguments->scanfile, false); gt_option_parser_add_option(op, scanoption); option = gt_option_new_string("ii", "Specify input index", arguments->indexname, NULL); gt_option_parser_add_option(op, option); gt_option_is_mandatory(option); queryoption = gt_option_new_filename_array("q", "Specify query files", arguments->queryfiles); gt_option_is_development_option(queryoption); gt_option_parser_add_option(op, queryoption); option = gt_option_new_bool("v", "be verbose ", &arguments->beverbose, false); gt_option_parser_add_option(op, option); gt_option_exclude(queryoption,sampleoption); gt_option_exclude(queryoption,scanoption); gt_option_exclude(queryoption,reverseoption); gt_option_exclude(queryoption,spmoption); gt_option_exclude(reverseoption,spmoption); gt_option_exclude(queryoption,spmoption); gt_option_exclude(sampleoption,spmoption); return op; }
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 GtOptionParser *gt_tyr_occratio_option_parser_new(void *tool_arguments) { GtOptionParser *op; GtOption *optionmersizes, *optionesa, *optionminmersize, *optionmaxmersize, *optionstep, *optionoutput, *option; Tyr_occratio_options *arguments = tool_arguments; op = gt_option_parser_new("[options] -esa suffixerator-index [options]", "Compute occurrence ratio for a set of sequences " "represented by an enhanced suffix array."); 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); optionminmersize = gt_option_new_ulong_min("minmersize", "specify minimum mer size for which " "to compute the occurrence distribution", &arguments->minmersize,0,1UL); gt_option_parser_add_option(op, optionminmersize); optionmaxmersize = gt_option_new_ulong_min("maxmersize", "specify maximum mer size for which " "to compute the occurrence distribution", &arguments->maxmersize,0,1UL); gt_option_parser_add_option(op, optionmaxmersize); optionstep = gt_option_new_ulong_min("step", "specify step size when specifying mer sizes", &arguments->stepmersize,1UL,1UL); gt_option_parser_add_option(op, optionstep); optionmersizes = gt_option_new_stringarray( "mersizes", "specify mer sizes as non-empty sequence of " "non decreasing positive integers", arguments->mersizesstrings); arguments->refoptionmersizes = gt_option_ref(optionmersizes); gt_option_parser_add_option(op, optionmersizes); optionoutput = gt_option_new_stringarray( "output", "use combination of the following keywords: " "unique nonunique nonuniquemulti relative total " "to specify kind of output", arguments->outputspec); gt_option_parser_add_option(op, optionoutput); option = gt_option_new_bool("scan", "read suffixerator-index sequentially " "instead of mapping it to memory", &arguments->scanfile, false); gt_option_parser_add_option(op, option); option = gt_option_new_verbose(&arguments->verbose); gt_option_parser_add_option(op, option); gt_option_exclude(optionmersizes,optionminmersize); gt_option_exclude(optionmersizes,optionmaxmersize); gt_option_exclude(optionmersizes,optionstep); return op; }