static GtOptionParser *gt_tyr_mkindex_option_parser_new(void *tool_arguments)
{
GtOptionParser *op;
GtOption *option,
*optionminocc,
*optionmaxocc,
*optionpl,
*optionstoreindex,
*optionstorecounts,
*optionscan,
*optionesa;
Tyr_mkindex_options *arguments = tool_arguments;
op = gt_option_parser_new("[options] -esa suffixerator-index [options]",
"Count and index k-mers in the given enhanced "
"suffix array for a fixed value of k.");
gt_option_parser_set_mailaddress(op,"<*****@*****.**>");
optionesa = gt_option_new_string("esa","specify suffixerator-index\n"
"(mandatory option)",
arguments->str_inputindex,
NULL);
gt_option_is_mandatory(optionesa);
gt_option_parser_add_option(op, optionesa);
option = gt_option_new_ulong("mersize",
"Specify the mer size.",
&arguments->mersize,
20UL);
gt_option_parser_add_option(op, option);
optionminocc
= gt_option_new_ulong("minocc",
"Specify the minimum occurrence number for "
"the mers to output/index",
&arguments->userdefinedminocc,
0);
gt_option_parser_add_option(op, optionminocc);
optionmaxocc
= gt_option_new_ulong("maxocc",
"Specify the maximum occurrence number for "
"the mers to output/index",
&arguments->userdefinedmaxocc,
0);
gt_option_parser_add_option(op, optionmaxocc);
optionpl = gt_option_new_uint_min("pl",
"specify prefix length for bucket boundary construction\n"
"recommendation: use without argument;\n"
"then a reasonable prefix length is automatically determined",
&arguments->userdefinedprefixlength,
0,
1U);
gt_option_argument_is_optional(optionpl);
gt_option_parser_add_option(op, optionpl);
arguments->refoptionpl = gt_option_ref(optionpl);
optionstoreindex = gt_option_new_string("indexname",
"store the mers specified by options "
"-maxocc and -minocc in an index",
arguments->str_storeindex, NULL);
gt_option_parser_add_option(op, optionstoreindex);
optionstorecounts = gt_option_new_bool("counts", "store counts of the mers",
&arguments->storecounts,false);
gt_option_parser_add_option(op, optionstorecounts);
option = gt_option_new_bool("test", "perform tests to verify program "
"correctness", &arguments->performtest,
false);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
optionscan = gt_option_new_bool("scan",
"read enhanced suffix array sequentially "
"instead of mapping it to memory",
&arguments->scanfile,
false);
gt_option_parser_add_option(op, optionscan);
option = gt_option_new_verbose(&arguments->verbose);
gt_option_parser_add_option(op, option);
gt_option_imply(optionpl, optionstoreindex);
gt_option_imply(optionstorecounts, optionstoreindex);
gt_option_imply_either_2(optionstoreindex,optionminocc,optionmaxocc);
return op;
}
static GtOptionParser* gt_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->scan, 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_tyr_occratio_option_parser_new(void *tool_arguments)
{
GtOptionParser *op;
GtOption *optionmersizes, *optionesa, *optionminmersize, *optionmaxmersize,
*optionstep, *optionoutput, *option;
Tyr_occratio_options *arguments = tool_arguments;
op = gt_option_parser_new("[options] -esa suffixerator-index [options]",
"Compute occurrence ratio for a set of sequences "
"represented by an enhanced suffix array.");
gt_option_parser_set_mailaddress(op,"<*****@*****.**>");
optionesa = gt_option_new_string("esa","specify suffixerator-index\n"
"(mandatory option)",
arguments->str_inputindex,
NULL);
gt_option_is_mandatory(optionesa);
gt_option_parser_add_option(op, optionesa);
optionminmersize
= gt_option_new_ulong_min("minmersize",
"specify minimum mer size for which "
"to compute the occurrence distribution",
&arguments->minmersize,0,1UL);
gt_option_parser_add_option(op, optionminmersize);
optionmaxmersize
= gt_option_new_ulong_min("maxmersize",
"specify maximum mer size for which "
"to compute the occurrence distribution",
&arguments->maxmersize,0,1UL);
gt_option_parser_add_option(op, optionmaxmersize);
optionstep
= gt_option_new_ulong_min("step",
"specify step size when specifying mer sizes",
&arguments->stepmersize,1UL,1UL);
gt_option_parser_add_option(op, optionstep);
optionmersizes = gt_option_new_stringarray(
"mersizes",
"specify mer sizes as non-empty sequence of "
"non decreasing positive integers",
arguments->mersizesstrings);
arguments->refoptionmersizes = gt_option_ref(optionmersizes);
gt_option_parser_add_option(op, optionmersizes);
optionoutput = gt_option_new_stringarray(
"output",
"use combination of the following keywords: "
"unique nonunique nonuniquemulti relative total "
"to specify kind of output",
arguments->outputspec);
gt_option_parser_add_option(op, optionoutput);
option = gt_option_new_bool("scan",
"read suffixerator-index sequentially "
"instead of mapping it to memory",
&arguments->scanfile,
false);
gt_option_parser_add_option(op, option);
option = gt_option_new_verbose(&arguments->verbose);
gt_option_parser_add_option(op, option);
gt_option_exclude(optionmersizes,optionminmersize);
gt_option_exclude(optionmersizes,optionmaxmersize);
gt_option_exclude(optionmersizes,optionstep);
return op;
}
static GtOptionParser* gt_condenser_search_option_parser_new
(void *tool_arguments)
{
GtCondenserSearchArguments *arguments = tool_arguments;
GtOptionParser *op;
GtOption *option, *score_opt, *ceval_opt, *feval_opt, *blastp_opt,
*blastn_opt;
gt_assert(arguments);
/* init */
op = gt_option_parser_new("[option ...]",
"Perform a BLAST or "
"HMMSEARCH on the given compressed database.");
/* -blastn */
blastn_opt = gt_option_new_bool("blastn", "perform blastn search",
&arguments->blastn, false);
/* -blastp */
blastp_opt = gt_option_new_bool("blastp", "perform blastp search",
&arguments->blastp, false);
gt_option_exclude(blastn_opt, blastp_opt);
gt_option_parser_add_option(op, blastn_opt);
gt_option_parser_add_option(op, blastp_opt);
/* -score */
score_opt = gt_option_new_uword("score", "bitscore threshold for BLAST(p) "
"evalue calculation",
&arguments->bitscore, (GtUword) 30);
gt_option_parser_add_option(op, score_opt);
/* -ce */
ceval_opt = gt_option_new_double("ce",
"coarse e value for coarse blast search",
&arguments->ceval, 5.0);
gt_option_parser_add_option(op, ceval_opt);
/* -fe */
feval_opt = gt_option_new_double("fe", "fine e value for fine blast search, "
"defaults to calculated evalue from the "
"given score",
&arguments->feval, GT_UNDEF_DOUBLE);
gt_option_hide_default(feval_opt);
gt_option_parser_add_option(op, feval_opt);
gt_option_exclude(score_opt, ceval_opt);
gt_option_exclude(score_opt, feval_opt);
/* -db */
option = gt_option_new_filename("db", "path of (compressed) fasta database",
arguments->dbpath);
gt_option_is_mandatory(option);
gt_option_parser_add_option(op, option);
/* -query */
option = gt_option_new_filename("query", "path of fasta query file",
arguments->querypath);
gt_option_is_mandatory(option);
gt_option_parser_add_option(op, option);
/* -verbose */
option = gt_option_new_bool("verbose", "verbose output", &arguments->verbose,
false);
gt_option_parser_add_option(op, option);
/* -blastthreads */
option = gt_option_new_int_min("blastthreads", "how many threads for blast "
"to use", &arguments->blthreads, 8, 1);
gt_option_imply_either_2(option, blastn_opt, blastp_opt);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
gt_output_file_info_register_options(arguments->ofi, op, &arguments->outfp);
return op;
}
static GtOptionParser* gtr_option_parser_new(GtR *gtr)
{
GtOptionParser *op;
GtOption *o, *only_option, *debug_option, *debugfp_option;
gt_assert(gtr);
op = gt_option_parser_new("[option ...] [tool | script] [argument ...]",
"The GenomeTools genome analysis system.");
gt_option_parser_set_comment_func(op, show_gtr_help, gtr->tools);
o = gt_option_new_bool("i",
"enter interactive mode after executing 'tool' or "
"'script'", >r->interactive, false);
gt_option_hide_default(o);
gt_option_parser_add_option(op, o);
o = gt_option_new_bool("q", "suppress warnings", >r->quiet, false);
gt_option_hide_default(o);
gt_option_parser_add_option(op, o);
o = gt_option_new_uint_min("j", "set number of parallel threads used at once",
>_jobs, 1, 1);
gt_option_is_development_option(o);
gt_option_parser_add_option(op, o);
o = gt_option_new_bool("test", "perform unit tests and exit", >r->test,
false);
gt_option_hide_default(o);
gt_option_parser_add_option(op, o);
only_option = gt_option_new_string("only", "perform single unit test "
"(requires -test)", gtr->test_only, "");
gt_option_imply(only_option, o);
gt_option_is_development_option(only_option);
gt_option_hide_default(only_option);
gt_option_parser_add_option(op, only_option);
debug_option = gt_option_new_debug(>r->debug);
gt_option_parser_add_option(op, debug_option);
debugfp_option = gt_option_new_string("debugfp",
"set file pointer for debugging output\n"
"use ``stdout'' for standard output\n"
"use ``stderr'' for standard error\n"
"or any other string to use the "
"corresponding file (will be overwritten "
"without warning!)", gtr->debugfp,
"stderr");
gt_option_is_development_option(debugfp_option);
gt_option_parser_add_option(op, debugfp_option);
gt_option_imply(debugfp_option, debug_option);
o = gt_option_new_uint("seed",
"set seed for random number generator manually.\n"
"0 generates a seed from current time and process id",
>r->seed, gtr->seed);
gt_option_hide_default(o);
gt_option_parser_add_option(op, o);
o = gt_option_new_bool("64bit", "exit with code 0 if this is a 64bit binary, "
"with 1 otherwise", >r->check64bit, false);
gt_option_is_development_option(o);
gt_option_parser_add_option(op, o);
o = gt_option_new_bool("list", "list all tools and exit", >r->list, false);
gt_option_is_development_option(o);
gt_option_hide_default(o);
gt_option_parser_add_option(op, o);
o = gt_option_new_filename("testspacepeak", "alloc 64 MB and mmap the given "
"file", gtr->testspacepeak);
gt_option_is_development_option(o);
gt_option_parser_add_option(op, o);
o = gt_option_new_string("createman", "create man page sources in directory",
gtr->manoutdir, "");
gt_option_is_development_option(o);
gt_option_parser_add_option(op, o);
return op;
}
static GtOptionParser* gt_show_seedext_option_parser_new(void *tool_arguments)
{
GtShowSeedextArguments *arguments = tool_arguments;
GtOptionParser *op;
GtOption *option, *op_ali, *option_filename, *op_relax_polish,
*op_seed_extend, *op_sortmatches, *op_showeoplist;
gt_assert(arguments);
/* init */
op = gt_option_parser_new("[options] -f <matchfilename>",
"Parse output of a seed extension and show/verify "
"the alignment.");
/* -a */
op_ali = gt_option_new_bool("a",
"show alignment",
&arguments->show_alignment,
false);
gt_option_parser_add_option(op, op_ali);
/* -seed-display */
option = gt_option_new_bool("seed-display",
"Display seeds in #-line and by "
"character + (instead of |) in middle "
"row of alignment column",
&arguments->seed_display,
false);
gt_option_parser_add_option(op, option);
/* -seed-extend */
op_seed_extend = gt_option_new_bool("seed-extend",
"read the seeds from the # seed: -lines and "
"extend them; match lines are ignored; "
"match coordindates are displayed",
&arguments->seed_extend,
false);
gt_option_parser_add_option(op, op_seed_extend);
/* -relax-polish */
op_relax_polish = gt_option_new_bool("relax-polish",
"do not force alignments to have "
"polished ends",
&arguments->relax_polish,false);
gt_option_parser_add_option(op, op_relax_polish);
gt_option_is_development_option(op_relax_polish);
gt_option_imply(op_relax_polish, op_ali);
/* -sort */
op_sortmatches = gt_option_new_bool("sort","sort matches in ascending order "
"of their end positon on the "
"query",
&arguments->sortmatches,false);
gt_option_parser_add_option(op, op_sortmatches);
/* -e */
op_showeoplist = gt_option_new_bool("e","show list of edit operations",
&arguments->showeoplist,false);
gt_option_parser_add_option(op, op_showeoplist);
/* -f */
option_filename = gt_option_new_filename("f",
"path to file with match coordinates",
arguments->matchfilename);
gt_option_is_mandatory(option_filename);
gt_option_parser_add_option(op, option_filename);
gt_option_exclude(op_seed_extend, op_sortmatches);
gt_option_exclude(op_relax_polish, op_seed_extend);
return op;
}
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_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_ulong("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 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;
}
static GtOptionParser* gt_eval_option_parser_new(void *tool_arguments)
{
EvalArguments *arguments = tool_arguments;
GtOptionParser *op;
GtOption *option, *ltroption, *ltrdeltaoption;
gt_assert(arguments);
op = gt_option_parser_new("reference_file prediction_file ",
"Compare annotation files and show "
"accuracy measures (prediction vs. reference).");
/* -exondiff */
option = gt_option_new_bool("exondiff", "show a diff for the exons",
&arguments->exondiff, false);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
/* -exondiffcollapsed */
option = gt_option_new_bool("exondiffcollapsed", "show a diff for the "
"collapsed exons", &arguments->exondiffcollapsed,
false);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
/* -nuc */
option = gt_option_new_bool("nuc",
"evaluate nucleotide level (memory consumption "
"is proportional to the input file sizes)",
&arguments->nuceval, true);
gt_option_parser_add_option(op, option);
/* -ltr */
ltroption = gt_option_new_bool("ltr", "evaluate a LTR retrotransposon "
"prediction instead of a gene prediction\n"
"(all LTR_retrotransposon elements are "
"considered to have an undetermined strand)",
&arguments->evalLTR, false);
gt_option_parser_add_option(op, ltroption);
/* -ltrdelta */
ltrdeltaoption = gt_option_new_uword("ltrdelta", "set allowed delta for LTR "
"borders to be considered equal",
&arguments->LTRdelta, 20);
gt_option_parser_add_option(op, ltrdeltaoption);
/* -v */
option = gt_option_new_verbose(&arguments->verbose);
gt_option_parser_add_option(op, option);
/* output file options */
gt_output_file_info_register_options(arguments->ofi, op, &arguments->outfp);
/* option implications */
gt_option_imply(ltrdeltaoption, ltroption);
/* set comment function */
gt_option_parser_set_comment_func(op, gt_gtdata_show_help, NULL);
/* set minimum and maximum number of arguments */
gt_option_parser_set_min_max_args(op, 2, 2);
return op;
}
