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 GtOPrval gthmkbssmfiles_parse_options(int *parsed_args, int argc,
const char **argv, GtError *err)
{
GtOptionParser *op;
GtOPrval oprval;
gt_error_check(err);
op = gt_option_parser_new("output_path", "Write hard coded BSSM files to "
"output_path.");
gt_option_parser_set_min_max_args(op, 1, 1);
gt_option_parser_set_mail_address(op, "<*****@*****.**>");
oprval = gt_option_parser_parse(op, parsed_args, argc, argv, gt_versionfunc,
err);
gt_option_parser_delete(op);
return oprval;
}
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 gthfilestat_parse_options(int *parsed_args,
GthFileStatInfo *file_stat_info,
int argc, const char **argv,
const GthPlugins *plugins,
GtError *err)
{
GtOptionParser *op;
GtOption *o;
GtOPrval oprval;
bool verbose;
gt_error_check(err);
op = gt_option_parser_new("[option ...] [file ...]", "Show statistics about "
"spliced alignments in GenomeThreader output files\n"
"containing intermediate results.");
/* add sa_filter options */
gth_sa_filter_register_options(op, file_stat_info->sa_filter, false);
/* -v */
o = gt_option_new_verbose(&verbose);
gt_option_parser_add_option(op, o);
gt_option_parser_set_mail_address(op, "<*****@*****.**>");
oprval = gt_option_parser_parse(op, parsed_args, argc, argv,
plugins->gth_version_func, err);
if (verbose)
file_stat_info->showverbose = gth_show_on_stdout;
/* save consensus files */
if (oprval == GT_OPTION_PARSER_OK) {
while (*parsed_args < argc) {
gt_str_array_add_cstr(file_stat_info->consensusfiles,
argv[*parsed_args]);
(*parsed_args)++;
}
}
gt_option_parser_delete(op);
return oprval;
}
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_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 GtOPrval gthsplit_parse_options(int *parsed_args,
Gthsplitinfo *gthsplitinfo,
int argc, const char **argv,
const GthPlugins *plugins, GtError *err)
{
GtOptionParser *op;
GtOption *optalignmentscore, *optcoverage, *optrange, *optverbose, *optgzip,
*optbzip2, *optforce;
bool alignmentscore, coverage, verbose, gzip, bzip2;
GtOPrval oprval;
gt_error_check(err);
op = gt_option_parser_new("-alignmentscore | -coverage [option ...] "
"[file ...]", "Split GenomeThreader output files "
"containing intermediate results.");
/* specify all options with a corresponding help-text */
optalignmentscore = gt_option_new_bool("alignmentscore", "split according to "
"the overall alignment score (scr)",
&alignmentscore, false);
gt_option_parser_add_option(op, optalignmentscore);
optcoverage = gt_option_new_bool("coverage", "split according to coverage "
"(cov)", &coverage, false);
gt_option_parser_add_option(op, optcoverage);
optrange = gt_option_new_uint_max(RANGE_OPT_CSTR, "set the percentage range "
"used to create the sets",
>hsplitinfo->range, DEFAULT_RANGE, 100);
gt_option_parser_add_option(op, optrange);
/* add sa_filter options */
gth_sa_filter_register_options(op, gthsplitinfo->sa_filter, false);
/* -v */
optverbose = gt_option_new_verbose(&verbose);
gt_option_parser_add_option(op, optverbose);
optgzip = gt_option_new_bool("gzip", "write gzip compressed output file(s)",
&gzip, false);
gt_option_parser_add_option(op, optgzip);
optbzip2 = gt_option_new_bool("bzip2", "write bzip2 compressed output "
"file(s)", &bzip2, false);
gt_option_parser_add_option(op, optbzip2);
optforce = gt_option_new_bool(GT_FORCE_OPT_CSTR,"force writing to split "
"files", >hsplitinfo->force, false);
gt_option_parser_add_option(op, optforce);
gt_option_exclude(optalignmentscore, optcoverage);
gt_option_exclude(optgzip, optbzip2);
gt_option_is_mandatory_either(optalignmentscore, optcoverage);
gt_option_parser_set_mail_address(op, "<*****@*****.**>");
oprval = gt_option_parser_parse(op, parsed_args, argc, argv,
plugins->gth_version_func, err);
if (oprval == GT_OPTION_PARSER_OK && alignmentscore)
gthsplitinfo->splitmode = ALIGNMENTSCORE_SPLIT;
if (oprval == GT_OPTION_PARSER_OK && coverage)
gthsplitinfo->splitmode = COVERAGE_SPLIT;
if (oprval == GT_OPTION_PARSER_OK && 100 % gthsplitinfo->range) {
gt_error_set(err, "argument to option %s must divide 100 without rest",
RANGE_OPT_CSTR);
oprval = GT_OPTION_PARSER_ERROR;
}
if (oprval == GT_OPTION_PARSER_OK && verbose)
gthsplitinfo->showverbose = gth_show_on_stdout;
if (oprval == GT_OPTION_PARSER_OK && gzip)
gthsplitinfo->file_mode = GT_FILE_MODE_GZIP;
if (oprval == GT_OPTION_PARSER_OK && bzip2)
gthsplitinfo->file_mode = GT_FILE_MODE_BZIP2;
/* save consensus files */
if (oprval == GT_OPTION_PARSER_OK) {
while (*parsed_args < argc) {
gt_str_array_add_cstr(gthsplitinfo->consensusfiles, argv[*parsed_args]);
(*parsed_args)++;
}
}
if (oprval == GT_OPTION_PARSER_OK &&
!gt_str_array_size(gthsplitinfo->consensusfiles) &&
(gt_option_is_set(optgzip) || gt_option_is_set(optbzip2))) {
gt_error_set(err, "to use compression, at least on input file has to be "
"supplied");
oprval = GT_OPTION_PARSER_ERROR;
}
gt_option_parser_delete(op);
return oprval;
}
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 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 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;
}
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;
}
