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_encseq_decode_option_parser_new(void *tool_arguments) { GtOptionParser *op; GtOption *option, *optionsep, *optionseq, *optionseqrange, *optionmode; GtEncseqDecodeArguments *arguments = (GtEncseqDecodeArguments*) tool_arguments; static const char *modes[] = {"fasta", "concat", NULL}; /* init */ op = gt_option_parser_new("(sequence_file|indexname)", "Decode/extract encoded sequences."); /* encseq options */ arguments->eopts = gt_encseq_options_register_loading(op, NULL); gt_encseq_options_add_readmode_option(op, arguments->dir); /* -singlechars */ option = gt_option_new_bool("singlechars", "do not use a GtEncseqReader but access each " "sequence character separately", &arguments->singlechars, false); gt_option_is_extended_option(option); gt_option_parser_add_option(op, option); /* -seq */ optionseq = gt_option_new_uword("seq", "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", "extract multiple consecutive sequences", &arguments->seqrng, NULL); gt_option_parser_add_option(op, optionseqrange); gt_option_exclude(optionseqrange, optionseq); /* -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); /* -range */ option = gt_option_new_range("range", "concatenated range to extract " "(implies '-output concat')", &arguments->rng, NULL); gt_option_parser_add_option(op, option); gt_option_imply(option, optionmode); /* -sepchar */ optionsep = gt_option_new_string("sepchar", "specify character to print as SEPARATOR", arguments->sepchar, "|"); gt_option_parser_add_option(op, optionsep); gt_option_imply(optionsep, optionmode); gt_option_parser_set_min_max_args(op, 1, 1); return op; }
void gth_sa_filter_register_options(GtOptionParser *op, GthSAFilter *sa_filter, bool extended_options) { GtOption *o; gt_assert(sa_filter && op); /* -minalignmentscore */ o = gt_option_new_double_min_max(MINALIGNMENTSCORE_OPT_CSTR, "set the " "minimum alignment score for spliced " "alignments to be included into the set of " "spliced alignments", &sa_filter->min_alignmentscore, GTH_DEFAULT_MIN_ALIGNMENTSCORE, GTH_DEFAULT_MIN_ALIGNMENTSCORE, GTH_DEFAULT_MAX_ALIGNMENTSCORE); if (extended_options) gt_option_is_extended_option(o); gt_option_parser_add_option(op, o); /* -maxalignmentscore */ o = gt_option_new_double_min_max(MAXALIGNMENTSCORE_OPT_CSTR, "set the " "maximum alignment score for spliced " "alignments to be included into the set of " "spliced alignments", &sa_filter->max_alignmentscore, GTH_DEFAULT_MAX_ALIGNMENTSCORE, GTH_DEFAULT_MIN_ALIGNMENTSCORE, GTH_DEFAULT_MAX_ALIGNMENTSCORE); if (extended_options) gt_option_is_extended_option(o); gt_option_parser_add_option(op, o); /* -mincoverage */ o = gt_option_new_double_min_max(MINCOVERAGE_OPT_CSTR, "set the minimum " "coverage for spliced alignments to be " "included into the set of spliced " "alignments", &sa_filter->min_coverage, GTH_DEFAULT_MIN_COVERAGE, GTH_DEFAULT_MIN_COVERAGE, GTH_DEFAULT_MAX_COVERAGE); if (extended_options) gt_option_is_extended_option(o); gt_option_parser_add_option(op, o); /* -maxcoverage */ o = gt_option_new_double_min_max(MAXCOVERAGE_OPT_CSTR, "set the maximum " "coverage for spliced alignments to be " "included into the set of spliced " "alignments", &sa_filter->max_coverage, GTH_DEFAULT_MAX_COVERAGE, GTH_DEFAULT_MIN_COVERAGE, GTH_DEFAULT_MAX_COVERAGE); if (extended_options) gt_option_is_extended_option(o); gt_option_parser_add_option(op, o); /* register hooks to check the arguments after the option parsing */ gt_option_parser_register_hook(op, sa_filter_check_arguments, sa_filter); }
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_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_linspace_align_option_parser_new(void *tool_arguments) { GtLinspaceArguments *arguments = tool_arguments; GtOptionParser *op; GtOption *optionstrings, *optionfiles, *optionglobal, *optionlocal, *optiondna, *optionprotein, *optioncostmatrix, *optionlinearcosts, *optionaffinecosts, *optionoutputfile, *optionshowscore, *optionshowsequences, *optiondiagonal, *optiondiagonalbonds, *optionsimilarity, *optiontsfactor, *optionspacetime, *optionscoreonly, *optionwildcardsymbol; gt_assert(arguments); /* init */ op = gt_option_parser_new("[ss|ff] sequence1 sequence2 [dna|protein] " "[global|local] [a|l] costs/scores " "[additional options]", "Apply function to compute alignment."); gt_option_parser_set_mail_address(op, "<*****@*****.**>"); /* -bool */ optionglobal = gt_option_new_bool("global", "global alignment", &arguments->global, false); gt_option_parser_add_option(op, optionglobal); optionlocal = gt_option_new_bool("local", "local alignment", &arguments->local, false); gt_option_parser_add_option(op, optionlocal); optiondiagonal = gt_option_new_bool("d", "diagonalband alignment", &arguments->diagonal, false); gt_option_parser_add_option(op, optiondiagonal); optiondna = gt_option_new_bool("dna", "type of sequences: DNA", &arguments->dna, false); gt_option_parser_add_option(op, optiondna); optionprotein = gt_option_new_bool("protein", "type of sequences: protein", &arguments->protein, false); gt_option_parser_add_option(op, optionprotein); optionwildcardsymbol = gt_option_new_bool("wildcard", "show symbol used to " "represented wildcards in output", &arguments->wildcardshow, false); gt_option_parser_add_option(op, optionwildcardsymbol); /* special case, if given matrix includes cost values in place of scores */ optioncostmatrix = gt_option_new_bool("costmatrix", "describes type of " "given substituation matrix", &arguments->has_costmatrix, false); gt_option_parser_add_option(op, optioncostmatrix); optionshowscore = gt_option_new_bool("showscore", "show score for alignment, " "please note it will calculate costs " "for global alignments and scores for " "local alignemnts always, independtly " "of input ", &arguments->showscore, false); gt_option_parser_add_option(op, optionshowscore); optionshowsequences = gt_option_new_bool("showsequences", "show sequences u " "and v in front of alignment", &arguments->showsequences, false); gt_option_parser_add_option(op, optionshowsequences); optionscoreonly = gt_option_new_bool("showonlyscore", "show only score for " "generated alignment to compare with " "other algorithms", &arguments->scoreonly, false); gt_option_parser_add_option(op, optionscoreonly); optionspacetime = gt_option_new_bool("spacetime", "write space peak and time" " overall on stdout", &arguments->spacetime, false); gt_option_parser_add_option(op, optionspacetime); /* -str */ optionstrings = gt_option_new_string_array("ss", "input, use two strings", arguments->strings); gt_option_parser_add_option(op, optionstrings); optionfiles = gt_option_new_filename_array("ff", "input, use two files", arguments->files); gt_option_parser_add_option(op, optionfiles); optionlinearcosts = gt_option_new_string_array("l", "lineargapcosts, " "use match, mismatch and " "gapcost, alternatively " "substituationmatrix and " "gapcost", arguments->linearcosts); gt_option_parser_add_option(op, optionlinearcosts); optionaffinecosts = gt_option_new_string_array("a", "affinegapcosts, " "use match, mismatch, gap_extension " "and gap_opening, alternatively " "substituationmatrix, gap_extension " "and gap_opening", arguments->affinecosts); gt_option_parser_add_option(op, optionaffinecosts); optiondiagonalbonds = gt_option_new_string_array("lr", "specified left and " "right shift of diagonal", arguments->diagonalbonds); gt_option_parser_add_option(op, optiondiagonalbonds); optionoutputfile = gt_option_new_string("o", "print alignment, " "use outputfile", arguments->outputfile, "stdout"); gt_option_parser_add_option(op, optionoutputfile); /* -ulong */ optiontsfactor = gt_option_new_ulong("t", "timesquarefactor to organize " "time and space", &arguments->timesquarefactor,1); gt_option_parser_add_option(op, optiontsfactor); /* -double */ optionsimilarity = gt_option_new_probability("similarity", "specified left " "and right shift of diagonal by " "similarity of sequences, " "0 <= similarty <= 1", &arguments->similarity, 0); gt_option_parser_add_option(op, optionsimilarity); /* dependencies */ gt_option_is_mandatory_either(optionstrings, optionfiles); gt_option_is_mandatory_either(optiondna, optionprotein); gt_option_exclude(optionlocal, optionglobal); gt_option_exclude(optionlinearcosts, optionaffinecosts); gt_option_exclude(optiondna, optionprotein); gt_option_exclude(optionshowsequences, optionscoreonly); gt_option_exclude(optionsimilarity, optiondiagonalbonds); gt_option_imply_either_2(optionfiles, optionglobal, optionlocal); gt_option_imply_either_2(optiondna, optionstrings, optionfiles); gt_option_imply_either_2(optionstrings, optionglobal, optionlocal); gt_option_imply_either_2(optionprotein, optionstrings, optionfiles); gt_option_imply_either_2(optionlocal, optionlinearcosts, optionaffinecosts); gt_option_imply_either_2(optionglobal, optionlinearcosts, optionaffinecosts); gt_option_imply_either_2(optionshowscore,optionlinearcosts,optionaffinecosts); gt_option_imply_either_2(optionshowsequences, optionstrings, optionfiles); gt_option_imply_either_2(optionscoreonly,optionlinearcosts,optionaffinecosts); gt_option_imply(optiondiagonal, optionglobal); gt_option_imply(optiondiagonalbonds, optiondiagonal); gt_option_imply(optionsimilarity, optiondiagonal); gt_option_imply(optioncostmatrix, optionprotein); /* extended options */ gt_option_is_extended_option(optiontsfactor); gt_option_is_extended_option(optionshowscore); gt_option_is_extended_option(optionwildcardsymbol); gt_option_is_extended_option(optioncostmatrix); /* development option(s) */ gt_option_is_development_option(optionspacetime); gt_option_is_development_option(optionscoreonly);/*only useful to test*/ return op; }
static GtOptionParser* gt_condenseq_compress_option_parser_new(void *tool_arguments) { GtCondenseqCompressArguments *arguments = tool_arguments; GtOptionParser *op; GtOption *option, *option_fraction; gt_assert(arguments); /* init */ op = gt_option_parser_new("[options] INPUTENCSEQ", "Compresses a GtEncseq to a UniqueEncseq."); /* -indexname */ option = gt_option_new_string("indexname", "path and basename of files to store", arguments->indexname, NULL); gt_option_parser_add_option(op, option); /* -kmersize */ option = gt_option_new_uint_min("kmersize", "kmer-size used for the seeds, default " "depends on alphabet size", &arguments->kmersize, GT_UNDEF_UINT, 2U); gt_option_parser_add_option(op, option); /* -windowsize */ option = gt_option_new_uint("windowsize", "Size of window in which to search for hit pairs " "of kmers, has to be larger than kmersize" , &arguments->windowsize, GT_UNDEF_UINT); gt_option_parser_add_option(op, option); /* -initsize */ option = gt_option_new_uword("initsize", "length of inital unique database in bases, " "should be larger than -alignlength", &arguments->initsize, GT_UNDEF_UWORD); gt_option_parser_add_option(op, option); /* -alignlength */ option = gt_option_new_uword("alignlength", "required minimal length of an xdrop-alignment, " "should be larger than -windowsize", &arguments->minalignlength, GT_UNDEF_UWORD); gt_option_parser_add_option(op, option); /* -cutoff */ option = gt_option_new_uword("cutoff", "if a kmer is found more often than this value " "it will be ignored for alignment searches. " "Setting this to 0 will disable cutoffs, " "leaving it undefined will use a cutoff based " "on the mean number of occurences of a k-word.", &arguments->cutoff_value, GT_UNDEF_UWORD); gt_option_is_extended_option(option); gt_option_parser_add_option(op, option); /* -fraction */ option_fraction = gt_option_new_uword("fraction", "when cutoffs aren'd disabled and no specific " "value is set the mean number of occurrences " "of each kmer divided by -fraction will be used " "as cutoff", &arguments->fraction, (GtUword) 2); gt_option_is_extended_option(option_fraction); gt_option_exclude(option, option_fraction); gt_option_parser_add_option(op, option_fraction); /* -disable_prune */ option = gt_option_new_bool("disable_prune", "when cutoffs and this option are set, " "the database will still save every kmer, even " "though only cutoff many kmers will be used.", &arguments->prune, false); gt_option_is_extended_option(option); gt_option_parser_add_option(op, option); /* -mat */ option = gt_option_new_int("mat", "matchscore for extension-alignment, " "requirements: mat > mis, mat > 2ins, mat > 2del", &arguments->scores.mat, 2); gt_option_is_extended_option(option); gt_option_parser_add_option(op, option); /* -mis */ option = gt_option_new_int("mis", "mismatchscore for extension-alignment, ", &arguments->scores.mis, -1); gt_option_is_extended_option(option); gt_option_parser_add_option(op, option); /* -ins */ option = gt_option_new_int("ins", "insertionscore for extension-alignment", &arguments->scores.ins, -2); gt_option_is_extended_option(option); gt_option_parser_add_option(op, option); /* -del */ option = gt_option_new_int("del", "deletionscore for extension-alignment", &arguments->scores.del, -2); gt_option_is_extended_option(option); gt_option_parser_add_option(op, option); /* -xdrop */ option = gt_option_new_word("xdrop", "xdrop score for extension-alignment", &arguments->xdrop, (GtWord) 3); gt_option_is_extended_option(option); gt_option_parser_add_option(op, option); /* -brute_force */ option = gt_option_new_bool("brute_force", "disable filtering of seeds. " "Incompatible with -diagonals yes " "or -full_diags yes", &arguments->brute, false); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); /* -diagonals */ option = gt_option_new_bool("diagonals", "use sparse diagonals. " "Incompatible with -brute_force yes. " "Disabling both diagonals will result in simple " "filtering of seed positions.", &arguments->diags, false); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); /* -full_diags */ option = gt_option_new_bool("full_diags", "use full (time efficient " "space inefficient) diagonals. " "Incompatible with -brute_force yes. " "Disabling both diagonals will result in simple " "filtering of seed positions.", &arguments->full_diags, false); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); /* -clean_percent */ option = gt_option_new_uint("diags_clean", "Percentage of sparse diagonals that is allowed " "to be marked as deletable. Sensible default is " "set." , &arguments->clean_percent, GT_UNDEF_UINT); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); /* -verbose */ option = gt_option_new_bool("verbose", "enable verbose output", &arguments->verbose, false); gt_option_parser_add_option(op, option); /* -kdb*/ option = gt_option_new_bool("kdb", "prints out the kmer database (frequency " "of each kmer), if -verbose each startposition " "will be shown instead", &arguments->kdb, false); gt_option_parser_add_option(op, option); return op; }
static GtOptionParser* gt_sketch_page_option_parser_new(void *tool_arguments) { SketchPageArguments *arguments = tool_arguments; GtOptionParser *op; static const char *formats[] = { #ifdef CAIRO_HAS_PDF_SURFACE "pdf", #endif #ifdef CAIRO_HAS_PS_SURFACE "ps", #endif NULL }; GtOption *o; op = gt_option_parser_new("outfile annotationfile", "Draw a multi-page PDF/PS representation of " "an annotation file."); o = gt_option_new_string("seqid", "sequence region to draw\n" "default: first in file", arguments->seqid, NULL); gt_option_parser_add_option(op, o); gt_option_hide_default(o); o = gt_option_new_string("text", "text to show in header\n" "default: file name", arguments->text, NULL); gt_option_parser_add_option(op, o); gt_option_hide_default(o); o = gt_option_new_double("fontsize", "header and footer font size " "(in points)", &arguments->theight, 10.0); gt_option_parser_add_option(op, o); o = gt_option_new_range("range", "range to draw (e.g. 100 10000)\n" "default: full range", &arguments->range, NULL); gt_option_parser_add_option(op, o); gt_option_hide_default(o); o = gt_option_new_ulong_min("linewidth", "base width of a single " "repeated unit", &arguments->width, 2000, 1000); gt_option_is_mandatory(o); gt_option_parser_add_option(op, o); o = gt_option_new_double("width", "page width in millimeters " "(default: DIN A4)", &arguments->pwidth, 210.0); gt_option_parser_add_option(op, o); o = gt_option_new_double("height", "page height in millimeters " "(default: DIN A4)", &arguments->pheight, 297.0); gt_option_parser_add_option(op, o); o = gt_option_new_choice("format", "output format\n" "choose from: " #ifdef CAIRO_HAS_PDF_SURFACE "pdf" #ifdef CAIRO_HAS_PS_SURFACE "|" #endif #endif #ifdef CAIRO_HAS_PS_SURFACE "ps" #endif "", arguments->format, formats[0], formats ); gt_option_parser_add_option(op, o); o = gt_option_new_string("style", "style file to use\n" "default: gtdata/sketch/default.style", arguments->stylefile, gt_str_get(arguments->stylefile)); gt_option_parser_add_option(op, o); gt_option_hide_default(o); o = gt_option_new_filename("seqfile", "sequence file for GC content view", arguments->seqfile); gt_option_parser_add_option(op, o); gt_option_is_extended_option(o); gt_option_parser_set_min_max_args(op, 2, 2); 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_ltrdigest_option_parser_new(void *tool_arguments) { GtLTRdigestOptions *arguments = tool_arguments; GtOptionParser *op; GtOption *o, *ot, *oto; GtOption *oh, *oc, *oeval; static const char *cutoffs[] = {"NONE", "GA", "TC", NULL}; static GtRange pptlen_defaults = { 8UL, 30UL}, uboxlen_defaults = { 3UL, 30UL}, pbsalilen_defaults = {11UL, 30UL}, pbsoffsetlen_defaults = { 0UL, 5UL}, pbstrnaoffsetlen_defaults = { 0UL, 5UL}; gt_assert(arguments); /* init */ op = gt_option_parser_new("[option ...] gff3_file", "Identifies and annotates sequence features in LTR " "retrotransposon candidates."); /* Output files */ oto = gt_option_new_string("outfileprefix", "prefix for output files (e.g. 'foo' will create " "files called 'foo_*.csv' and 'foo_*.fas')\n" "Omit this option for GFF3 output only.", arguments->prefix, NULL); gt_option_parser_add_option(op, oto); gt_option_hide_default(oto); o = gt_option_new_bool("metadata", "output metadata (run conditions) to separate file", &arguments->print_metadata, true); gt_option_parser_add_option(op, o); gt_option_imply(o, oto); o = gt_option_new_uint("seqnamelen", "set maximal length of sequence names in FASTA headers" " (e.g. for clustalw or similar tools)", &arguments->seqnamelen, 20U); gt_option_parser_add_option(op, o); /* PPT search options */ o = gt_option_new_range("pptlen", "required PPT length range", &arguments->ppt_len, &pptlen_defaults); gt_option_parser_add_option(op, o); o = gt_option_new_range("uboxlen", "required U-box length range", &arguments->ubox_len, &uboxlen_defaults); gt_option_parser_add_option(op, o); o = gt_option_new_uint("uboxdist", "allowed U-box distance range from PPT", &arguments->max_ubox_dist, 0); gt_option_parser_add_option(op, o); o = gt_option_new_uint("pptradius", "radius around beginning of 3' LTR " "to search for PPT", &arguments->ppt_radius, 30U); gt_option_parser_add_option(op, o); o = gt_option_new_probability("pptrprob", "purine emission probability inside PPT", &arguments->ppt_purine_prob, PPT_PURINE_PROB); gt_option_parser_add_option(op, o); gt_option_is_extended_option(o); o = gt_option_new_probability("pptyprob", "pyrimidine emission probability inside PPT", &arguments->ppt_pyrimidine_prob, PPT_PYRIMIDINE_PROB); gt_option_parser_add_option(op, o); gt_option_is_extended_option(o); o = gt_option_new_probability("pptgprob", "background G emission probability outside PPT", &arguments->bkg_g_prob, BKG_G_PROB); gt_option_parser_add_option(op, o); gt_option_is_extended_option(o); o = gt_option_new_probability("pptcprob", "background C emission probability outside PPT", &arguments->bkg_c_prob, BKG_C_PROB); gt_option_parser_add_option(op, o); gt_option_is_extended_option(o); o = gt_option_new_probability("pptaprob", "background A emission probability outside PPT", &arguments->bkg_a_prob, BKG_A_PROB); gt_option_parser_add_option(op, o); gt_option_is_extended_option(o); o = gt_option_new_probability("ppttprob", "background T emission probability outside PPT", &arguments->bkg_t_prob, BKG_T_PROB); gt_option_parser_add_option(op, o); gt_option_is_extended_option(o); o = gt_option_new_probability("pptuprob", "U/T emission probability inside U-box", &arguments->ubox_u_prob, UBOX_U_PROB); gt_option_parser_add_option(op, o); gt_option_is_extended_option(o); /* PBS search options */ ot = gt_option_new_filename("trnas", "tRNA library in multiple FASTA format for PBS " "detection\n" "Omit this option to disable PBS search.", arguments->trna_lib); gt_option_parser_add_option(op, ot); gt_option_hide_default(ot); o = gt_option_new_range("pbsalilen", "required PBS/tRNA alignment length range", &arguments->alilen, &pbsalilen_defaults); gt_option_parser_add_option(op, o); gt_option_imply(o, ot); o = gt_option_new_range("pbsoffset", "allowed PBS offset from LTR boundary range", &arguments->offsetlen, &pbsoffsetlen_defaults); gt_option_parser_add_option(op, o); gt_option_imply(o, ot); o = gt_option_new_range("pbstrnaoffset", "allowed PBS/tRNA 3' end alignment offset range", &arguments->trnaoffsetlen, &pbstrnaoffsetlen_defaults); gt_option_parser_add_option(op, o); gt_option_imply(o, ot); o = gt_option_new_uint("pbsmaxedist", "maximal allowed PBS/tRNA alignment unit " "edit distance", &arguments->max_edist, 1U); gt_option_parser_add_option(op, o); gt_option_imply(o, ot); o = gt_option_new_uint("pbsradius", "radius around end of 5' LTR " "to search for PBS", &arguments->pbs_radius, 30U); gt_option_parser_add_option(op, o); gt_option_imply(o, ot); /* Protein domain search options */ oh = 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, oh); oeval = 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, oeval); gt_option_is_extended_option(oeval); gt_option_hide_default(oeval); gt_option_imply(oeval, oh); oc = gt_option_new_choice("pdomcutoff", "model-specific score cutoff\n" "choose from TC (trusted cutoff) | " "GA (gathering cutoff) | " "NONE (no cutoffs)", arguments->cutoffs, cutoffs[0], cutoffs); gt_option_parser_add_option(op, oc); gt_option_is_extended_option(oeval); gt_option_imply(oeval, oh); o = gt_option_new_bool("aliout", "output pHMM to amino acid sequence alignments", &arguments->write_alignments, false); gt_option_parser_add_option(op, o); gt_option_imply(o, oh); gt_option_imply(o, oto); o = gt_option_new_bool("aaout", "output amino acid sequences for protein domain " "hits", &arguments->write_aaseqs, false); gt_option_parser_add_option(op, o); gt_option_imply(o, oh); gt_option_imply(o, oto); o = gt_option_new_bool("allchains", "output features from all chains and unchained " "features, labeled with chain numbers", &arguments->output_all_chains, false); gt_option_parser_add_option(op, o); gt_option_imply(o, oh); o = 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, o); gt_option_is_extended_option(o); gt_option_imply(o, oh); o = gt_option_new_uword("threads", "DEPRECATED, only included for compatibility reasons!" " Use the -j parameter of the 'gt' call instead.", &arguments->nthreads, 0); gt_option_parser_add_option(op, o); gt_option_is_extended_option(o); /* Extended PBS options */ o = gt_option_new_int("pbsmatchscore", "match score for PBS/tRNA alignments", &arguments->ali_score_match, 5); gt_option_parser_add_option(op, o); gt_option_is_extended_option(o); gt_option_imply(o, ot); o = gt_option_new_int("pbsmismatchscore", "mismatch score for PBS/tRNA alignments", &arguments->ali_score_mismatch, -10); gt_option_parser_add_option(op, o); gt_option_is_extended_option(o); gt_option_imply(o, ot); o = gt_option_new_int("pbsinsertionscore", "insertion score for PBS/tRNA alignments", &arguments->ali_score_insertion, -20); gt_option_parser_add_option(op, o); gt_option_is_extended_option(o); gt_option_imply(o, ot); o = gt_option_new_int("pbsdeletionscore", "deletion score for PBS/tRNA alignments", &arguments->ali_score_deletion, -20); gt_option_parser_add_option(op, o); gt_option_is_extended_option(o); gt_option_imply(o, ot); /* verbosity */ o = gt_option_new_verbose(&arguments->verbose); gt_option_parser_add_option(op, o); /* output file options */ gt_output_file_info_register_options(arguments->ofi, op, &arguments->outfp); /* region mapping and sequence source options */ gt_seqid2file_register_options_ext(op, arguments->s2fi, false, false); return op; }
static OPrval parse_options(int *parsed_args, LTRharvestoptions *lo, int argc, const char **argv, GtError *err) { GtOptionParser *op; GtOption *optionindex, *optionltrsearchseqrange, *optionseed, *optionminlenltr, *optionmaxlenltr, *optionmindistltr, *optionmaxdistltr, *optionmintsd, *optionmaxtsd, *optionsimilar, *optionmotif, *optionmotifmis, *optionvic, *optionoverlaps, *optionxdrop, *optionmat, *optionmis, *optionins, *optiondel, *optionv, *optionoffset, *optionlongoutput, *optionout, *optionoutinner, *optiongff3; OPrval oprval; GtRange default_ltrsearchseqrange = {0,0}; unsigned int vicinityforcorrectboundaries; static const char *overlaps[] = { "best", /* the default */ "no", "all", NULL }; gt_error_check(err); op = gt_option_parser_new("[option ...] -index filenameindex", "Predict LTR retrotransposons."); /* -index */ lo->str_indexname = gt_str_new(); optionindex = gt_option_new_string("index", "specify the name of the enhanced suffix " "array index (mandatory)", lo->str_indexname, NULL); gt_option_is_mandatory(optionindex); gt_option_parser_add_option(op, optionindex); /* -range */ optionltrsearchseqrange = gt_option_new_range("range", "specify sequence range in which LTRs are searched", &lo->repeatinfo.ltrsearchseqrange, &default_ltrsearchseqrange); gt_option_parser_add_option(op, optionltrsearchseqrange); /* -seed */ optionseed = gt_option_new_ulong_min("seed", "specify minimum seed length for" " exact repeats", &lo->minseedlength, 30UL, 1UL); gt_option_parser_add_option(op, optionseed); /* -minlenltr */ optionminlenltr = gt_option_new_ulong_min_max("minlenltr", "specify minimum length for each LTR", &lo->repeatinfo.lmin, 100UL, 1UL, GT_UNDEF_ULONG); gt_option_parser_add_option(op, optionminlenltr); /* -maxlenltr */ optionmaxlenltr = gt_option_new_ulong_min_max("maxlenltr", "specify maximum length for each LTR", &lo->repeatinfo.lmax, 1000UL, 1UL, GT_UNDEF_ULONG); gt_option_parser_add_option(op, optionmaxlenltr); /* -mindistltr */ optionmindistltr = gt_option_new_ulong_min_max("mindistltr", "specify minimum distance of " "LTR startpositions", &lo->repeatinfo.dmin, 1000UL, 1UL, GT_UNDEF_ULONG); gt_option_parser_add_option(op, optionmindistltr); /* -maxdistltr */ optionmaxdistltr = gt_option_new_ulong_min_max("maxdistltr", "specify maximum distance of " "LTR startpositions", &lo->repeatinfo.dmax, 15000UL, 1UL, GT_UNDEF_ULONG); gt_option_parser_add_option(op, optionmaxdistltr); /* -similar */ optionsimilar = gt_option_new_double_min_max("similar", "specify similaritythreshold in " "range [1..100%]", &lo->similaritythreshold, (double) 85.0, (double) 0.0, 100.0); gt_option_parser_add_option(op, optionsimilar); /* -mintsd */ optionmintsd = gt_option_new_uint_min_max("mintsd", "specify minimum length for each TSD", &lo->minlengthTSD, 4U, 0, GT_UNDEF_UINT); gt_option_parser_add_option(op, optionmintsd); /* -maxtsd */ optionmaxtsd = gt_option_new_uint_min_max("maxtsd", "specify maximum length for each TSD", &lo->maxlengthTSD, 20U, 0, GT_UNDEF_UINT); gt_option_parser_add_option(op, optionmaxtsd); /* -motif */ /* characters will be tranformed later into characters from virtualtree alphabet */ lo->motif.firstleft = (GtUchar) 't'; lo->motif.secondleft = (GtUchar) 'g'; lo->motif.firstright = (GtUchar) 'c'; lo->motif.secondright = (GtUchar) 'a'; lo->motif.str_motif = gt_str_new(); optionmotif = gt_option_new_string("motif", "specify 2 nucleotides startmotif + " "2 nucleotides endmotif: ****", lo->motif.str_motif, NULL); gt_option_parser_add_option(op, optionmotif); /* -motifmis */ optionmotifmis = gt_option_new_uint_min_max("motifmis", "specify maximum number of " "mismatches in motif [0,3]", &lo->motif.allowedmismatches, 4U, 0, 3U); gt_option_parser_add_option(op, optionmotifmis); /* -vic */ optionvic = gt_option_new_uint_min_max("vic", "specify the number of nucleotides (to the left and " "to the right) that will be searched " "for TSDs and/or motifs around 5' and 3' boundary " "of predicted LTR retrotransposons", &vicinityforcorrectboundaries, 60U, 1U, 500U); gt_option_parser_add_option(op, optionvic); /* -overlaps */ lo->str_overlaps = gt_str_new(); optionoverlaps = gt_option_new_choice("overlaps", "specify no|best|all", lo->str_overlaps, overlaps[0], overlaps); gt_option_parser_add_option(op, optionoverlaps); /* -xdrop */ optionxdrop = gt_option_new_int_min("xdrop", "specify xdropbelowscore for extension-alignment", &lo->xdropbelowscore, (int)5, (int)0); gt_option_parser_add_option(op, optionxdrop); /* -mat */ lo->arbitscores.gcd = 1; /* set only for initialization, do not change! */ optionmat = gt_option_new_int_min("mat", "specify matchscore for extension-alignment", &lo->arbitscores.mat, 2, 1); gt_option_parser_add_option(op, optionmat); /* -mis */ optionmis = gt_option_new_int_max("mis", "specify mismatchscore for extension-alignment", &lo->arbitscores.mis, -2, -1); gt_option_parser_add_option(op, optionmis); /* -ins */ optionins = gt_option_new_int_max("ins", "specify insertionscore for extension-alignment", &lo->arbitscores.ins, -3, -1); gt_option_parser_add_option(op, optionins); /* -del */ optiondel = gt_option_new_int_max("del", "specify deletionscore for extension-alignment", &lo->arbitscores.del, -3, -1); gt_option_parser_add_option(op, optiondel); /* -v */ optionv = gt_option_new_bool("v", "verbose mode", &lo->verbosemode, false); gt_option_parser_add_option(op, optionv); /* -longoutput */ optionlongoutput = gt_option_new_bool("longoutput", "additional motif/TSD output", &lo->longoutput, false); gt_option_parser_add_option(op, optionlongoutput); /* -out */ lo->fastaoutput = false; /* by default no FASTA output */ lo->str_fastaoutputfilename = gt_str_new(); optionout = gt_option_new_string("out", "specify FASTA outputfilename", lo->str_fastaoutputfilename, NULL); gt_option_parser_add_option(op, optionout); /* -outinner */ lo->fastaoutputinnerregion = false; lo->str_fastaoutputfilenameinnerregion = gt_str_new(); optionoutinner = gt_option_new_string("outinner", "specify FASTA outputfilename for inner regions", lo->str_fastaoutputfilenameinnerregion, NULL); gt_option_parser_add_option(op, optionoutinner); /* -gff3 */ lo->gff3output = false; /* by default no gff3 output */ lo->str_gff3filename = gt_str_new(); optiongff3 = gt_option_new_string("gff3", "specify GFF3 outputfilename", lo->str_gff3filename, NULL); gt_option_parser_add_option(op, optiongff3); /* -offset */ optionoffset = gt_option_new_ulong("offset", "offset added to GFF3 coordinates", &lo->offset, 0UL); gt_option_parser_add_option(op, optionoffset); gt_option_is_extended_option(optionoffset); /* implications */ gt_option_imply(optionmaxtsd, optionmintsd); gt_option_imply(optionmotifmis, optionmotif); gt_option_imply_either_2(optionlongoutput, optionmintsd, optionmotif); gt_option_parser_refer_to_manual(op); oprval = gt_option_parser_parse(op, parsed_args, argc, argv, gt_versionfunc, err); lo->vicinityforcorrectboundaries = (Seqpos) vicinityforcorrectboundaries; if (oprval == OPTIONPARSER_OK) { if (lo->repeatinfo.lmin > lo->repeatinfo.lmax) { gt_error_set(err,"argument of -minlenltr is greater than argument of" " -maxlenltr"); oprval = OPTIONPARSER_ERROR; } if (lo->repeatinfo.dmin > lo->repeatinfo.dmax) { gt_error_set(err, "argument of -mindistltr is greater than argument of -maxdistltr"); oprval = OPTIONPARSER_ERROR; } if (lo->repeatinfo.lmax > lo->repeatinfo.dmin) { gt_error_set(err,"argument of -maxlenltr is greater than argument of" " -mindistltr"); oprval = OPTIONPARSER_ERROR; } if (lo->minlengthTSD > lo->maxlengthTSD) { gt_error_set(err, "argument of -mintsd is greater than argument of -maxtsd"); oprval = OPTIONPARSER_ERROR; } /* If option motif is set, store characters, transform them later */ if (gt_option_is_set(optionmotif)) { if (gt_str_length(lo->motif.str_motif) != 4UL) { gt_error_set(err, "argument of -motif has not exactly 4 characters"); oprval = OPTIONPARSER_ERROR; } lo->motif.firstleft = (GtUchar) gt_str_get(lo->motif.str_motif)[0]; lo->motif.secondleft = (GtUchar) gt_str_get(lo->motif.str_motif)[1]; lo->motif.firstright = (GtUchar) gt_str_get(lo->motif.str_motif)[2]; lo->motif.secondright = (GtUchar) gt_str_get(lo->motif.str_motif)[3]; /* default if motif specified */ if (!gt_option_is_set(optionmotifmis)) { lo->motif.allowedmismatches = 0; } } /* If option overlaps is set */ if (gt_option_is_set(optionoverlaps)) { if (strcmp(gt_str_get(lo->str_overlaps), "no") == 0) { lo->bestofoverlap = false; lo->nooverlapallowed = true; } else if (strcmp(gt_str_get(lo->str_overlaps), "best") == 0 ) { lo->bestofoverlap = true; lo->nooverlapallowed = false; } else if (strcmp(gt_str_get(lo->str_overlaps), "all") == 0 ) { lo->bestofoverlap = false; lo->nooverlapallowed = false; } else { gt_assert(0); /* cannot happen */ } } else { /* default is "best" */ lo->bestofoverlap = true; /* take best prediction if overlap occurs, default */ lo->nooverlapallowed = false; /* overlapping predictions (not)allowed*/ } /* if FASTA output is set */ if (gt_option_is_set(optionout)) { lo->fastaoutput = true; } /* if FASTA output inner region is set */ if (gt_option_is_set(optionoutinner)) { lo->fastaoutputinnerregion = true; } /* if GFF3 output is set */ if (gt_option_is_set(optiongff3)) { lo->gff3output = true; } if (gt_option_is_set(optionltrsearchseqrange)) { if (lo->repeatinfo.ltrsearchseqrange.start > lo->repeatinfo.ltrsearchseqrange.end) { gt_error_set(err, "arguments of -range: first arg must be <= than second arg"); oprval = OPTIONPARSER_ERROR; } } } gt_option_parser_delete(op); return oprval; }
static GtOPrval parse_options(int *parsed_args, bool doesa, Suffixeratoroptions *so, int argc, const char **argv, GtError *err) { GtOptionParser *op; GtOption *option, *optionshowprogress, *optiongenomediff, *optionii; GtOPrval oprval; gt_error_check(err); op = gt_option_parser_new("[option ...] (-db file [...] | -ii index)", doesa ? "Compute enhanced suffix array." : "Compute packed index."); gt_option_parser_set_mail_address(op, "<*****@*****.**>"); /* input info */ so->indexname = gt_str_new(); so->inputindex = gt_str_new(); so->db = gt_str_array_new(); /* register options for encoded sequence handling */ so->encopts = gt_encseq_options_register_encoding(op, so->indexname, so->db); so->loadopts = gt_encseq_options_register_loading(op, so->indexname); /* register options for index handling */ if (doesa) so->idxopts = gt_index_options_register_esa(op, so->encopts); else so->idxopts = gt_index_options_register_packedidx(op, so->indexname, so->encopts); /* verbosity */ option = gt_option_new_verbose(&so->beverbose); gt_option_parser_add_option(op, option); optionshowprogress = gt_option_new_bool("showprogress", "show a progress bar", &so->showprogress, false); gt_option_parser_add_option(op, optionshowprogress); optionii = gt_option_new_filename("ii", "specify existing encoded sequence", so->inputindex); gt_option_parser_add_option(op, optionii); gt_option_is_mandatory_either(gt_encseq_options_db_option(so->encopts), optionii); gt_option_exclude(gt_encseq_options_db_option(so->encopts), optionii); gt_option_exclude(optionii, gt_encseq_options_smap_option(so->encopts)); gt_option_exclude(optionii, gt_encseq_options_dna_option(so->encopts)); gt_option_exclude(optionii, gt_encseq_options_protein_option(so->encopts)); gt_option_exclude(optionii, gt_encseq_options_plain_option(so->encopts)); gt_option_exclude(optionii, gt_encseq_options_sat_option(so->encopts)); optiongenomediff = gt_option_new_bool("genomediff", "directly process the lcp intervals using " "the genomediff algorithm (suffix array and " "lcp-tables are not output)", &so->genomediff, false); gt_option_is_extended_option(optiongenomediff); if (gt_index_options_outsuftab_option(so->idxopts) != NULL) { gt_option_exclude(optiongenomediff, gt_index_options_outsuftab_option(so->idxopts)); } gt_option_parser_add_option(op, optiongenomediff); /* suffixerator and friends do not take arguments */ gt_option_parser_set_min_max_args(op, 0U, 0U); oprval = gt_option_parser_parse(op, parsed_args, argc, argv, gt_versionfunc, err); if (gt_str_length(so->indexname) == 0UL) { /* we do not have an indexname yet, so there was none given in the -indexname option and it could not be derived from the input filenames. So it must be in the -ii parameter. */ char *basenameptr; basenameptr = gt_basename(gt_str_get(so->inputindex)); gt_str_set(so->indexname, basenameptr); gt_free(basenameptr); } gt_option_parser_delete(op); return oprval; }
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; }