static GtOptionParser* gt_sequniq_option_parser_new(void *tool_arguments)
{
GtSequniqArguments *arguments = tool_arguments;
GtOptionParser *op;
GtOption *seqit_option, *verbose_option, *width_option, *rev_option,
*nofseqs_option;
gt_assert(arguments);
op = gt_option_parser_new("[option ...] sequence_file [...] ",
"Filter out repeated sequences in given "
"sequence files.");
/* -seqit */
seqit_option = gt_option_new_bool("seqit", "use sequence iterator",
&arguments->seqit, false);
gt_option_is_development_option(seqit_option);
gt_option_parser_add_option(op, seqit_option);
/* -nofseqs */
nofseqs_option = gt_option_new_uword("nofseqs", "number of sequences "
"(improves efficiency)\ndefault: unspecified",
&arguments->nofseqs, 0);
gt_option_is_development_option(nofseqs_option);
gt_option_hide_default(nofseqs_option);
gt_option_parser_add_option(op, nofseqs_option);
/* -rev */
rev_option = gt_option_new_bool("rev", "also filter out sequences whose "
"reverse complement is identical to a sequence already output",
&arguments->rev, false);
gt_option_parser_add_option(op, rev_option);
/* -v */
verbose_option = gt_option_new_verbose(&arguments->verbose);
gt_option_parser_add_option(op, verbose_option);
/* -width */
width_option = gt_option_new_width(&arguments->width);
gt_option_parser_add_option(op, width_option);
gt_output_file_info_register_options(arguments->ofi, op, &arguments->outfp);
/* option implications */
gt_option_imply(verbose_option, seqit_option);
gt_option_parser_set_comment_func(op, gt_gtdata_show_help, NULL);
gt_option_parser_set_min_args(op, 1U);
return op;
}
static GtOptionParser* gt_gff3validator_option_parser_new(void *tool_arguments)
{
GFF3ValidatorArguments *arguments = tool_arguments;
GtOptionParser *op;
GtOption *option;
gt_assert(arguments);
/* init */
op = gt_option_parser_new("[option ...] [GFF3_file ...]",
"Strictly validate given GFF3 files.");
/* typecheck options */
gt_typecheck_info_register_options(arguments->tci, op);
/* xrfcheck options */
gt_xrfcheck_info_register_options(arguments->xci, op);
/* -strict */
option = gt_option_new_bool("strict", "be very strict during GFF3 parsing "
"(stricter than the specification requires)",
&arguments->strict, false);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
return op;
}
void gt_typecheck_info_register_options(GtTypecheckInfo *tci,
GtOptionParser *op)
{
GtOption *typecheck_option, *built_in_option;
gt_assert(tci && op);
gt_assert(!tci->typecheck_option); /* can only called once */
/* -typecheck */
typecheck_option =
gt_option_new_string("typecheck", "check GFF3 types against \"id\" and "
"\"name\" tags in given OBO file and validate parent "
"(part-of) relationships.\nIf no argument is given, "
"the sofa.obo file from the gtdata/obo_files "
"directory is used.\nIf an argument is given, it is "
"used as an OBO filename.\nIn the case that such a "
"file does not exist '.obo' is added to the argument "
"and loading the resulting filename from the "
"gtdata/obo_files directory is attempted.",
tci->typecheck, NULL);
gt_option_argument_is_optional(typecheck_option);
gt_option_parser_add_option(op, typecheck_option);
tci->typecheck_option = gt_option_ref(typecheck_option);
/* -typecheck-built-in */
built_in_option = gt_option_new_bool("typecheck-built-in",
"use built-in type checker",
&tci->typecheck_built_in, false);
gt_option_is_development_option(built_in_option);
gt_option_parser_add_option(op, built_in_option);
gt_option_exclude(typecheck_option, built_in_option);
}
void gt_typecheck_info_register_options_with_default(GtTypecheckInfo *tci,
GtOptionParser *op,
const char *default_v)
{
GtOption *typecheck_option, *built_in_option;
gt_assert(tci && op);
gt_assert(!tci->typecheck_option); /* can only called once */
/* -typecheck */
typecheck_option =
gt_option_new_string("typecheck", "use an ontology given in an OBO file "
"to validate parent-child relationships.\n"
"If no argument is given, "
"the sofa.obo file from the gtdata/obo_files "
"directory is used.\nIf an argument is given, it is "
"used as an OBO filename.\nIn the case that such a "
"file does not exist '.obo' is added to the argument "
"and loading the resulting filename from the "
"gtdata/obo_files directory is attempted.",
tci->typecheck, default_v);
gt_option_argument_is_optional(typecheck_option);
gt_option_parser_add_option(op, typecheck_option);
tci->typecheck_option = gt_option_ref(typecheck_option);
/* -typecheck-built-in */
built_in_option = gt_option_new_bool("typecheck-built-in",
"use built-in type checker",
&tci->typecheck_built_in, false);
gt_option_is_development_option(built_in_option);
gt_option_parser_add_option(op, built_in_option);
gt_option_exclude(typecheck_option, built_in_option);
}
static GtOptionParser*
gt_compreads_decompress_option_parser_new(void *tool_arguments)
{
GtCsrHcrDecodeArguments *arguments = tool_arguments;
GtOptionParser *op;
GtOption *option;
gt_assert(arguments);
/* init */
op = gt_option_parser_new("[option ...] (-file file)",
"Decodes a file of compressed reads.");
option = gt_option_new_bool("v", "be verbose",
&arguments->verbose, false);
gt_option_parser_add_option(op, option);
option = gt_option_new_bool("descs","enable description decoding",
&arguments->descs, false);
gt_option_parser_add_option(op, option);
option = gt_option_new_string("file", "specify base name of files containing"
" HCR.",
arguments->file, NULL);
gt_option_is_mandatory(option);
gt_option_parser_add_option(op, option);
option = gt_option_new_string("name", "specify base name for decoded hcr"
" (suffix will be \".fastq\")",
arguments->name, NULL);
gt_option_parser_add_option(op, option);
option = gt_option_new_string("smap", "specify file containing alphabet"
"description (file must be an .al1 file)."
" If \"-smap\" is not set, dna alphabet is"
" used.",
arguments->smap, NULL);
gt_option_parser_add_option(op, option);
option = gt_option_new_range("range", "decode multiple consecutive reads."
" If range is not specified, the "
" entire file will be decoded.",
&arguments->rng, NULL);
gt_option_parser_add_option(op, option);
option = gt_option_new_ulong("benchmark", "decode given number random reads "
"and report the time to do this",
&arguments->bench, 0);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
gt_option_parser_set_min_max_args(op, 0U, 0U);
return op;
}
static GtOptionParser* gt_cds_option_parser_new(void *tool_arguments)
{
CDSArguments *arguments = tool_arguments;
GtOptionParser *op;
GtOption *option;
gt_assert(arguments);
op = gt_option_parser_new("[option ...] [GFF3_file]",
"Add CDS (coding sequence) features to exon "
"features given in GFF3 file.");
/* -minorflen */
option = gt_option_new_uint_min("minorflen", "set the minimum length an open "
"reading frame (ORF) must have to be added "
"as a CDS feature (measured in amino acids)",
&arguments->minorflen, 64, 1);
gt_option_parser_add_option(op, option);
/* -startcodon */
option = gt_option_new_bool("startcodon", "require than an ORF must begin "
"with a start codon", &arguments->start_codon,
false);
gt_option_parser_add_option(op, option);
/* -finalstopcodon */
option = gt_option_new_bool("finalstopcodon", "require that the final ORF "
"must end with a stop codon",
&arguments->final_stop_codon, false);
gt_option_parser_add_option(op, option);
/* -genericstartcodons */
option = gt_option_new_bool("genericstartcodons", "use generic start codons",
&arguments->generic_start_codons, false);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
/* -seqfile, -matchdesc, -usedesc and -regionmapping */
gt_seqid2file_register_options(op, arguments->s2fi);
/* -v */
option = gt_option_new_verbose(&arguments->verbose);
gt_option_parser_add_option(op, option);
/* output file options */
gt_outputfile_register_options(op, &arguments->outfp, arguments->ofi);
gt_option_parser_set_comment_func(op, gt_gtdata_show_help, NULL);
gt_option_parser_set_max_args(op, 1);
return op;
}
static GtOptionParser *gt_tyr_search_option_parser_new(void *tool_arguments)
{
GtOptionParser *op;
GtOption *option, *optiontyr, *optionqueries;
Tyr_search_options *arguments = tool_arguments;
op = gt_option_parser_new("[options] -tyr tallymer-index -q queryfile0 "
"[queryfile1..] [options]",
"Search a set of k-mers in an index constructed "
"by \"gt tyr mkindex\".");
gt_option_parser_set_mailaddress(op,"<*****@*****.**>");
optiontyr = gt_option_new_string("tyr","specify tallymer-index",
arguments->str_inputindex,
NULL);
gt_option_is_mandatory(optiontyr);
gt_option_parser_add_option(op, optiontyr);
optionqueries = gt_option_new_filenamearray("q","specify query file names",
arguments->queryfilenames);
gt_option_is_mandatory(optionqueries);
gt_option_parser_add_option(op, optionqueries);
option = gt_option_new_string("strand",
"specify the strand to be searched: "
"use f (for forward strand) or "
"p (for reverse complemented strand) or "
"fp (for both); default is f",
arguments->strandspec,
"f");
gt_option_parser_add_option(op, option);
option = gt_option_new_stringarray("output",
"specify output flags "
"(qseqnum, qpos, counts, sequence)",
arguments->showmodespec);
gt_option_parser_add_option(op, option);
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);
option = gt_option_new_verbose(&arguments->verbose);
gt_option_parser_add_option(op, option);
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_mailaddress(op,"<*****@*****.**>");
optionesaindex = gt_option_new_string("esa",
"Specify index (enhanced suffix array)",
arguments->str_inputindex, NULL);
gt_option_parser_add_option(op, optionesaindex);
arguments->refoptionesaindex = gt_option_ref(optionesaindex);
optionpckindex = gt_option_new_string("pck",
"Specify index (packed index)",
arguments->str_inputindex, NULL);
gt_option_parser_add_option(op, optionpckindex);
arguments->refoptionpckindex = gt_option_ref(optionpckindex);
gt_option_exclude(optionesaindex,optionpckindex);
gt_option_is_mandatory_either(optionesaindex,optionpckindex);
option = gt_option_new_filenamearray("q",
"Specify files containing the "
"query sequences",
arguments->queryfilenames);
gt_option_parser_add_option(op, option);
gt_option_is_mandatory(option);
option = gt_option_new_bool("cmp","compare results of offline and online "
"searches",&arguments->docompare,false);
gt_option_parser_add_option(op, option);
gt_option_is_development_option(option);
option = gt_option_new_verbose(&arguments->verbose);
gt_option_parser_add_option(op, option);
return op;
}
static GtOptionParser* gt_encseq_encode_option_parser_new(void *tool_arguments)
{
GtOptionParser *op;
GtOption *option;
GtEncseqEncodeArguments *arguments =
(GtEncseqEncodeArguments*) tool_arguments;
/* init */
op = gt_option_parser_new("sequence_file [sequence_file "
"[sequence_file ...]]",
"Encode sequence files (FASTA/FASTQ, GenBank, "
"EMBL) efficiently.");
/* -showstats */
option = gt_option_new_bool("showstats",
"show compression results",
&arguments->showstats,
false);
gt_option_parser_add_option(op, option);
/* -no_esq_header */
option = gt_option_new_bool("no_esq_header",
"omit the header in the .esq file",
&arguments->no_esq_header,
false);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
/* encoded sequence options */
arguments->eopts = gt_encseq_options_register_encoding(op,
arguments->indexname,
NULL);
/* -v */
option = gt_option_new_verbose(&arguments->verbose);
gt_option_parser_add_option(op, option);
gt_option_parser_set_min_args(op, 1);
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_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* 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_readjoiner_assembly_option_parser_new(
void *tool_arguments)
{
GtReadjoinerAssemblyArguments *arguments = tool_arguments;
GtOptionParser *op;
GtOption *option, *errors_option, *deadend_option, *v_option,
*q_option, *bubble_option, *deadend_depth_option;
gt_assert(arguments);
/* init */
op = gt_option_parser_new("[option ...]",
"Construct string graph and output contigs.");
/* -readset */
option = gt_option_new_string("readset", "specify the readset name",
arguments->readset, NULL);
gt_option_parser_add_option(op, option);
gt_option_is_mandatory(option);
/* -spmfiles */
option = gt_option_new_uint_min("spmfiles", "number of SPM files to read\n"
"this must be equal to the value of -j for the overlap phase",
&arguments->nspmfiles, 1U, 1U);
gt_option_is_extended_option(option);
gt_option_parser_add_option(op, option);
/* -l */
option = gt_option_new_uint_min("l", "specify the minimum SPM length",
&arguments->minmatchlength, 0, 2U);
gt_option_is_extended_option(option);
gt_option_parser_add_option(op, option);
/* -depthcutoff */
option = gt_option_new_uint_min("depthcutoff", "specify the minimal "
"number of nodes in a contig",
&arguments->depthcutoff, 3U, 1U);
gt_option_is_extended_option(option);
gt_option_parser_add_option(op, option);
/* -lengthcutoff */
option = gt_option_new_uint_min("lengthcutoff", "specify the minimal "
"length of a contig",
&arguments->lengthcutoff, 100U, 1U);
gt_option_is_extended_option(option);
gt_option_parser_add_option(op, option);
/* -redtrans */
option = gt_option_new_bool("redtrans", "reduce transitive edges",
&arguments->redtrans, false);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
/* -errors */
errors_option = gt_option_new_bool("errors", "search graph features which "
"may originate from sequencing errors and remove them",
&arguments->errors, false);
gt_option_is_extended_option(errors_option);
gt_option_parser_add_option(op, errors_option);
/* -bubble */
bubble_option = gt_option_new_uint("bubble", "number of rounds of p-bubble "
"removal to perform", &arguments->bubble, 3U);
gt_option_is_extended_option(bubble_option);
gt_option_imply(bubble_option, errors_option);
gt_option_parser_add_option(op, bubble_option);
/* -deadend */
deadend_option = gt_option_new_uint("deadend", "number of rounds of "
"dead end removal to perform a dead end",
&arguments->deadend, 10U);
gt_option_is_extended_option(deadend_option);
gt_option_imply(deadend_option, errors_option);
gt_option_parser_add_option(op, deadend_option);
/* -deadend-depth */
deadend_depth_option = gt_option_new_uint_min("deadend-depth", "specify the "
"maximal depth of a path to an end-vertex by which the path shall be "
"considered a dead end",
&arguments->deadend_depth, 10U, 1U);
gt_option_is_extended_option(deadend_depth_option);
gt_option_imply(deadend_depth_option, errors_option);
gt_option_parser_add_option(op, deadend_depth_option);
/* -paths2seq */
option = gt_option_new_bool("paths2seq", "read <indexname>"
GT_READJOINER_SUFFIX_CONTIG_PATHS " and write "
"<indexname>" GT_READJOINER_SUFFIX_CONTIGS,
&arguments->paths2seq, false);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
/* -buffersize */
option = gt_option_new_string("buffersize", "specify size for read buffer"
" of paths2seq phase (in bytes, the keywords 'MB' and 'GB' are allowed)",
arguments->buffersizearg, NULL);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
arguments->refoptionbuffersize = gt_option_ref(option);
/* -vd */
option = gt_option_new_bool("vd", "use verbose descriptions for contigs",
&arguments->vd, false);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
/* -astat */
option = gt_option_new_bool("astat", "calculate A-statistics for each contig",
&arguments->astat, false);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
/* -cov */
option = gt_option_new_double("cov", "average coverage value to use for the "
"A-statistics calculation", &arguments->coverage, (double)0);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
/* -copynum */
option = gt_option_new_bool("copynum", "load reads copy numbers list from "
"file for the A-statistics calculation",
&arguments->copynum, false);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
/* -v */
v_option = gt_option_new_verbose(&arguments->verbose);
gt_option_parser_add_option(op, v_option);
/* -q */
q_option = gt_option_new_bool("q", "suppress standard output messages",
&arguments->quiet, false);
gt_option_parser_add_option(op, q_option);
gt_option_exclude(q_option, v_option);
/* -load */
option = gt_option_new_bool("load", "save the string graph from file",
&arguments->load, false);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
/* -save */
option = gt_option_new_bool("save", "save the string graph to file",
&arguments->save, false);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
/* -show_contigs_info */
option = gt_option_new_bool("cinfo", "output additional files required "
"for contigs graph construction (eqlen only)",
&arguments->show_contigs_info, false);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
gt_option_parser_set_version_func(op, gt_readjoiner_show_version);
gt_option_parser_set_max_args(op, 0);
return op;
}
static GtOptionParser* gt_genomediff_option_parser_new(void *tool_arguments)
{
GtGenomediffArguments *arguments = tool_arguments;
GtOptionParser *op;
GtOption *option, *option_unitfile;
static const char *indextypes[] = { "esa", "pck", "encseq", NULL };
gt_assert(arguments);
/* init */
op = gt_option_parser_new("[option ...] "
"(INDEX | -indexname NAME SEQFILE SEQFILE [...]) ",
"Calculates Kr: pairwise distances between genomes.");
/* options */
option = gt_option_new_choice("indextype", "specify type of index, one of: "
"esa|pck|encseq. Where encseq is an encoded "
"sequence and an enhanced suffix array will be "
"constructed only in memory.",
arguments->indextype, indextypes[2],
indextypes);
gt_option_parser_add_option(op, option);
option = gt_option_new_string("indexname", "Basename of encseq to construct.",
arguments->indexname, NULL);
gt_option_parser_add_option(op, option);
/*-unitfile*/
option_unitfile =
gt_option_new_filename("unitfile",
"specifies genomic units, "
"see below for description.",
arguments->unitfile);
gt_option_parser_add_option(op, option_unitfile);
arguments->ref_unitfile = gt_option_ref(option_unitfile);
/* encseq options */
arguments->loadopts =
gt_encseq_options_register_loading(op, arguments->indexname);
gt_option_is_development_option(
gt_encseq_options_lossless_option(arguments->loadopts));
/* esa options */
arguments->idxopts =
gt_index_options_register_esa_noout(op);
gt_option_is_development_option(
gt_index_options_spmopt_option(arguments->idxopts));
/* scan */
option = gt_option_new_bool("scan", "do not load esa index but scan "
"it sequentially.", &arguments->scanfile, true);
gt_option_is_extended_option(option);
gt_option_parser_add_option(op, option);
/* dev options */
/* -max_n */
option = gt_option_new_uword("max_n", "Number of precalculated values "
"for ln(n!) and pmax(x).",
&arguments->max_ln_n_fac, 1000UL);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
/* -maxdepth */
option = gt_option_new_int("maxdepth", "max depth of .pbi-file, use with "
"-indextype pck.",
&arguments->user_max_depth, -1);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
/* thresholds */
/* divergence error */
option = gt_option_new_double("thr",
"Threshold for difference (du, dl) in "
"divergence calculation.\n"
"default: 1e-9",
&arguments->divergence_threshold,
1e-9);
gt_option_is_extended_option(option);
gt_option_hide_default(option);
gt_option_parser_add_option(op, option);
/* expected shulen error */
option = gt_option_new_double("abs_err",
"absolute error for expected shulen "
"calculation.\n"
"default: 1e-5",
&arguments->divergence_abs_err,
1e-5);
gt_option_is_extended_option(option);
gt_option_hide_default(option);
gt_option_parser_add_option(op, option);
/* relative expected shulen error */
option = gt_option_new_double("rel_err",
"relative error for expected shulen "
"calculation.\n"
"default: 1e-3",
&arguments->divergence_rel_err,
1e-3);
gt_option_is_extended_option(option);
gt_option_hide_default(option);
gt_option_parser_add_option(op, option);
/* M */
option = gt_option_new_double("M",
"threshold for minimum logarithm.\n"
"default: DBL_MIN",
&arguments->divergence_m,
DBL_MIN);
gt_option_is_extended_option(option);
gt_option_hide_default(option);
gt_option_parser_add_option(op, option);
/* -v */
option = gt_option_new_verbose(&arguments->verbose);
gt_option_parser_add_option(op, option);
/* mail */
gt_option_parser_set_mail_address(op, "<*****@*****.**>");
/* doc */
gt_option_parser_set_comment_func(op, gt_gtdata_show_help, NULL);
return op;
}
static GtOptionParser* gt_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_development_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_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_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_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_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_sketch_option_parser_new(void *tool_arguments)
{
GtSketchArguments *arguments = tool_arguments;
GtOptionParser *op;
GtOption *option, *option2;
static const char *formats[] = { "png",
#ifdef CAIRO_HAS_PDF_SURFACE
"pdf",
#endif
#ifdef CAIRO_HAS_SVG_SURFACE
"svg",
#endif
#ifdef CAIRO_HAS_PS_SURFACE
"ps",
#endif
NULL
};
static const char *inputs[] = {
"gff",
"bed",
"gtf",
NULL
};
gt_assert(arguments);
/* init */
op = gt_option_parser_new("[option ...] image_file [GFF3_file ...]",
"Create graphical representation of GFF3 "
"annotation files.");
/* -pipe */
option = gt_option_new_bool("pipe", "use pipe mode (i.e., show all gff3 "
"features on stdout)", &arguments->pipe, false);
gt_option_parser_add_option(op, option);
/* -flattenfiles */
option = gt_option_new_bool("flattenfiles", "do not group tracks by source "
"file name and remove file names from track "
"description", &arguments->flattenfiles, false);
gt_option_parser_add_option(op, option);
/* -seqid */
option = gt_option_new_string("seqid", "sequence region identifier\n"
"default: first one in file",
arguments->seqid, NULL);
gt_option_parser_add_option(op, option);
gt_option_hide_default(option);
/* -start */
option = gt_option_new_uword_min("start", "start position\n"
"default: first region start",
&arguments->start, GT_UNDEF_UWORD, 1);
gt_option_parser_add_option(op, option);
gt_option_hide_default(option);
/* -end */
option2 = gt_option_new_uword("end", "end position\ndefault: last region end",
&arguments->end, GT_UNDEF_UWORD);
gt_option_parser_add_option(op, option2);
/* -start and -end must be given together */
gt_option_imply(option, option2);
gt_option_imply(option2, option);
gt_option_hide_default(option2);
/* -width */
option = gt_option_new_uint_min("width", "target image width (in pixel)",
&arguments->width,
800, 1);
gt_option_parser_add_option(op, option);
/* -style */
option = gt_option_new_string("style", "style file to use",
arguments->stylefile,
gt_str_get(arguments->stylefile));
gt_option_parser_add_option(op, option);
/* -format */
option = gt_option_new_choice("format", "output graphics format\n"
"choose from png"
#ifdef CAIRO_HAS_PDF_SURFACE
"|pdf"
#endif
#ifdef CAIRO_HAS_SVG_SURFACE
"|svg"
#endif
#ifdef CAIRO_HAS_PS_SURFACE
"|ps"
#endif
"",
arguments->format, formats[0], formats);
gt_option_parser_add_option(op, option);
/* -input */
option = gt_option_new_choice("input", "input data format\n"
"choose from gff|bed|gtf",
arguments->input, inputs[0], inputs);
gt_option_parser_add_option(op, option);
/* -addintrons */
option = gt_option_new_bool("addintrons", "add intron features between "
"existing exon features (before drawing)",
&arguments->addintrons, false);
gt_option_parser_add_option(op, option);
/* -unsafe */
option = gt_option_new_bool("unsafe", "enable unsafe mode for style file",
&arguments->unsafe, false);
gt_option_parser_add_option(op, option);
/* -showrecmaps */
option = gt_option_new_bool("showrecmaps",
"show RecMaps after image creation",
&arguments->showrecmaps, false);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
/* -streams */
option = gt_option_new_bool("streams", "use streams to write data to file",
&arguments->use_streams, false);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
/* -v */
option = gt_option_new_verbose(&arguments->verbose);
gt_option_parser_add_option(op, option);
/* -force */
option = gt_option_new_bool(GT_FORCE_OPT_CSTR, "force writing to output file",
&arguments->force, false);
gt_option_parser_add_option(op, option);
gt_option_parser_set_min_args(op, 1);
return op;
}
static GtOptionParser *gt_idxlocali_option_parser_new (void *tool_arguments)
{
IdxlocaliOptions *arguments = tool_arguments;
GtOptionParser *op;
GtOption *option, *optionesaindex, *optionpckindex, *optiononline, *optioncmp;
gt_assert (arguments != NULL);
arguments->indexname = gt_str_new ();
arguments->queryfiles = gt_str_array_new ();
op = gt_option_parser_new
("[options] -q query-file-names [-esa|-pck] indexname",
"Find all local alignments using suffix tree.");
gt_option_parser_set_mailaddress (op, "<*****@*****.**>");
option = gt_option_new_filenamearray ("q","Specify files containing the "
"query sequences",
arguments->queryfiles);
gt_option_parser_add_option (op, option);
option = gt_option_new_long ("match",
"Specify match score",
&arguments->matchscore, 1L);
gt_option_parser_add_option (op, option);
option = gt_option_new_long ("mismatch",
"Specify mismatch score",
&arguments->mismatchscore, -3L);
gt_option_parser_add_option (op, option);
option = gt_option_new_long ("gapstart",
"Specify gap start score",
&arguments->gapstart, -5L);
gt_option_parser_add_option (op, option);
option = gt_option_new_long ("gapextend",
"Specify gap extension score",
&arguments->gapextend, -2L);
gt_option_parser_add_option (op, option);
option = gt_option_new_ulong_min ("th",
"Specify the threshold",
&arguments->threshold, 0, 1UL);
gt_option_parser_add_option (op, option);
gt_option_is_mandatory (option);
optionesaindex = gt_option_new_string ("esa",
"Specify index "
"(enhanced suffix array)",
arguments->indexname, NULL);
gt_option_parser_add_option (op, optionesaindex);
arguments->refoptionesaindex = gt_option_ref (optionesaindex);
optionpckindex = gt_option_new_string ("pck",
"Specify index (packed index)",
arguments->indexname, NULL);
gt_option_parser_add_option (op, optionpckindex);
arguments->refoptionpckindex = gt_option_ref (optionpckindex);
gt_option_exclude (optionesaindex, optionpckindex);
gt_option_is_mandatory_either (optionesaindex, optionpckindex);
optiononline = gt_option_new_bool("online","Perform online searches",
&arguments->doonline, false);
gt_option_parser_add_option(op, optiononline);
gt_option_is_development_option(optiononline);
optioncmp = gt_option_new_bool("cmp","Compare results of offline and online "
"searches",
&arguments->docompare, false);
gt_option_parser_add_option(op,optioncmp);
gt_option_exclude(optiononline,optioncmp);
option = gt_option_new_bool("s",
"Show alignments",
&arguments->showalignment, false);
gt_option_parser_add_option (op, option);
option = gt_option_new_verbose(&arguments->verbose);
gt_option_parser_add_option(op, option);
return op;
}
static GtOptionParser* gt_encseq2spm_option_parser_new(void *tool_arguments)
{
GtEncseq2spmArguments *arguments = tool_arguments;
GtOptionParser *op;
GtOption *option, *optionparts, *optionmemlimit;
gt_assert(arguments);
/* init */
op = gt_option_parser_new("[option ...] [file]",
"Compute suffix prefix matches "
"from encoded sequence.");
/* -l */
option = gt_option_new_uint_min("l", "specify the minimum length",
&arguments->minmatchlength, 0, 1U);
gt_option_parser_add_option(op, option);
gt_option_is_mandatory(option);
/* -parts */
optionparts = gt_option_new_uint("parts", "specify the number of parts",
&arguments->numofparts, 0U);
gt_option_parser_add_option(op, optionparts);
/* -memlimit */
optionmemlimit = gt_option_new_string("memlimit",
"specify maximal amount of memory to be used during "
"index construction (in bytes, the keywords 'MB' "
"and 'GB' are allowed)",
arguments->memlimitarg, NULL);
gt_option_parser_add_option(op, optionmemlimit);
gt_option_exclude(optionmemlimit, optionparts);
arguments->refoptionmemlimit = gt_option_ref(optionmemlimit);
/* -checksuftab */
option = gt_option_new_bool("checksuftab", "check the suffix table",
&arguments->checksuftab, false);
gt_option_parser_add_option(op, option);
gt_option_is_development_option(option);
/* -singlestrand */
option = gt_option_new_bool("singlestrand", "use only the forward strand "
"of the sequence",
&arguments->singlestrand, false);
gt_option_parser_add_option(op, option);
/* -spm */
option = gt_option_new_string("spm", "specify output for spms",
arguments->spmspec, NULL);
gt_option_parser_add_option(op, option);
/* -ii */
option = gt_option_new_string("ii", "specify the input sequence",
arguments->encseqinput, NULL);
gt_option_parser_add_option(op, option);
gt_option_is_mandatory(option);
/* -onlyaccum */
option = gt_option_new_bool("onlyaccum", "only accumulate codes",
&arguments->onlyaccum, false);
gt_option_parser_add_option(op, option);
gt_option_is_development_option(option);
/* -onlyallfirstcodes */
option = gt_option_new_bool("onlyallfirstcodes", "only determines allcodes",
&arguments->onlyallfirstcodes, false);
gt_option_parser_add_option(op, option);
gt_option_is_development_option(option);
/* -addbscachedepth */
option = gt_option_new_uint("addbscachedepth", "only determines allcodes",
&arguments->addbscache_depth, 5U);
gt_option_parser_add_option(op, option);
gt_option_is_development_option(option);
/* -phase2extra */
option = gt_option_new_string("phase2extra",
"specify amount of additional space required for "
"the second phase of the computation involving the "
"processing of the intervals (in bytes, "
"the keywords 'MB' and 'GB' are allowed)",
arguments->phase2extraarg, NULL);
gt_option_parser_add_option(op, option);
arguments->refoptionphase2extra = gt_option_ref(option);
gt_option_is_development_option(option);
/* -radixlarge */
option = gt_option_new_bool("radixlarge", "use large tables for radixsort",
&arguments->radixlarge, false);
gt_option_parser_add_option(op, option);
gt_option_is_development_option(option);
/* -radixparts */
option = gt_option_new_uint("radixparts", "specify the number of parts "
"for radixsort",
&arguments->radixparts, 1U);
gt_option_parser_add_option(op, option);
gt_option_is_development_option(option);
/* -singlescan */
option = gt_option_new_uint("singlescan", "run a single scan: 1=fast; "
"2=fast with check; 3=fast with output; "
"4=sfx-mapped4-version",
&arguments->singlescan, 0);
gt_option_parser_add_option(op, option);
gt_option_is_development_option(option);
/* -forcek */
option = gt_option_new_uint("forcek", "specify the value of k",
&arguments->forcek, 0);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
option = gt_option_new_verbose(&arguments->verbose);
gt_option_parser_add_option(op, option);
return op;
}
static GtIndexOptions*
gt_index_options_register_generic_output(GtOptionParser *op,
GtIndexOptions *idxo,
GtStr *indexname,
GtEncseqOptions *encopts)
{
gt_assert(idxo != NULL);
gt_assert(op != NULL && idxo->type != GT_INDEX_OPTIONS_UNDEFINED &&
encopts != NULL);
idxo->encopts = encopts;
idxo->indexname = indexname != NULL ? gt_str_ref(indexname) : NULL;
idxo->optionkys = gt_option_new_string("kys",
"output/sort according to keys of the form "
"|key| in fasta header",
idxo->kysargumentstring,
"nosort");
gt_option_argument_is_optional(idxo->optionkys);
gt_option_imply(idxo->optionkys, gt_encseq_options_sds_option(idxo->encopts));
gt_option_parser_add_option(op, idxo->optionkys);
gt_encseq_options_add_readmode_option(op, idxo->dir);
if (idxo->type == GT_INDEX_OPTIONS_ESA)
{
idxo->optionoutsuftab = gt_option_new_bool("suf",
"output suffix array (suftab) to file",
&idxo->outsuftab,
false);
gt_option_parser_add_option(op, idxo->optionoutsuftab);
idxo->optionoutlcptab = gt_option_new_bool("lcp",
"output lcp table (lcptab) to file",
&idxo->outlcptab,
false);
gt_option_parser_add_option(op, idxo->optionoutlcptab);
idxo->option = gt_option_new_bool("lcpdist",
"output distributions of values in lcptab",
&idxo->lcpdist,
false);
gt_option_is_extended_option(idxo->option);
gt_option_imply(idxo->option, idxo->optionoutlcptab);
gt_option_parser_add_option(op, idxo->option);
idxo->option = gt_option_new_bool("swallow-tail",
"swallow the tail of the suffix array and lcptab",
&idxo->swallow_tail,
false);
gt_option_is_development_option(idxo->option);
gt_option_parser_add_option(op, idxo->option);
idxo->optionoutbwttab = gt_option_new_bool("bwt",
"output Burrows-Wheeler Transformation "
"(bwttab) to file",
&idxo->outbwttab,
false);
gt_option_exclude(idxo->optionspmopt, idxo->optionoutbwttab);
gt_option_parser_add_option(op, idxo->optionoutbwttab);
idxo->optionoutbcktab = gt_option_new_bool("bck",
"output bucket table to file",
&idxo->outbcktab,
false);
gt_option_parser_add_option(op, idxo->optionoutbcktab);
} else {
idxo->optionoutsuftab
= idxo->optionoutlcptab = idxo->optionoutbwttab = NULL;
idxo->sfxstrategy.spmopt_minlength = 0;
#ifndef S_SPLINT_S
gt_registerPackedIndexOptions(op,
&idxo->bwtIdxParams,
BWTDEFOPT_CONSTRUCTION,
idxo->indexname);
#endif
}
gt_option_parser_register_hook(op, gt_index_options_check_set_out_opts, idxo);
return idxo;
}
static GtOptionParser*
gt_condenseq_compress_option_parser_new(void *tool_arguments)
{
GtCondenseqCompressArguments *arguments = tool_arguments;
GtOptionParser *op;
GtOption *option,
*option_fraction;
gt_assert(arguments);
/* init */
op = gt_option_parser_new("[options] INPUTENCSEQ",
"Compresses a GtEncseq to a UniqueEncseq.");
/* -indexname */
option = gt_option_new_string("indexname",
"path and basename of files to store",
arguments->indexname, NULL);
gt_option_parser_add_option(op, option);
/* -kmersize */
option = gt_option_new_uint_min("kmersize",
"kmer-size used for the seeds, default "
"depends on alphabet size",
&arguments->kmersize, GT_UNDEF_UINT, 2U);
gt_option_parser_add_option(op, option);
/* -windowsize */
option = gt_option_new_uint("windowsize",
"Size of window in which to search for hit pairs "
"of kmers, has to be larger than kmersize" ,
&arguments->windowsize, GT_UNDEF_UINT);
gt_option_parser_add_option(op, option);
/* -initsize */
option = gt_option_new_uword("initsize",
"length of inital unique database in bases, "
"should be larger than -alignlength",
&arguments->initsize, GT_UNDEF_UWORD);
gt_option_parser_add_option(op, option);
/* -alignlength */
option = gt_option_new_uword("alignlength",
"required minimal length of an xdrop-alignment, "
"should be larger than -windowsize",
&arguments->minalignlength, GT_UNDEF_UWORD);
gt_option_parser_add_option(op, option);
/* -cutoff */
option = gt_option_new_uword("cutoff",
"if a kmer is found more often than this value "
"it will be ignored for alignment searches. "
"Setting this to 0 will disable cutoffs, "
"leaving it undefined will use a cutoff based "
"on the mean number of occurences of a k-word.",
&arguments->cutoff_value, GT_UNDEF_UWORD);
gt_option_is_extended_option(option);
gt_option_parser_add_option(op, option);
/* -fraction */
option_fraction = gt_option_new_uword("fraction",
"when cutoffs aren'd disabled and no specific "
"value is set the mean number of occurrences "
"of each kmer divided by -fraction will be used "
"as cutoff",
&arguments->fraction, (GtUword) 2);
gt_option_is_extended_option(option_fraction);
gt_option_exclude(option, option_fraction);
gt_option_parser_add_option(op, option_fraction);
/* -disable_prune */
option = gt_option_new_bool("disable_prune",
"when cutoffs and this option are set, "
"the database will still save every kmer, even "
"though only cutoff many kmers will be used.",
&arguments->prune, false);
gt_option_is_extended_option(option);
gt_option_parser_add_option(op, option);
/* -mat */
option = gt_option_new_int("mat",
"matchscore for extension-alignment, "
"requirements: mat > mis, mat > 2ins, mat > 2del",
&arguments->scores.mat, 2);
gt_option_is_extended_option(option);
gt_option_parser_add_option(op, option);
/* -mis */
option = gt_option_new_int("mis",
"mismatchscore for extension-alignment, ",
&arguments->scores.mis, -1);
gt_option_is_extended_option(option);
gt_option_parser_add_option(op, option);
/* -ins */
option = gt_option_new_int("ins",
"insertionscore for extension-alignment",
&arguments->scores.ins, -2);
gt_option_is_extended_option(option);
gt_option_parser_add_option(op, option);
/* -del */
option = gt_option_new_int("del",
"deletionscore for extension-alignment",
&arguments->scores.del, -2);
gt_option_is_extended_option(option);
gt_option_parser_add_option(op, option);
/* -xdrop */
option = gt_option_new_word("xdrop",
"xdrop score for extension-alignment",
&arguments->xdrop, (GtWord) 3);
gt_option_is_extended_option(option);
gt_option_parser_add_option(op, option);
/* -brute_force */
option = gt_option_new_bool("brute_force", "disable filtering of seeds. "
"Incompatible with -diagonals yes "
"or -full_diags yes",
&arguments->brute, false);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
/* -diagonals */
option = gt_option_new_bool("diagonals", "use sparse diagonals. "
"Incompatible with -brute_force yes. "
"Disabling both diagonals will result in simple "
"filtering of seed positions.",
&arguments->diags, false);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
/* -full_diags */
option = gt_option_new_bool("full_diags", "use full (time efficient "
"space inefficient) diagonals. "
"Incompatible with -brute_force yes. "
"Disabling both diagonals will result in simple "
"filtering of seed positions.",
&arguments->full_diags, false);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
/* -clean_percent */
option = gt_option_new_uint("diags_clean",
"Percentage of sparse diagonals that is allowed "
"to be marked as deletable. Sensible default is "
"set." ,
&arguments->clean_percent, GT_UNDEF_UINT);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
/* -verbose */
option = gt_option_new_bool("verbose", "enable verbose output",
&arguments->verbose, false);
gt_option_parser_add_option(op, option);
/* -kdb*/
option = gt_option_new_bool("kdb", "prints out the kmer database (frequency "
"of each kmer), if -verbose each startposition "
"will be shown instead",
&arguments->kdb, false);
gt_option_parser_add_option(op, option);
return op;
}
static GtIndexOptions* gt_index_options_register_generic_create(
GtOptionParser *op,
GtIndexOptionsIndexType t)
{
GtIndexOptions *idxo;
gt_assert(op != NULL && t != GT_INDEX_OPTIONS_UNDEFINED);
idxo = gt_index_options_new();
idxo->type = t;
idxo->optionprefixlength = gt_option_new_uint_min("pl",
"specify prefix length for bucket sort\n"
"recommendation: use without argument;\n"
"then a reasonable prefix length is "
"automatically determined.",
&idxo->prefixlength,
GT_PREFIXLENGTH_AUTOMATIC,
1U);
gt_option_argument_is_optional(idxo->optionprefixlength);
gt_option_parser_add_option(op, idxo->optionprefixlength);
idxo->optionuserdefinedsortmaxdepth
= gt_option_new_uint_min("sortmaxdepth","sort only up to the given depth.",
&idxo->sfxstrategy.userdefinedsortmaxdepth,
0,
1U);
gt_option_parser_add_option(op, idxo->optionuserdefinedsortmaxdepth);
gt_option_is_development_option(idxo->optionuserdefinedsortmaxdepth);
idxo->optiondifferencecover = gt_option_new_uint_min("dc",
"specify difference cover value",
&idxo->sfxstrategy.differencecover,
0,
4U);
gt_option_parser_add_option(op, idxo->optiondifferencecover);
gt_option_exclude(idxo->optionuserdefinedsortmaxdepth,
idxo->optiondifferencecover);
idxo->optioncmpcharbychar = gt_option_new_bool("cmpcharbychar",
"compare suffixes character "
"by character",
&idxo->sfxstrategy.cmpcharbychar,
false);
gt_option_is_development_option(idxo->optioncmpcharbychar);
gt_option_parser_add_option(op, idxo->optioncmpcharbychar);
idxo->optionnoshortreadsort = gt_option_new_bool("noshortreadsort",
"do not use short read sort",
&idxo->sfxstrategy.noshortreadsort,
false);
gt_option_is_development_option(idxo->optionnoshortreadsort);
gt_option_parser_add_option(op, idxo->optionnoshortreadsort);
idxo->optionmaxwidthrealmedian = gt_option_new_uword("maxwidthrealmedian",
"compute real median for "
"intervals of at most the "
"given widthprefixes",
&idxo->sfxstrategy.
maxwidthrealmedian,
1UL);
gt_option_is_development_option(idxo->optionmaxwidthrealmedian);
gt_option_parser_add_option(op, idxo->optionmaxwidthrealmedian);
idxo->optionalgbounds
= gt_option_new_string_array("algbds",
"length boundaries for the different "
"algorithms to sort buckets of suffixes\n"
"first number: maxbound for insertion sort\n"
"second number: maxbound for blindtrie sort\n"
"third number: maxbound for counting sort",
idxo->algbounds);
gt_option_is_development_option(idxo->optionalgbounds);
gt_option_parser_add_option(op, idxo->optionalgbounds);
idxo->optionstorespecialcodes
= gt_option_new_bool("storespecialcodes",
"store special codes (this may speed up the program)",
&idxo->sfxstrategy.storespecialcodes,false);
gt_option_is_development_option(idxo->optionstorespecialcodes);
gt_option_parser_add_option(op, idxo->optionstorespecialcodes);
idxo->optionparts
= gt_option_new_uint_max("parts",
"specify number of parts in which the index "
"construction is performed",
&idxo->numofparts, 1U, (unsigned) ((1 << 22) - 1));
gt_option_is_development_option(idxo->optionparts);
gt_option_parser_add_option(op, idxo->optionparts);
if (idxo->type == GT_INDEX_OPTIONS_ESA)
{
idxo->optionspmopt = gt_option_new_uint_min("spmopt",
"optimize esa-construction for "
"suffix-prefix matching",
&idxo->sfxstrategy.spmopt_minlength,
0,1U);
gt_option_parser_add_option(op, idxo->optionspmopt);
gt_option_exclude(idxo->optionspmopt, idxo->optiondifferencecover);
idxo->optionmemlimit = gt_option_new_string("memlimit",
"specify maximal amount of memory to be used during "
"index construction (in bytes, the keywords 'MB' "
"and 'GB' are allowed)",
idxo->memlimit, NULL);
gt_option_parser_add_option(op, idxo->optionmemlimit);
gt_option_exclude(idxo->optionmemlimit, idxo->optionparts);
}
idxo->option = gt_option_new_bool("iterscan",
"use iteratorbased-kmer scanning",
&idxo->sfxstrategy.iteratorbasedkmerscanning,
false);
gt_option_is_development_option(idxo->option);
gt_option_parser_add_option(op, idxo->option);
idxo->option = gt_option_new_bool("samplewithprefixlengthnull",
"sort sample with prefixlength=0",
&idxo->sfxstrategy.samplewithprefixlengthnull,
false);
gt_option_is_development_option(idxo->option);
gt_option_parser_add_option(op, idxo->option);
idxo->option = gt_option_new_bool("suftabuint",
"use uint32_t for suftab",
&idxo->sfxstrategy.suftabuint,
false);
gt_option_is_development_option(idxo->option);
gt_option_parser_add_option(op, idxo->option);
idxo->option = gt_option_new_bool("onlybucketinsertion",
"perform only bucket insertion",
&idxo->sfxstrategy.onlybucketinsertion,
false);
gt_option_is_development_option(idxo->option);
gt_option_parser_add_option(op, idxo->option);
idxo->option = gt_option_new_bool("kmerswithencseqreader",
"always perform kmerscanning with encseq-reader",
&idxo->sfxstrategy.kmerswithencseqreader,
false);
gt_option_is_development_option(idxo->option);
gt_option_parser_add_option(op, idxo->option);
idxo->option = gt_option_new_bool("dccheck",
"check intermediate results in difference cover",
&idxo->sfxstrategy.dccheck,
false);
gt_option_is_development_option(idxo->option);
gt_option_parser_add_option(op, idxo->option);
idxo->option = gt_option_new_bool("withradixsort",
"use radixsort to sort the buckets",
&idxo->sfxstrategy.withradixsort,
false);
gt_option_is_development_option(idxo->option);
gt_option_parser_add_option(op, idxo->option);
idxo->option = gt_option_new_bool("compressedoutput",
"output suftab and lcptab in compressed "
"form",
&idxo->sfxstrategy.compressedoutput,
false);
gt_option_is_development_option(idxo->option);
gt_option_parser_add_option(op, idxo->option);
gt_option_parser_register_hook(op, gt_index_options_check_set_create_opts,
idxo);
return idxo;
}
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_gff3_option_parser_new(void *tool_arguments)
{
GFF3Arguments *arguments = tool_arguments;
GtOptionParser *op;
GtOption *sort_option, *load_option, *strict_option, *tidy_option,
*mergefeat_option, *addintrons_option, *offset_option,
*offsetfile_option, *setsource_option, *option;
gt_assert(arguments);
/* init */
op = gt_option_parser_new("[option ...] [GFF3_file ...]", "Parse, possibly "
"transform, and output GFF3 files.");
/* -sort */
sort_option = gt_option_new_bool("sort", "sort the GFF3 features (memory "
"consumption is proportional to the input "
"file size(s))",
&arguments->sort, false);
gt_option_parser_add_option(op, sort_option);
/* -strict */
strict_option = gt_option_new_bool("strict", "be very strict during GFF3 "
"parsing (stricter than the specification "
"requires)", &arguments->strict, false);
gt_option_is_development_option(strict_option);
gt_option_parser_add_option(op, strict_option);
/* -tidy */
tidy_option = gt_option_new_bool("tidy", "try to tidy the GFF3 files up "
"during parsing", &arguments->tidy, false);
gt_option_parser_add_option(op, tidy_option);
gt_option_exclude(strict_option, tidy_option);
/* -retainids */
option = gt_option_new_bool("retainids",
"when available, use the original IDs provided "
"in the source file\n"
"(memory consumption is proportional to the "
"input file size(s))", &arguments->retainids,
false);
gt_option_parser_add_option(op, option);
/* -checkids */
option = gt_option_new_bool("checkids",
"make sure the ID attributes are unique "
"within the scope of each GFF3_file, as required "
"by GFF3 specification\n"
"(memory consumption is proportional to the "
"input file size(s))", &arguments->checkids,
false);
gt_option_parser_add_option(op, option);
/* -addids */
option = gt_option_new_bool("addids", "add missing \""
GT_GFF_SEQUENCE_REGION"\" lines automatically",
&arguments->addids, true);
gt_option_parser_add_option(op, option);
/* -fixregionboundaries */
option = gt_option_new_bool("fixregionboundaries", "automatically adjust \""
GT_GFF_SEQUENCE_REGION"\" lines to contain all "
"their features (memory consumption is "
"proportional to the input file size(s))",
&arguments->fixboundaries, false);
gt_option_parser_add_option(op, option);
/* -mergefeat */
mergefeat_option = gt_option_new_bool("mergefeat",
"merge adjacent features of the same "
"type", &arguments->mergefeat, false);
gt_option_is_development_option(mergefeat_option);
gt_option_imply(mergefeat_option, sort_option);
gt_option_parser_add_option(op, mergefeat_option);
/* -load */
load_option = gt_option_new_bool("load", "load the GFF3 features into memory "
"(requires space proportional to the input "
"file size(s))",
&arguments->load, false);
gt_option_is_development_option(load_option);
gt_option_parser_add_option(op, load_option);
/* -addintrons */
addintrons_option = gt_option_new_bool("addintrons", "add intron features "
"between existing exon features",
&arguments->addintrons, false);
gt_option_parser_add_option(op, addintrons_option);
/* -offset */
offset_option = gt_option_new_word("offset", "transform all features by the "
"given offset", &arguments->offset,
GT_UNDEF_WORD);
gt_option_parser_add_option(op, offset_option);
/* -offsetfile */
offsetfile_option = gt_option_new_filename("offsetfile", "transform all "
"features by the offsets given in "
"file", arguments->offsetfile);
gt_option_parser_add_option(op, offsetfile_option);
gt_option_exclude(offset_option, offsetfile_option);
/* -setsource */
setsource_option = gt_option_new_string("setsource", "set the 'source' "
"value (2nd column) of each feature",
arguments->newsource, NULL);
gt_option_parser_add_option(op, setsource_option);
/* typecheck options */
gt_typecheck_info_register_options(arguments->tci, op);
/* -show */
option = gt_option_new_bool("show", "show GFF3 output", &arguments->show,
true);
gt_option_parser_add_option(op, option);
/* -v */
option = gt_option_new_verbose(&arguments->verbose);
gt_option_parser_add_option(op, option);
/* -width */
option = gt_option_new_width(&arguments->width);
gt_option_parser_add_option(op, option);
/* output file options */
gt_output_file_info_register_options(arguments->ofi, op, &arguments->outfp);
/* set comment function */
gt_option_parser_set_comment_func(op, gt_gtdata_show_help, NULL);
return op;
}
static GtOptionParser* gt_gdiffcalc_option_parser_new(void *tool_arguments)
{
GtGenomediffArguments *arguments = tool_arguments;
GtOptionParser *op;
GtOption *option, *option_unitfile;
gt_assert(arguments);
/* init */
op = gt_option_parser_new("[option ...] "
"-indexname NAME AVGSHULEN) ",
"Calculates Kr: pairwise distances between genomes.");
/* options */
option = gt_option_new_string("indexname", "Basename of encseq to construct.",
arguments->indexname, NULL);
gt_option_is_mandatory(option);
gt_option_parser_add_option(op, option);
/*-unitfile*/
option_unitfile =
gt_option_new_filename("unitfile",
"specifies genomic units, see below for description",
arguments->unitfile);
gt_option_parser_add_option(op, option_unitfile);
arguments->ref_unitfile = gt_option_ref(option_unitfile);
/* encseq options */
arguments->loadopts =
gt_encseq_options_register_loading(op, arguments->indexname);
gt_option_is_development_option(
gt_encseq_options_lossless_option(arguments->loadopts));
/* dev options */
/* -max_n */
option = gt_option_new_uword("max_n", "Number of precalculated values "
"for ln(n!) and pmax(x)",
&arguments->max_ln_n_fac, 1000UL);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
/* thresholds */
/* divergence error */
option = gt_option_new_double("thr",
"Threshold for difference (du, dl) in "
"divergence calculation.\n"
"default: 1e-9",
&arguments->divergence_threshold,
1e-9);
gt_option_is_extended_option(option);
gt_option_hide_default(option);
gt_option_parser_add_option(op, option);
/* expected shulen error */
option = gt_option_new_double("abs_err",
"absolute error for expected shulen "
"calculation.\n"
"default: 1e-5",
&arguments->divergence_abs_err,
1e-5);
gt_option_is_extended_option(option);
gt_option_hide_default(option);
gt_option_parser_add_option(op, option);
/* relative expected shulen error */
option = gt_option_new_double("rel_err",
"relative error for expected shulen "
"calculation.\n"
"default: 1e-3",
&arguments->divergence_rel_err,
1e-3);
gt_option_is_extended_option(option);
gt_option_hide_default(option);
gt_option_parser_add_option(op, option);
/* M */
option = gt_option_new_double("M",
"threshold for minimum logarithm.\n"
"default: DBL_MIN",
&arguments->divergence_m,
DBL_MIN);
gt_option_is_extended_option(option);
gt_option_hide_default(option);
gt_option_parser_add_option(op, option);
/* -v */
option = gt_option_new_verbose(&arguments->verbose);
gt_option_parser_add_option(op, option);
/* mail */
gt_option_parser_set_mail_address(op, "<*****@*****.**>");
/* doc */
gt_option_parser_set_comment_func(op, gt_gtdata_show_help, NULL);
return op;
}
static GtOptionParser* gt_seed_extend_option_parser_new(void *tool_arguments)
{
GtSeedExtendArguments *arguments = tool_arguments;
GtOptionParser *op;
GtOption *option, *op_gre, *op_xdr, *op_cam, *op_his, *op_dif, *op_pmh,
*op_len, *op_err, *op_xbe, *op_sup, *op_frq, *op_mem, *op_ali, *op_bia;
gt_assert(arguments != NULL);
/* init */
op = gt_option_parser_new("[option ...] encseq_basename [encseq_basename]",
"Calculate local alignments using the seed and "
"extend algorithm.");
/* DIAGBANDSEED OPTIONS */
/* -ii */
option = gt_option_new_string("ii",
"Input index for encseq encoded sequences",
arguments->dbs_indexname,
"");
gt_option_is_mandatory(option);
gt_option_parser_add_option(op, option);
/* -qii */
option = gt_option_new_string("qii",
"Query input index (encseq)",
arguments->dbs_queryname,
"");
gt_option_parser_add_option(op, option);
/* -seedlength */
op_len = gt_option_new_uint_min_max("seedlength",
"Minimum length of a seed",
&arguments->dbs_seedlength,
14UL, 1UL, 32UL);
gt_option_parser_add_option(op, op_len);
/* -diagbandwidth */
option = gt_option_new_uword("diagbandwidth",
"Logarithm of diagonal band width (for filter)",
&arguments->dbs_logdiagbandwidth,
6UL);
gt_option_parser_add_option(op, option);
/* -mincoverage */
option = gt_option_new_uword("mincoverage",
"Minimum coverage in two neighbouring diagonal "
"bands (for filter)",
&arguments->dbs_mincoverage,
35UL);
gt_option_parser_add_option(op, option);
/* -maxfreq */
op_frq = gt_option_new_uword_min("maxfreq",
"Maximum frequency of a k-mer (for filter)",
&arguments->dbs_maxfreq,
GT_UWORD_MAX, 1UL);
gt_option_parser_add_option(op, op_frq);
/* -t */
op_sup = gt_option_new_uword_min("t",
"Suppress k-mers occurring at least t times "
"(for filter)",
&arguments->dbs_suppress,
GT_UWORD_MAX, 2UL);
gt_option_exclude(op_sup, op_frq);
gt_option_is_development_option(op_sup);
gt_option_parser_add_option(op, op_sup);
/* -memlimit */
op_mem = gt_option_new_string("memlimit",
"Maximum memory usage to determine the maximum "
"frequency of a k-mer (for filter)",
arguments->dbs_memlimit_str,
"");
gt_option_parser_add_option(op, op_mem);
/* -debug-kmer */
option = gt_option_new_bool("debug-kmer",
"Output KmerPos lists",
&arguments->dbs_debug_kmer,
false);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
/* -debug-seedpair */
option = gt_option_new_bool("debug-seedpair",
"Output SeedPair lists",
&arguments->dbs_debug_seedpair,
false);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
/* -verify */
option = gt_option_new_bool("verify",
"Check that k-mer seeds occur in the sequences",
&arguments->dbs_verify,
false);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
/* SEED EXTENSION OPTIONS */
/* -extendxdrop */
op_xdr = gt_option_new_uword_min_max("extendxdrop",
"Extend seed to both sides using xdrop "
"algorithm, optional parameter "
"specifies sensitivity",
&arguments->se_extendxdrop,
97UL, 90UL, 100UL);
gt_option_argument_is_optional(op_xdr);
gt_option_parser_add_option(op, op_xdr);
arguments->se_option_xdrop = gt_option_ref(op_xdr);
/* -xdropbelow */
op_xbe = gt_option_new_word("xdropbelow",
"Specify xdrop cutoff score (0 means "
"automatically defined depending on minidentity)",
&arguments->se_xdropbelowscore,
0L);
gt_option_imply(op_xbe, op_xdr);
gt_option_parser_add_option(op, op_xbe);
/* -extendgreedy */
op_gre = gt_option_new_uword_min_max("extendgreedy",
"Extend seed to both sides using greedy "
"algorithm, optional parameter "
"specifies sensitivity",
&arguments->se_extendgreedy,
97UL, 90UL, 100UL);
gt_option_argument_is_optional(op_gre);
gt_option_exclude(op_gre, op_xdr);
gt_option_parser_add_option(op, op_gre);
arguments->se_option_greedy = gt_option_ref(op_gre);
/* -history */
op_his = gt_option_new_uword_min_max("history",
"Size of (mis)match history in range [1"
"..64] (trimming for greedy extension)",
&arguments->se_historysize,
60UL, 1UL, 64UL);
gt_option_imply(op_his, op_gre);
gt_option_parser_add_option(op, op_his);
/* -maxalilendiff */
op_dif = gt_option_new_uword("maxalilendiff",
"Maximum difference of alignment length "
"(trimming for greedy extension)",
&arguments->se_maxalilendiff, 0UL);
gt_option_imply(op_dif, op_gre);
gt_option_is_development_option(op_dif);
gt_option_parser_add_option(op, op_dif);
/* -percmathistory */
op_pmh = gt_option_new_uword_min_max("percmathistory",
"percentage of matches required in "
"history (for greedy extension)",
&arguments->se_perc_match_hist,
0UL, 1UL, 100UL);
gt_option_imply(op_pmh, op_gre);
gt_option_is_development_option(op_pmh);
gt_option_parser_add_option(op, op_pmh);
/* -bias-parameters */
op_bia = gt_option_new_bool("bias-parameters",
"Use -maxalilendiff 30 and let percmathistory "
"depend on minidentiy and DNA base distribution",
&arguments->bias_parameters,
false);
gt_option_imply(op_bia, op_gre);
gt_option_exclude(op_bia, op_pmh);
gt_option_exclude(op_bia, op_dif);
gt_option_is_development_option(op_bia);
gt_option_parser_add_option(op, op_bia);
/* -cam */
op_cam = gt_option_new_string("cam",
gt_cam_extendgreedy_comment(),
arguments->se_char_access_mode,
"");
gt_option_is_development_option(op_cam);
gt_option_parser_add_option(op, op_cam);
/* -l */
op_len = gt_option_new_uword_min("l",
"Minimum alignment length "
"(for seed extension)",
&arguments->se_alignlength,
20UL, 1UL);
gt_option_imply_either_2(op_len, op_xdr, op_gre);
gt_option_parser_add_option(op, op_len);
/* -minidentity */
op_err = gt_option_new_uword_min_max("minidentity",
"Minimum identity of matches "
"(for seed extension)",
&arguments->se_minidentity,
80UL, GT_EXTEND_MIN_IDENTITY_PERCENTAGE,
99UL);
gt_option_imply_either_2(op_err, op_xdr, op_gre);
gt_option_parser_add_option(op, op_err);
/* -a */
op_ali = gt_option_new_uword_min("a",
"show alignments/sequences (optional "
"argument is number of columns per line)",
&arguments->se_alignmentwidth,
70, 20);
gt_option_argument_is_optional(op_ali);
gt_option_parser_add_option(op, op_ali);
arguments->se_option_withali = gt_option_ref(op_ali);
/* -mirror */
option = gt_option_new_bool("mirror",
"Add reverse complement reads",
&arguments->mirror,
false);
gt_option_parser_add_option(op, option);
/* -overlappingseeds */
option = gt_option_new_bool("overlappingseeds",
"Allow overlapping SeedPairs",
&arguments->overlappingseeds,
false);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
/* -benchmark */
option = gt_option_new_bool("benchmark",
"Measure total running time and be silent",
&arguments->benchmark,
false);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
/* -seed-display */
option = gt_option_new_bool("seed-display",
"Display seeds in #-line",
&arguments->seed_display,
false);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
/* -v */
option = gt_option_new_verbose(&arguments->verbose);
gt_option_parser_add_option(op, option);
return op;
}
static GtOptionParser* gt_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;
}
