static GtOPrval parse_options(GtStr *indexname,GtStrArray *indexnametab, int *parsed_args, int argc, const char **argv, GtError *err) { GtOptionParser *op; GtOPrval oprval; GtOption *option; gt_error_check(err); op = gt_option_parser_new("storeindex <mkvindex1> <mkvindex2> ...", "Merge indexes into one index."); gt_option_parser_set_mail_address(op,"<*****@*****.**>"); option = gt_option_new_filename_array("ii", "specify input index files (mandatory)", indexnametab); gt_option_is_mandatory(option); gt_option_parser_add_option(op, option); option = gt_option_new_string("indexname", "specify index to be created", indexname, NULL); gt_option_is_mandatory(option); gt_option_parser_add_option(op, option); oprval = gt_option_parser_parse(op, parsed_args, argc, argv, gt_versionfunc, err); gt_option_parser_delete(op); return oprval; }
static GtOptionParser* gt_compreads_compress_option_parser_new(void *tool_arguments) { GtCsrHcrEncodeArguments *arguments = tool_arguments; GtOptionParser *op; GtOption *option; static const char *methods[] = { "page", "regular", "none" }; gt_assert(arguments); /* init */ op = gt_option_parser_new("[option ...] (-files file [...])", "Generates compact encoding for fastq data."); option = gt_option_new_bool("descs","encode descriptions", &arguments->descs, false); gt_option_parser_add_option(op, option); option = gt_option_new_filename_array("files", "File(s) containing reads.", arguments->files); gt_option_parser_add_option(op, option); option = gt_option_new_string("name", "specify base name for HCR to be" " generated. Only mandatory, if more than one" " file was given.", arguments->name, NULL); gt_option_parser_add_option(op, option); option = gt_option_new_string("smap", "file containing alphabet description." " If \"-smap\" is not set, dna alphabet is" " used.", arguments->smap, NULL); gt_option_parser_add_option(op, option); option = gt_option_new_range("qrange", "specify range of quality values." " All values smaller or equal to the lower bound" " will be converted to the lower bound. All" " values equal or larger than the upper bound" " will be converted to the upper bound.", &arguments->arg_range, NULL); gt_option_parser_add_option(op, option); option = gt_option_new_uword("srate", "sampling rate, set to sensible default" " depending on sampling method", &arguments->srate, GT_UNDEF_UWORD); gt_option_parser_add_option(op, option); option = gt_option_new_choice("stype", "type of sampling\n" "one of regular - page - none", arguments->method, "page", methods); gt_option_parser_add_option(op, option); gt_option_parser_set_min_max_args(op, 0U, 0U); return op; }
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_mail_address(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_filename_array("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; }
static GtOPrval parse_options(int *parsed_args, Cmppairwiseopt *pw, int argc, const char **argv, GtError *err) { GtOptionParser *op; GtOption *optionstrings, *optionfiles, *optioncharlistlen, *optiontext, *optionshowedist; GtStrArray *charlistlen; GtOPrval oprval; gt_error_check(err); charlistlen = gt_str_array_new(); pw->strings = gt_str_array_new(); pw->files = gt_str_array_new(); pw->text = gt_str_new(); pw->charlistlen = NULL; pw->showedist = false; op = gt_option_parser_new("options", "Apply function to pairs of strings."); gt_option_parser_set_mail_address(op, "<*****@*****.**>"); optionstrings = gt_option_new_string_array("ss", "use two strings", pw->strings); gt_option_parser_add_option(op, optionstrings); optionfiles = gt_option_new_filename_array("ff", "use two files", pw->files); gt_option_parser_add_option(op, optionfiles); optioncharlistlen = gt_option_new_string_array("a", "use character list and length", charlistlen); gt_option_parser_add_option(op, optioncharlistlen); optiontext = gt_option_new_string("t", "use text", pw->text, NULL); gt_option_parser_add_option(op, optiontext); optionshowedist = gt_option_new_bool("e", "output unit edit distance", &pw->showedist, false); gt_option_parser_add_option(op, optionshowedist); gt_option_exclude(optionstrings, optionfiles); gt_option_exclude(optionstrings, optioncharlistlen); gt_option_exclude(optionstrings, optiontext); gt_option_exclude(optionfiles, optioncharlistlen); gt_option_exclude(optionfiles, optiontext); gt_option_exclude(optioncharlistlen, optiontext); gt_option_imply(optionshowedist, optionstrings); oprval = gt_option_parser_parse(op, parsed_args, argc, argv, gt_versionfunc, err); if (oprval == GT_OPTION_PARSER_OK) { if (gt_option_is_set(optionstrings)) { if (gt_str_array_size(pw->strings) != 2UL) { gt_error_set(err, "option -ss requires two string arguments"); oprval = GT_OPTION_PARSER_ERROR; } } else { if (gt_option_is_set(optionfiles)) { if (gt_str_array_size(pw->files) != 2UL) { gt_error_set(err, "option -ff requires two filename arguments"); oprval = GT_OPTION_PARSER_ERROR; } } else { if (gt_option_is_set(optioncharlistlen)) { GtWord readint; if (gt_str_array_size(charlistlen) != 2UL) { gt_error_set(err, "option -a requires charlist and length argument"); oprval = GT_OPTION_PARSER_ERROR; } pw->charlistlen = gt_malloc(sizeof *pw->charlistlen); pw->charlistlen->charlist = gt_str_ref(gt_str_array_get_str(charlistlen, 0)); if (sscanf(gt_str_array_get(charlistlen,1UL), GT_WD, &readint) != 1 || readint < 1L) { gt_error_set(err, "option -a requires charlist and length argument"); oprval = GT_OPTION_PARSER_ERROR; } pw->charlistlen->len = (GtUword) readint; } else { if (!gt_option_is_set(optiontext)) { gt_error_set(err, "use exactly one of the options -ss, -ff, -a, -t"); oprval = GT_OPTION_PARSER_ERROR; } } } } } gt_option_parser_delete(op); if (oprval == GT_OPTION_PARSER_OK && *parsed_args != argc) { gt_error_set(err, "superfluous program parameters"); oprval = GT_OPTION_PARSER_ERROR; } gt_str_array_delete(charlistlen); return oprval; }
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_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_matstat_option_parser_new(void *tool_arguments) { Gfmsubcallinfo *arguments = tool_arguments; GtOptionParser *op; gt_assert(arguments); op = gt_option_parser_new("[options ...] -query queryfile [...]", arguments->doms ? "Compute matching statistics." : "Compute length of minimum unique prefixes."); gt_option_parser_set_mail_address(op,"<*****@*****.**>"); arguments->optionfmindex = gt_option_new_string("fmi", "specify fmindex", arguments->indexname,NULL); gt_option_parser_add_option(op, arguments->optionfmindex); arguments->optionesaindex = gt_option_new_string("esa", "specify suffix array", arguments->indexname,NULL); gt_option_parser_add_option(op, arguments->optionesaindex); arguments->optionpckindex = gt_option_new_string("pck", "specify packed index", arguments->indexname,NULL); gt_option_parser_add_option(op, arguments->optionpckindex); gt_option_exclude(arguments->optionfmindex,arguments->optionesaindex); gt_option_exclude(arguments->optionpckindex,arguments->optionesaindex); gt_option_exclude(arguments->optionpckindex,arguments->optionfmindex); arguments->optionquery = gt_option_new_filename_array("query", "specify queryfiles", arguments->queryfilenames); gt_option_is_mandatory(arguments->optionquery); gt_option_parser_add_option(op, arguments->optionquery); arguments->optionmin = gt_option_new_uword_min("min", "only output length " "if >= given minimum length", &arguments->minlength. valueunsignedlong, 0,(GtUword) 1); gt_option_parser_add_option(op, arguments->optionmin); arguments->optionmax = gt_option_new_uword_min("max", "only output length " "if <= given maximum length", &arguments->maxlength. valueunsignedlong, 0,(GtUword) 1); gt_option_parser_add_option(op, arguments->optionmax); arguments->optionoutput = gt_option_new_string_array("output", arguments->doms ? "set output flags (sequence, querypos, subjectpos)" : "set output flags (sequence, querypos)", arguments->flagsoutputoption); gt_option_parser_add_option(op, arguments->optionoutput); if (arguments->doms) { arguments->optionverify = gt_option_new_bool("verify", "verify witness positions", &arguments->verifywitnesspos, false); gt_option_is_development_option(arguments->optionverify); gt_option_parser_add_option(op, arguments->optionverify); } else { arguments->verifywitnesspos = false; } gt_option_parser_refer_to_manual(op); 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 GtOPrval parsemkfmindex(Mkfmcallinfo *mkfmcallinfo, int argc, const char **argv, GtError *err) { GtOptionParser *op; GtOption *option, *optionfmout; GtOPrval oprval; int parsed_args; gt_error_check(err); mkfmcallinfo->indexnametab = gt_str_array_new(); mkfmcallinfo->outfmindex = gt_str_new(); mkfmcallinfo->leveldesc = gt_str_new(); op = gt_option_parser_new("[option ...] -ii indexfile [...]", "Compute FM-index."); gt_option_parser_set_mail_address(op, "<*****@*****.**>"); optionfmout = gt_option_new_string("fmout", "specify name of FM-index to be generated\n" "(mandatory if more than one input index " "is specified)", mkfmcallinfo->outfmindex, NULL); gt_option_parser_add_option(op, optionfmout); option = gt_option_new_filename_array("ii", "specify indices to be used", mkfmcallinfo->indexnametab); gt_option_is_mandatory(option); gt_option_parser_add_option(op, option); option = gt_option_new_string("size", "specify size (tiny, small, medium, big)", mkfmcallinfo->leveldesc, "medium"); gt_option_parser_add_option(op, option); option = gt_option_new_bool("noindexpos", "store no index positions (hence the positions of\n" "matches in the index cannot be retrieved)", &mkfmcallinfo->noindexpos,false); gt_option_parser_add_option(op, option); oprval = gt_option_parser_parse(op, &parsed_args, argc, argv, gt_versionfunc, err); if (oprval == GT_OPTION_PARSER_OK) { if (!gt_option_is_set(optionfmout)) { if (gt_str_array_size(mkfmcallinfo->indexnametab) > 1UL) { gt_error_set(err,"if more than one index is given, then " "option -fmout is mandatory"); oprval = GT_OPTION_PARSER_ERROR; } else { char *basenameptr; basenameptr = gt_basename(gt_str_array_get(mkfmcallinfo->indexnametab, 0)); gt_str_set(mkfmcallinfo->outfmindex,basenameptr); gt_free(basenameptr); } } } gt_option_parser_delete(op); if (oprval == GT_OPTION_PARSER_OK && parsed_args != argc) { gt_error_set(err,"superfluous program parameters"); oprval = GT_OPTION_PARSER_ERROR; } return oprval; }
static GtOptionParser* gt_select_option_parser_new(void *tool_arguments) { SelectArguments *arguments = tool_arguments; GtOptionParser *op; GtOption *option, *contain_option, *overlap_option, *minaveragessp_option, *singleintron_option, *optiondroppedfile; gt_assert(arguments); static const char *filter_logic[] = { "AND", "OR", NULL }; /* init */ op = gt_option_parser_new("[option ...] [GFF3_file ...]", "Select certain features (specified by the used " "options) from given GFF3 file(s)."); /* -seqid */ option = gt_option_new_string("seqid", "select feature with the given " "sequence ID (all comments are selected). ", arguments->seqid, NULL); gt_option_parser_add_option(op, option); /* -source */ option = gt_option_new_string("source", "select feature with the given " "source (the source is column 2 in regular " "GFF3 lines)" , arguments->source, NULL); gt_option_parser_add_option(op, option); /* -contain */ contain_option = gt_option_new_range("contain", "select all features which " "are contained in the given range", &arguments->contain_range, NULL); gt_option_parser_add_option(op, contain_option); /* -overlap */ overlap_option = gt_option_new_range("overlap", "select all features which " "do overlap with the given range", &arguments->overlap_range, NULL); gt_option_parser_add_option(op, overlap_option); /* -strand */ option = gt_option_new_string(GT_STRAND_OPT, "select all top-level features" "(i.e., features without parents) whose strand " "equals the given one (must be one of '" GT_STRAND_CHARS"')", arguments->gt_strand_char, NULL); gt_option_parser_add_option(op, option); /* -targetstrand */ option = gt_option_new_string(TARGETGT_STRAND_OPT, "select all top-level " "features (i.e., features without parents) " "which have exactly one target attribute whose " "strand equals the given one (must be one of '" GT_STRAND_CHARS"')", arguments->targetgt_strand_char, NULL); gt_option_parser_add_option(op, option); /* -targetbest */ option = gt_option_new_bool("targetbest", "if multiple top-level features " "(i.e., features without parents) with exactly " "one target attribute have the same target_id, " "keep only the feature with the best score. If " "-"TARGETGT_STRAND_OPT" is used at the same time, " "this option is applied after " "-"TARGETGT_STRAND_OPT".\n" "Memory consumption is proportional to the input " "file size(s).", &arguments->targetbest, false); gt_option_parser_add_option(op, option); /* -hascds */ option = gt_option_new_bool("hascds", "select all top-level features which " "do have a CDS child", &arguments->has_CDS, false); gt_option_parser_add_option(op, option); /* -maxgenelength */ option = gt_option_new_uword_min("maxgenelength", "select genes up to the " "given maximum length", &arguments->max_gene_length, GT_UNDEF_UWORD, 1); gt_option_parser_add_option(op, option); /* -maxgenenum */ option = gt_option_new_uword("maxgenenum", "select the first genes up to the " "given maximum number", &arguments->max_gene_num, GT_UNDEF_UWORD); gt_option_parser_add_option(op, option); /* -mingenescore */ option = gt_option_new_double("mingenescore", "select genes with the given " "minimum score", &arguments->min_gene_score, GT_UNDEF_DOUBLE); gt_option_parser_add_option(op, option); /* -maxgenescore */ option = gt_option_new_double("maxgenescore", "select genes with the given " "maximum score", &arguments->max_gene_score, GT_UNDEF_DOUBLE); gt_option_parser_add_option(op, option); /* -minaveragessp */ minaveragessp_option = gt_option_new_probability("minaveragessp", "set the minimum average splice site probability", &arguments->min_average_splice_site_prob, GT_UNDEF_DOUBLE); gt_option_parser_add_option(op, minaveragessp_option); /* -singleintronfactor */ singleintron_option = gt_option_new_double_min("singleintronfactor", "factor to multiplicate the average splice site " "probability with for single introns before " "comparing it to the minimum average splice site " "probability", &arguments->single_intron_factor, 1.0, 1.0); gt_option_is_development_option(singleintron_option); gt_option_parser_add_option(op, singleintron_option); /* -featurenum */ option = gt_option_new_uword_min("featurenum", "select feature tree occurring " "at given position in input", &arguments->feature_num, GT_UNDEF_UWORD, 1); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); /* -filter_files */ option = gt_option_new_filename_array("rule_files", "specify Lua files to be used " "for selection", arguments->filter_files); gt_option_parser_add_option(op, option); /* -filter_logic */ option = gt_option_new_choice("rule_logic", "select how multiple Lua " "files should be combined\nchoose from AND|OR", arguments->filter_logic, filter_logic[0], filter_logic); gt_option_parser_add_option(op, option); /* -nh_file */ optiondroppedfile = gt_option_new_filename("dropped_file", "save non-selected features to " "file", arguments->dropped_file); gt_option_parser_add_option(op, optiondroppedfile); /* -v */ option = gt_option_new_verbose(&arguments->verbose); gt_option_parser_add_option(op, option); /* option exclusions */ gt_option_exclude(contain_option, overlap_option); /* option implications */ gt_option_imply(singleintron_option, minaveragessp_option); /* output file options */ gt_output_file_info_register_options(arguments->ofi, op, &arguments->outfp); gt_option_parser_set_comment_func(op, gt_gtdata_show_help, NULL); 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_mail_address(op, "<*****@*****.**>"); option = gt_option_new_filename_array("q","Specify files containing the " "query sequences", arguments->queryfiles); gt_option_parser_add_option (op, option); option = gt_option_new_word("match", "Specify match score", &arguments->matchscore, 1L); gt_option_parser_add_option(op, option); option = gt_option_new_word("mismatch", "Specify mismatch score", &arguments->mismatchscore, -3L); gt_option_parser_add_option(op, option); option = gt_option_new_word("gapstart", "Specify gap start score", &arguments->gapstart, -5L); gt_option_parser_add_option(op, option); option = gt_option_new_word("gapextend", "Specify gap extension score", &arguments->gapextend, -2L); gt_option_parser_add_option(op, option); option = gt_option_new_uword_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; }