static OPrval parse_options(int *parsed_args, RegionCovArguments *arguments,
int argc, const char **argv, GtError *err)
{
GtOptionParser *op;
GtOption *o;
OPrval oprval;
gt_error_check(err);
op = gt_option_parser_new("[option ...] GFF3_file",
"Show which parts of the given sequence regions are "
"covered by features.");
/* -maxfeaturedist */
o = gt_option_new_ulong("maxfeaturedist", "set the maximum distance two "
"features can have while still being in the same "
"``cluster''", &arguments->max_feature_dist, 0);
gt_option_parser_add_option(op, o);
/* -v */
o = gt_option_new_verbose(&arguments->verbose);
gt_option_parser_add_option(op, o);
/* parse */
gt_option_parser_set_min_max_args(op, 1, 1);
oprval = gt_option_parser_parse(op, parsed_args, argc, argv, gt_versionfunc,
err);
gt_option_parser_delete(op);
return oprval;
}
static GtOptionParser* gt_seqids_option_parser_new(GT_UNUSED
void *tool_arguments)
{
GtOptionParser *op;
op = gt_option_parser_new("[GFF3_file]",
"Show sequence IDs from annotation file.");
gt_option_parser_set_min_max_args(op, 1, 1);
return op;
}
static GtOptionParser*
gt_compreads_compress_option_parser_new(void *tool_arguments)
{
GtCsrHcrEncodeArguments *arguments = tool_arguments;
GtOptionParser *op;
GtOption *option;
static const char *methods[] = { "page", "regular", "none" };
gt_assert(arguments);
/* init */
op = gt_option_parser_new("[option ...] (-files file [...])",
"Generates compact encoding for fastq data.");
option = gt_option_new_bool("descs","encode descriptions",
&arguments->descs, false);
gt_option_parser_add_option(op, option);
option = gt_option_new_filename_array("files", "File(s) containing reads.",
arguments->files);
gt_option_parser_add_option(op, option);
option = gt_option_new_string("name", "specify base name for HCR to be"
" generated. Only mandatory, if more than one"
" file was given.", arguments->name, NULL);
gt_option_parser_add_option(op, option);
option = gt_option_new_string("smap", "file containing alphabet description."
" If \"-smap\" is not set, dna alphabet is"
" used.",
arguments->smap, NULL);
gt_option_parser_add_option(op, option);
option = gt_option_new_range("qrange", "specify range of quality values."
" All values smaller or equal to the lower bound"
" will be converted to the lower bound. All"
" values equal or larger than the upper bound"
" will be converted to the upper bound.",
&arguments->arg_range, NULL);
gt_option_parser_add_option(op, option);
option = gt_option_new_uword("srate", "sampling rate, set to sensible default"
" depending on sampling method",
&arguments->srate, GT_UNDEF_UWORD);
gt_option_parser_add_option(op, option);
option = gt_option_new_choice("stype", "type of sampling\n"
"one of regular - page - none",
arguments->method, "page",
methods);
gt_option_parser_add_option(op, option);
gt_option_parser_set_min_max_args(op, 0U, 0U);
return op;
}
static GtOptionParser*
gt_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 GtOPrval gthmkbssmfiles_parse_options(int *parsed_args, int argc,
const char **argv, GtError *err)
{
GtOptionParser *op;
GtOPrval oprval;
gt_error_check(err);
op = gt_option_parser_new("output_path", "Write hard coded BSSM files to "
"output_path.");
gt_option_parser_set_min_max_args(op, 1, 1);
gt_option_parser_set_mail_address(op, "<*****@*****.**>");
oprval = gt_option_parser_parse(op, parsed_args, argc, argv, gt_versionfunc,
err);
gt_option_parser_delete(op);
return oprval;
}
static OPrval
parseChkIndexOptions(int *parsed_args, int argc, const char *argv[],
struct chkIndexOptions *params, GtError *err)
{
GtOptionParser *op;
GtOption *option;
OPrval oprval;
bool extRankCheck;
gt_error_check(err);
op = gt_option_parser_new("indexname",
"Map <indexname> block composition index"
"and bwt and check index integrity.");
option = gt_option_new_bool("v",
"print verbose progress information",
¶ms->verboseOutput,
false);
gt_option_parser_add_option(op, option);
option = gt_option_new_ulong("skip", "number of symbols to skip",
¶ms->skipCount, 0);
gt_option_parser_add_option(op, option);
option = gt_option_new_ulong("ticks", "print dot after this many symbols"
" tested okay", ¶ms->progressInterval,
DEFAULT_PROGRESS_INTERVAL);
gt_option_parser_add_option(op, option);
option = gt_option_new_bool("ext-rank-check",
"do additional checks of rank query results",
&extRankCheck, false);
gt_option_parser_add_option(op, option);
gt_option_parser_set_min_max_args(op, 1, 1);
oprval = gt_option_parser_parse(op, parsed_args, argc, (const char**) argv,
gt_versionfunc, err);
gt_option_parser_delete(op);
params->checkFlags = EIS_VERIFY_BASIC | (extRankCheck?EIS_VERIFY_EXT_RANK:0);
params->EISFeatureSet = EIS_FEATURE_REGION_SUMS;
params->encType = BWT_ON_BLOCK_ENC;
return oprval;
}
static GtOptionParser* gt_seqorder_option_parser_new(void *tool_arguments)
{
GtSeqorderArguments *arguments = tool_arguments;
GtOptionParser *op;
GtOption *invert_option, *sort_option, *revsort_option, *shuffle_option;
gt_assert(arguments);
/* init */
op = gt_option_parser_new("(-invert|-sort|-revsort|-shuffle) encseq",
"Output sequences as MultiFasta in specified "
"order.");
/* -invert */
invert_option = gt_option_new_bool("invert", "invert order of sequences",
&arguments->invert, false);
gt_option_parser_add_option(op, invert_option);
/* -sort */
sort_option = gt_option_new_bool("sort", "sort sequences lexicographically",
&arguments->sort, false);
gt_option_exclude(sort_option, invert_option);
gt_option_parser_add_option(op, sort_option);
/* -revsort */
revsort_option = gt_option_new_bool("revsort", "sort sequences in reverse "
"lexicographic order", &arguments->revsort, false);
gt_option_exclude(revsort_option, invert_option);
gt_option_exclude(revsort_option, sort_option);
gt_option_parser_add_option(op, revsort_option);
/* -shuffle */
shuffle_option = gt_option_new_bool("shuffle", "shuffle sequences "
"pseudo-randomly", &arguments->shuffle, false);
gt_option_exclude(shuffle_option, invert_option);
gt_option_exclude(shuffle_option, sort_option);
gt_option_exclude(shuffle_option, revsort_option);
gt_option_parser_add_option(op, shuffle_option);
gt_option_parser_set_min_max_args(op, 1U, 1U);
return op;
}
static GtOPrval parse_options(int *parsed_args, ChseqidsArguments *arguments,
int argc, const char **argv, GtError *err)
{
GtOptionParser *op;
GtOutputFileInfo *ofi;
GtOption *option;
GtOPrval oprval;
gt_error_check(err);
/* init */
op = gt_option_parser_new("[option ...] mapping_file [GFF3_file]",
"Change sequence ids by the mapping given in "
"mapping_file.");
ofi = gt_outputfileinfo_new();
/* -sort */
option = gt_option_new_bool("sort",
"sort the GFF3 features after changing the "
"sequence ids\n(memory consumption is "
"proportional to the input file size)",
&arguments->sort, false);
gt_option_parser_add_option(op, option);
/* -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, ofi);
/* parse options */
gt_option_parser_set_comment_func(op, gt_gtdata_show_help, NULL);
gt_option_parser_set_min_max_args(op, 1, 2);
oprval = gt_option_parser_parse(op, parsed_args, argc, argv, gt_versionfunc,
err);
/* free */
gt_outputfileinfo_delete(ofi);
gt_option_parser_delete(op);
return oprval;
}
static GtOptionParser* gt_splitfasta_option_parser_new(void *tool_arguments)
{
SplitfastaArguments *arguments = tool_arguments;
GtOptionParser *op;
GtOption *targetsize_option, *splitdesc_option, *o, *numfiles_option;
gt_assert(arguments);
op = gt_option_parser_new("[option ...] fastafile","Split the supplied fasta "
"file.");
numfiles_option = gt_option_new_uint_min("numfiles",
"set the number of target files "
"",
&arguments->num_files, 0,
1);
gt_option_parser_add_option(op, numfiles_option);
targetsize_option = gt_option_new_ulong_min("targetsize",
"set the target file "
"size in MB",
&arguments->max_filesize_in_MB,
50, 1);
gt_option_parser_add_option(op, targetsize_option);
splitdesc_option = gt_option_new_string("splitdesc",
"put every fasta entry in "
"a separate file named by its "
"description in the given directory",
arguments->splitdesc, NULL);
gt_option_parser_add_option(op, splitdesc_option);
gt_option_exclude(targetsize_option, splitdesc_option);
gt_option_exclude(numfiles_option, splitdesc_option);
gt_option_exclude(numfiles_option, targetsize_option);
o = gt_option_new_width(&arguments->width);
gt_option_parser_add_option(op, o);
o = gt_option_new_bool(GT_FORCE_OPT_CSTR, "force writing to output file",
&arguments->force, false);
gt_option_parser_add_option(op, o);
gt_option_parser_set_min_max_args(op, 1, 1);
return op;
}
static GtOptionParser* gt_encseq_info_option_parser_new(void *tool_arguments)
{
GtEncseqInfoArguments *arguments = tool_arguments;
GtOptionParser *op;
GtOption *option, *optionnomap;
gt_assert(arguments);
/* init */
op = gt_option_parser_new("[option ...] indexname",
"Display meta-information about an "
"encoded sequence.");
optionnomap = gt_option_new_bool("nomap", "do not map encoded sequence "
"(gives less information)",
&arguments->nomap, false);
gt_option_parser_add_option(op, optionnomap);
option = gt_option_new_bool("mirrored", "use mirrored encoded sequence "
"(DNA only)",
&arguments->mirror, false);
gt_option_parser_add_option(op, option);
gt_option_exclude(optionnomap, option);
option = gt_option_new_bool("noindexname", "do not output index name",
&arguments->noindexname, false);
gt_option_parser_add_option(op, option);
option = gt_option_new_bool("show_alphabet", "output alphabet definition",
&arguments->show_alphabet, false);
gt_option_parser_add_option(op, option);
/* output file options */
gt_output_file_info_register_options(arguments->ofi, op, &arguments->outfp);
gt_option_parser_set_min_max_args(op, 1, 1);
return op;
}
static GtOptionParser* gt_extracttarget_option_parser_new(void *tool_arguments)
{
ExtractTargetArguments *arguments = tool_arguments;
GtOptionParser *op;
GtOption *o;
gt_assert(arguments);
/* init */
op = gt_option_parser_new("[option ...] -seqfile sequence_file GFF3_file",
"Extract target sequences given in GFF3_file from "
"sequence_file.");
/* -seqfile */
o = gt_option_new_filenamearray("seqfiles",
"set the sequence file from which "
"to extract the features",
arguments->seqfiles);
gt_option_is_mandatory(o);
gt_option_parser_add_option(op, o);
gt_option_parser_set_min_max_args(op, 1, 1);
return op;
}
static GtOptionParser* gt_sketch_page_option_parser_new(void *tool_arguments)
{
SketchPageArguments *arguments = tool_arguments;
GtOptionParser *op;
static const char *formats[] = {
#ifdef CAIRO_HAS_PDF_SURFACE
"pdf",
#endif
#ifdef CAIRO_HAS_PS_SURFACE
"ps",
#endif
NULL
};
GtOption *o;
op = gt_option_parser_new("outfile annotationfile",
"Draw a multi-page PDF/PS representation of "
"an annotation file.");
o = gt_option_new_string("seqid", "sequence region to draw\n"
"default: first in file",
arguments->seqid, NULL);
gt_option_parser_add_option(op, o);
gt_option_hide_default(o);
o = gt_option_new_string("text", "text to show in header\n"
"default: file name",
arguments->text, NULL);
gt_option_parser_add_option(op, o);
gt_option_hide_default(o);
o = gt_option_new_double("fontsize", "header and footer font size "
"(in points)",
&arguments->theight, 10.0);
gt_option_parser_add_option(op, o);
o = gt_option_new_range("range", "range to draw (e.g. 100 10000)\n"
"default: full range",
&arguments->range, NULL);
gt_option_parser_add_option(op, o);
gt_option_hide_default(o);
o = gt_option_new_ulong_min("linewidth", "base width of a single "
"repeated unit",
&arguments->width, 2000, 1000);
gt_option_is_mandatory(o);
gt_option_parser_add_option(op, o);
o = gt_option_new_double("width", "page width in millimeters "
"(default: DIN A4)",
&arguments->pwidth, 210.0);
gt_option_parser_add_option(op, o);
o = gt_option_new_double("height", "page height in millimeters "
"(default: DIN A4)",
&arguments->pheight, 297.0);
gt_option_parser_add_option(op, o);
o = gt_option_new_choice("format", "output format\n"
"choose from: "
#ifdef CAIRO_HAS_PDF_SURFACE
"pdf"
#ifdef CAIRO_HAS_PS_SURFACE
"|"
#endif
#endif
#ifdef CAIRO_HAS_PS_SURFACE
"ps"
#endif
"",
arguments->format, formats[0], formats );
gt_option_parser_add_option(op, o);
o = gt_option_new_string("style", "style file to use\n"
"default: gtdata/sketch/default.style",
arguments->stylefile,
gt_str_get(arguments->stylefile));
gt_option_parser_add_option(op, o);
gt_option_hide_default(o);
o = gt_option_new_filename("seqfile", "sequence file for GC content view",
arguments->seqfile);
gt_option_parser_add_option(op, o);
gt_option_is_extended_option(o);
gt_option_parser_set_min_max_args(op, 2, 2);
return op;
}
static GtOPrval
parseChkBWTOptions(int *parsed_args, int argc, const char **argv,
struct chkSearchOptions *params, const GtStr *projectName,
GtError *err)
{
GtOptionParser *op;
GtOPrval oprval;
GtOption *option, *optionProgress;
bool checkSuffixArrayValues, tryContextRetrieve, tryFullRegen;
gt_error_check(err);
op = gt_option_parser_new("indexname",
"Load (or build if necessary) BWT index for project"
" <indexname> and perform verification of search"
" results.");
gt_registerPackedIndexOptions(op, ¶ms->idx, BWTDEFOPT_MULTI_QUERY,
projectName);
option = gt_option_new_long("minpatlen",
"minimum length of patterns searched for, -1 "
"implies automatic choice based on index "
"properties", ¶ms->minPatLen, -1);
gt_option_parser_add_option(op, option);
option = gt_option_new_long("maxpatlen",
"maximum length of patterns searched for, -1 "
"implies automatic choice based on index "
"properties", ¶ms->maxPatLen, -1);
gt_option_parser_add_option(op, option);
option = gt_option_new_ulong("nsamples",
"number of sequences to search for",
¶ms->numOfSamples, 1000);
gt_option_parser_add_option(op, option);
option = gt_option_new_bool("chksfxarray",
"verify integrity of stored suffix array positions",
&checkSuffixArrayValues, false);
gt_option_parser_add_option(op, option);
option = gt_option_new_bool("full-lfmap",
"verify complete backwards regeneration of "
"original sequence", &tryFullRegen, false);
gt_option_parser_add_option(op, option);
option = gt_option_new_bool("chkcontext",
"verify integrity of regenerated sequence context",
&tryContextRetrieve, false);
gt_option_parser_add_option(op, option);
optionProgress = gt_option_new_ulong("ticks",
"print dot after this many symbols "
"tested okay", ¶ms->progressInterval,
DEFAULT_PROGRESS_INTERVAL);
gt_option_parser_add_option(op, optionProgress);
option = gt_option_new_bool("v",
"print verbose progress information",
¶ms->verboseOutput,
false);
gt_option_parser_add_option(op, option);
gt_option_parser_set_min_max_args(op, 1, 1);
oprval = gt_option_parser_parse(op, parsed_args, argc, argv, gt_versionfunc,
err);
/* condense boolean options to flags field */
params->flags = (checkSuffixArrayValues?VERIFY_BWTSEQ_SUFVAL:0)
| (tryFullRegen?VERIFY_BWTSEQ_LFMAPWALK:0)
| (tryContextRetrieve?VERIFY_BWTSEQ_CONTEXT:0);
/* compute parameters currently not set from command-line or
* determined indirectly */
gt_computePackedIndexDefaults(¶ms->idx, BWTBaseFeatures);
gt_option_parser_delete(op);
return oprval;
}
static GtOPrval parse_options(int *parsed_args,
bool doesa,
Suffixeratoroptions *so,
int argc, const char **argv, GtError *err)
{
GtOptionParser *op;
GtOption *option,
*optionshowprogress,
*optiongenomediff,
*optionii;
GtOPrval oprval;
gt_error_check(err);
op = gt_option_parser_new("[option ...] (-db file [...] | -ii index)",
doesa ? "Compute enhanced suffix array."
: "Compute packed index.");
gt_option_parser_set_mail_address(op, "<*****@*****.**>");
/* input info */
so->indexname = gt_str_new();
so->inputindex = gt_str_new();
so->db = gt_str_array_new();
/* register options for encoded sequence handling */
so->encopts = gt_encseq_options_register_encoding(op, so->indexname, so->db);
so->loadopts = gt_encseq_options_register_loading(op, so->indexname);
/* register options for index handling */
if (doesa)
so->idxopts = gt_index_options_register_esa(op, so->encopts);
else
so->idxopts = gt_index_options_register_packedidx(op, so->indexname,
so->encopts);
/* verbosity */
option = gt_option_new_verbose(&so->beverbose);
gt_option_parser_add_option(op, option);
optionshowprogress = gt_option_new_bool("showprogress",
"show a progress bar",
&so->showprogress,
false);
gt_option_parser_add_option(op, optionshowprogress);
optionii = gt_option_new_filename("ii", "specify existing encoded sequence",
so->inputindex);
gt_option_parser_add_option(op, optionii);
gt_option_is_mandatory_either(gt_encseq_options_db_option(so->encopts),
optionii);
gt_option_exclude(gt_encseq_options_db_option(so->encopts), optionii);
gt_option_exclude(optionii, gt_encseq_options_smap_option(so->encopts));
gt_option_exclude(optionii, gt_encseq_options_dna_option(so->encopts));
gt_option_exclude(optionii, gt_encseq_options_protein_option(so->encopts));
gt_option_exclude(optionii, gt_encseq_options_plain_option(so->encopts));
gt_option_exclude(optionii, gt_encseq_options_sat_option(so->encopts));
optiongenomediff = gt_option_new_bool("genomediff",
"directly process the lcp intervals using "
"the genomediff algorithm (suffix array and "
"lcp-tables are not output)",
&so->genomediff,
false);
gt_option_is_extended_option(optiongenomediff);
if (gt_index_options_outsuftab_option(so->idxopts) != NULL) {
gt_option_exclude(optiongenomediff,
gt_index_options_outsuftab_option(so->idxopts));
}
gt_option_parser_add_option(op, optiongenomediff);
/* suffixerator and friends do not take arguments */
gt_option_parser_set_min_max_args(op, 0U, 0U);
oprval = gt_option_parser_parse(op, parsed_args, argc, argv, gt_versionfunc,
err);
if (gt_str_length(so->indexname) == 0UL) {
/* we do not have an indexname yet, so there was none given in the
-indexname option and it could not be derived from the input filenames.
So it must be in the -ii parameter. */
char *basenameptr;
basenameptr = gt_basename(gt_str_get(so->inputindex));
gt_str_set(so->indexname, basenameptr);
gt_free(basenameptr);
}
gt_option_parser_delete(op);
return oprval;
}
static GtOptionParser* gt_ltrdigest_option_parser_new(void *tool_arguments)
{
GtLTRdigestOptions *arguments = tool_arguments;
GtOptionParser *op;
GtOption *o, *ot, *oto;
#ifdef HAVE_HMMER
GtOption *oh, *oc, *oeval;
static const char *cutoffs[] = {"NONE", "GA", "TC", NULL};
#endif
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 indexname",
"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_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_opts.ppt_len,
&pptlen_defaults);
gt_option_parser_add_option(op, o);
o = gt_option_new_range("uboxlen",
"required U-box length range",
&arguments->ppt_opts.ubox_len,
&uboxlen_defaults);
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_opts.radius,
30U);
gt_option_parser_add_option(op, o);
o = gt_option_new_probability("pptrprob",
"purine emission probability inside PPT",
&arguments->ppt_opts.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_opts.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->ppt_opts.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->ppt_opts.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->ppt_opts.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->ppt_opts.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->ppt_opts.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->pbs_opts.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->pbs_opts.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->pbs_opts.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->pbs_opts.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_opts.radius,
30U);
gt_option_parser_add_option(op, o);
gt_option_imply(o, ot);
/* Protein domain search options */
#ifdef HAVE_HMMER
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->pdom_opts.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->pdom_opts.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->pdom_opts.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->pdom_opts.write_aaseqs,
false);
gt_option_parser_add_option(op, o);
gt_option_imply(o, oh);
gt_option_imply(o, oto);
o = gt_option_new_uint("maxgaplen",
"maximal allowed gap size between fragments (in amino "
"acids) when chaining pHMM hits for a protein domain",
&arguments->pdom_opts.chain_max_gap_length,
50);
gt_option_parser_add_option(op, o);
gt_option_is_extended_option(o);
gt_option_imply(o, oh);
o = gt_option_new_ulong("threads",
"DEPRECATED, only included for compatibility reasons!"
" Use the -j parameter of the 'gt' call instead.",
&arguments->nthreads,
0);
gt_option_parser_add_option(op, o);
gt_option_is_extended_option(o);
#endif
/* Extended PBS options */
o = gt_option_new_int("pbsmatchscore",
"match score for PBS/tRNA alignments",
&arguments->pbs_opts.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->pbs_opts.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->pbs_opts.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->pbs_opts.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_outputfile_register_options(op, &arguments->outfp, arguments->ofi);
gt_option_parser_set_min_max_args(op, 2U, 2U);
return op;
}
static GtOptionParser* gt_encseq_decode_option_parser_new(void *tool_arguments)
{
GtOptionParser *op;
GtOption *option,
*optionsep,
*optionseq,
*optionseqrange,
*optionmode;
GtEncseqDecodeArguments *arguments =
(GtEncseqDecodeArguments*) tool_arguments;
static const char *modes[] = {"fasta", "concat", NULL};
/* init */
op = gt_option_parser_new("(sequence_file|indexname)",
"Decode/extract encoded sequences.");
/* encseq options */
arguments->eopts = gt_encseq_options_register_loading(op, NULL);
gt_encseq_options_add_readmode_option(op, arguments->dir);
/* -singlechars */
option = gt_option_new_bool("singlechars",
"do not use a GtEncseqReader but access each "
"sequence character separately",
&arguments->singlechars,
false);
gt_option_is_extended_option(option);
gt_option_parser_add_option(op, option);
/* -seq */
optionseq = gt_option_new_uword("seq",
"extract sequence identified by its number",
&arguments->seq,
GT_UNDEF_UWORD);
gt_option_parser_add_option(op, optionseq);
/* -seqrange */
optionseqrange = gt_option_new_range("seqrange",
"extract multiple consecutive sequences",
&arguments->seqrng,
NULL);
gt_option_parser_add_option(op, optionseqrange);
gt_option_exclude(optionseqrange, optionseq);
/* -output */
optionmode = gt_option_new_choice("output",
"specify output format "
"(choose from fasta|concat)",
arguments->mode,
modes[0],
modes);
gt_option_parser_add_option(op, optionmode);
/* -range */
option = gt_option_new_range("range",
"concatenated range to extract "
"(implies '-output concat')",
&arguments->rng,
NULL);
gt_option_parser_add_option(op, option);
gt_option_imply(option, optionmode);
/* -sepchar */
optionsep = gt_option_new_string("sepchar",
"specify character to print as SEPARATOR",
arguments->sepchar, "|");
gt_option_parser_add_option(op, optionsep);
gt_option_imply(optionsep, optionmode);
gt_option_parser_set_min_max_args(op, 1, 1);
return op;
}
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;
}
