static GtOPrval parse_options(GtStr *indexname,GtStrArray *indexnametab,
int *parsed_args, int argc,
const char **argv, GtError *err)
{
GtOptionParser *op;
GtOPrval oprval;
GtOption *option;
gt_error_check(err);
op = gt_option_parser_new("storeindex <mkvindex1> <mkvindex2> ...",
"Merge indexes into one index.");
gt_option_parser_set_mail_address(op,"<*****@*****.**>");
option = gt_option_new_filename_array("ii",
"specify input index files (mandatory)",
indexnametab);
gt_option_is_mandatory(option);
gt_option_parser_add_option(op, option);
option = gt_option_new_string("indexname",
"specify index to be created",
indexname, NULL);
gt_option_is_mandatory(option);
gt_option_parser_add_option(op, option);
oprval = gt_option_parser_parse(op, parsed_args, argc, argv, gt_versionfunc,
err);
gt_option_parser_delete(op);
return oprval;
}
static GtOptionParser* gt_interfeat_option_parser_new(void *tool_arguments)
{
InterFeatArguments *arguments = tool_arguments;
GtOptionParser *op;
GtOption *option;
gt_assert(arguments);
/* init */
op = gt_option_parser_new("[option ...] [GFF3_file ...]", "Duplicate "
"internal feature nodes in given GFF3 files.");
/* -outside */
option = gt_option_new_string("dest", "set destination type",
arguments->dest_type, NULL);
gt_option_is_mandatory(option);
gt_option_parser_add_option(op, option);
/* -inter */
option = gt_option_new_string("source", "set source type",
arguments->source_type, NULL);
gt_option_is_mandatory(option);
gt_option_parser_add_option(op, option);
/* output file options */
gt_output_file_info_register_options(arguments->ofi, op, &arguments->outfp);
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_extractfeat_option_parser_new(void *tool_arguments)
{
GtExtractFeatArguments *arguments = tool_arguments;
GtOptionParser *op;
GtOption *option;
gt_assert(arguments);
op = gt_option_parser_new("[option ...] [GFF3_file]",
"Extract features given in GFF3 file from "
"sequence file.");
/* -type */
option = gt_option_new_string("type", "set type of features to extract",
arguments->type, NULL);
gt_option_is_mandatory(option);
gt_option_parser_add_option(op, option);
/* -join */
option = gt_option_new_bool("join", "join feature sequences in the same "
"subgraph into a single one", &arguments->join,
false);
gt_option_parser_add_option(op, option);
/* -translate */
option = gt_option_new_bool("translate", "translate the features (of a DNA "
"sequence) into protein", &arguments->translate,
false);
gt_option_parser_add_option(op, option);
/* -seqid */
option = gt_option_new_bool("seqid", "add sequence ID of extracted features "
"to FASTA descriptions", &arguments->seqid,
false);
gt_option_parser_add_option(op, option);
/* -target */
option = gt_option_new_bool("target", "add target ID(s) of extracted "
"features to FASTA descriptions",
&arguments->target, false);
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);
/* -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);
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_readjoiner_cnttest_option_parser_new(
void *tool_arguments)
{
GtReadjoinerCnttestArguments *arguments = tool_arguments;
GtOptionParser *op;
GtOption *option;
gt_assert(arguments);
/* init */
op = gt_option_parser_new("-readset [option ...]",
"Test/development tool for readjoiner containments filtering.");
/* -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);
/* -test */
option = gt_option_new_string("test",
"select among the available tests:\n"
"showlist: show content of an cnt list (input: cntlist)\n"
"bruteforce: memcmp reads vs all suffixes and prefixes (input: encseq)\n"
"kmp: variant of Knuth-Morris-Pratt (input: encseq)\n"
"esa: own esa-based algorithm (input: esa)",
arguments->teststr, NULL);
gt_option_parser_add_option(op, option);
gt_option_is_mandatory(option);
/* -singlestrand */
option = gt_option_new_bool("singlestrand", "do not use reads "
"reverse complements", &arguments->singlestrand, false);
gt_option_parser_add_option(op, option);
/* -v */
option = gt_option_new_verbose(&arguments->verbose);
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_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_speck_option_parser_new(void *tool_arguments)
{
GtOptionParser *op;
GtOption *option;
SpeccheckArguments *arguments = tool_arguments;
/* init */
op = gt_option_parser_new("[options] [GFF3_file ...]",
"Checks spec definition compliance in GFF3 input.");
option = gt_option_new_filename("specfile",
"file with specification definition",
arguments->specfile);
gt_option_parser_add_option(op, option);
gt_option_is_mandatory(option);
option = gt_option_new_bool("colored", "show colored output",
&arguments->colored, true);
gt_option_parser_add_option(op, option);
option = gt_option_new_bool("provideindex", "provide feature index in "
"specfile namespace (requires O(n) memory for n "
"input features)",
&arguments->provideindex, false);
gt_option_parser_add_option(op, option);
option = gt_option_new_bool("sort", "sort input before checking (requires "
"O(n) memory for n input features)",
&arguments->sort, false);
gt_option_parser_add_option(op, option);
option = gt_option_new_bool("failhard", "stop processing and report runtime "
"errors instead of recording them in the results",
&arguments->fail_hard, false);
gt_option_parser_add_option(op, option);
/* -format */
option = gt_option_new_string("output", "output format\n"
"choose from: json, text, html, statsonly",
arguments->format, "text");
gt_option_parser_add_option(op, option);
gt_typecheck_info_register_options_with_default(arguments->tci, op, "so");
gt_seqid2file_register_options_ext(op, arguments->s2fi, false, false);
gt_output_file_info_register_options(arguments->ofi, op, &arguments->outfp);
option = gt_option_new_verbose(&arguments->verbose);
gt_option_parser_add_option(op, option);
return op;
}
static GtOptionParser*
gt_condenseq_hmmsearch_option_parser_new(void *tool_arguments)
{
GtCondenseqHmmsearchArguments *arguments = tool_arguments;
GtOptionParser *op;
GtOption *option;
gt_assert(arguments);
/* init */
op = gt_option_parser_new("[option ...] -db DATABASE -hmm HMMPROFILE",
"Perform a hmmsearch on the given compressed "
"database.");
/* -db and -verbose */
gt_condenseq_search_register_options(arguments->csa, op);
/* -hmm */
option = gt_option_new_string("hmm", "hmm query", arguments->hmm, NULL);
gt_option_is_mandatory(option);
gt_option_parser_add_option(op, option);
/* -hmmsearch */
option = gt_option_new_string("hmmsearch", "path to hmmsearch, please set if "
"not installed at (linux) default location",
arguments->hmmsearch_path,
"/usr/bin/hmmsearch");
gt_option_parser_add_option(op, option);
/* -tblout */
option = gt_option_new_string("tblout", "file basename to output tabular "
"hmmsearch output to (like hmmer option "
"--tblout). Depending on -max_queries will "
"produce multiple numbered files.",
arguments->outtable_filename, NULL);
gt_option_parser_add_option(op, option);
/* -force_ow */
option = gt_option_new_bool("force_ow", "force overwrite of existing files",
&arguments->force_ow, false);
gt_option_parser_add_option(op, option);
/* -max_queries */
option = gt_option_new_uint("max_queries", "maximum number of queries per "
"fine search, influences file-size and therefore "
"speed!, 0 disables splitting",
&arguments->max_queries, 5U);
gt_option_parser_add_option(op, option);
return op;
}
static GtOptionParser* gt_speck_option_parser_new(void *tool_arguments)
{
GtOptionParser *op;
GtOption *option;
SpeccheckArguments *arguments = tool_arguments;
/* init */
op = gt_option_parser_new("[options] [GFF3_file ...]",
"Checks spec definition compliance in GFF3 input.");
option = gt_option_new_filename("specfile",
"file with specification definition",
arguments->specfile);
gt_option_parser_add_option(op, option);
gt_option_is_mandatory(option);
option = gt_option_new_bool("colored", "show colored output",
&arguments->colored, true);
gt_option_parser_add_option(op, option);
option = gt_option_new_bool("allexpects", "show results counted by "
"expectations instead of by nodes",
&arguments->allexpects, false);
gt_option_parser_add_option(op, option);
option = gt_option_new_bool("provideindex", "provide feature index in "
"specfile namespace (requires O(n) memory for n "
"input features)",
&arguments->provideindex, false);
gt_option_parser_add_option(op, option);
option = gt_option_new_bool("sort", "sort input before checking (requires "
"O(n) memory for n input features)",
&arguments->sort, false);
gt_option_parser_add_option(op, option);
option = gt_option_new_bool("failhard", "stop processing and report runtime "
"errors instead of recording them in the results",
&arguments->fail_hard, false);
gt_option_parser_add_option(op, option);
option = gt_option_new_verbose(&arguments->verbose);
gt_option_parser_add_option(op, option);
gt_seqid2file_register_options(op, arguments->s2fi);
gt_output_file_info_register_options(arguments->ofi, op, &arguments->outfp);
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_condenser_extract_option_parser_new(void *tool_arguments)
{
GtCondenserExtractArguments *arguments = tool_arguments;
GtOptionParser *op;
GtOption *option;
gt_assert(arguments);
/* init */
/*TODO soll das nur zu fasta sein oder kann man auch raw sequence
extracten?*/
op = gt_option_parser_new("[option ...] [archive]",
"Decompresses a condenser archive to fasta.");
/* -original */
option = gt_option_new_filename("original",
"uncompressed encseq, needs to be present "
"for development reasons.",
arguments->original);
gt_option_is_mandatory(option);
gt_option_parser_add_option(op, option);
/* -range */
option = gt_option_new_range("range",
"Range of positions to extract"
". If no "
"range is given, whole sequence "
"collection is extracted.",
&arguments->range, NULL);
gt_option_parser_add_option(op, option);
/* -verbose */
option = gt_option_new_bool("verbose", "Print out verbose output to stderr.",
&arguments->verbose, false);
gt_option_parser_add_option(op, option);
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_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_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_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 OPrval parse_options(int *parsed_args,
LTRharvestoptions *lo,
int argc, const char **argv, GtError *err)
{
GtOptionParser *op;
GtOption *optionindex,
*optionltrsearchseqrange,
*optionseed,
*optionminlenltr,
*optionmaxlenltr,
*optionmindistltr,
*optionmaxdistltr,
*optionmintsd,
*optionmaxtsd,
*optionsimilar,
*optionmotif,
*optionmotifmis,
*optionvic,
*optionoverlaps,
*optionxdrop,
*optionmat,
*optionmis,
*optionins,
*optiondel,
*optionv,
*optionoffset,
*optionlongoutput,
*optionout,
*optionoutinner,
*optiongff3;
OPrval oprval;
GtRange default_ltrsearchseqrange = {0,0};
unsigned int vicinityforcorrectboundaries;
static const char *overlaps[] = {
"best", /* the default */
"no",
"all",
NULL
};
gt_error_check(err);
op = gt_option_parser_new("[option ...] -index filenameindex",
"Predict LTR retrotransposons.");
/* -index */
lo->str_indexname = gt_str_new();
optionindex = gt_option_new_string("index",
"specify the name of the enhanced suffix "
"array index (mandatory)",
lo->str_indexname, NULL);
gt_option_is_mandatory(optionindex);
gt_option_parser_add_option(op, optionindex);
/* -range */
optionltrsearchseqrange
= gt_option_new_range("range",
"specify sequence range in which LTRs are searched",
&lo->repeatinfo.ltrsearchseqrange,
&default_ltrsearchseqrange);
gt_option_parser_add_option(op, optionltrsearchseqrange);
/* -seed */
optionseed = gt_option_new_ulong_min("seed",
"specify minimum seed length for"
" exact repeats",
&lo->minseedlength,
30UL,
1UL);
gt_option_parser_add_option(op, optionseed);
/* -minlenltr */
optionminlenltr = gt_option_new_ulong_min_max("minlenltr",
"specify minimum length for each LTR",
&lo->repeatinfo.lmin,
100UL,
1UL,
GT_UNDEF_ULONG);
gt_option_parser_add_option(op, optionminlenltr);
/* -maxlenltr */
optionmaxlenltr = gt_option_new_ulong_min_max("maxlenltr",
"specify maximum length for each LTR",
&lo->repeatinfo.lmax,
1000UL,
1UL,
GT_UNDEF_ULONG);
gt_option_parser_add_option(op, optionmaxlenltr);
/* -mindistltr */
optionmindistltr = gt_option_new_ulong_min_max("mindistltr",
"specify minimum distance of "
"LTR startpositions",
&lo->repeatinfo.dmin,
1000UL,
1UL,
GT_UNDEF_ULONG);
gt_option_parser_add_option(op, optionmindistltr);
/* -maxdistltr */
optionmaxdistltr = gt_option_new_ulong_min_max("maxdistltr",
"specify maximum distance of "
"LTR startpositions",
&lo->repeatinfo.dmax,
15000UL,
1UL,
GT_UNDEF_ULONG);
gt_option_parser_add_option(op, optionmaxdistltr);
/* -similar */
optionsimilar = gt_option_new_double_min_max("similar",
"specify similaritythreshold in "
"range [1..100%]",
&lo->similaritythreshold,
(double) 85.0,
(double) 0.0,
100.0);
gt_option_parser_add_option(op, optionsimilar);
/* -mintsd */
optionmintsd = gt_option_new_uint_min_max("mintsd",
"specify minimum length for each TSD",
&lo->minlengthTSD,
4U,
0,
GT_UNDEF_UINT);
gt_option_parser_add_option(op, optionmintsd);
/* -maxtsd */
optionmaxtsd = gt_option_new_uint_min_max("maxtsd",
"specify maximum length for each TSD",
&lo->maxlengthTSD,
20U,
0,
GT_UNDEF_UINT);
gt_option_parser_add_option(op, optionmaxtsd);
/* -motif */
/* characters will be tranformed later
into characters from virtualtree alphabet */
lo->motif.firstleft = (GtUchar) 't';
lo->motif.secondleft = (GtUchar) 'g';
lo->motif.firstright = (GtUchar) 'c';
lo->motif.secondright = (GtUchar) 'a';
lo->motif.str_motif = gt_str_new();
optionmotif = gt_option_new_string("motif",
"specify 2 nucleotides startmotif + "
"2 nucleotides endmotif: ****",
lo->motif.str_motif, NULL);
gt_option_parser_add_option(op, optionmotif);
/* -motifmis */
optionmotifmis = gt_option_new_uint_min_max("motifmis",
"specify maximum number of "
"mismatches in motif [0,3]",
&lo->motif.allowedmismatches,
4U,
0,
3U);
gt_option_parser_add_option(op, optionmotifmis);
/* -vic */
optionvic = gt_option_new_uint_min_max("vic",
"specify the number of nucleotides (to the left and "
"to the right) that will be searched "
"for TSDs and/or motifs around 5' and 3' boundary "
"of predicted LTR retrotransposons",
&vicinityforcorrectboundaries,
60U,
1U,
500U);
gt_option_parser_add_option(op, optionvic);
/* -overlaps */
lo->str_overlaps = gt_str_new();
optionoverlaps = gt_option_new_choice("overlaps",
"specify no|best|all",
lo->str_overlaps,
overlaps[0],
overlaps);
gt_option_parser_add_option(op, optionoverlaps);
/* -xdrop */
optionxdrop = gt_option_new_int_min("xdrop",
"specify xdropbelowscore for extension-alignment",
&lo->xdropbelowscore,
(int)5,
(int)0);
gt_option_parser_add_option(op, optionxdrop);
/* -mat */
lo->arbitscores.gcd = 1; /* set only for initialization,
do not change! */
optionmat = gt_option_new_int_min("mat",
"specify matchscore for extension-alignment",
&lo->arbitscores.mat,
2,
1);
gt_option_parser_add_option(op, optionmat);
/* -mis */
optionmis = gt_option_new_int_max("mis",
"specify mismatchscore for extension-alignment",
&lo->arbitscores.mis,
-2,
-1);
gt_option_parser_add_option(op, optionmis);
/* -ins */
optionins = gt_option_new_int_max("ins",
"specify insertionscore for extension-alignment",
&lo->arbitscores.ins,
-3,
-1);
gt_option_parser_add_option(op, optionins);
/* -del */
optiondel = gt_option_new_int_max("del",
"specify deletionscore for extension-alignment",
&lo->arbitscores.del,
-3,
-1);
gt_option_parser_add_option(op, optiondel);
/* -v */
optionv = gt_option_new_bool("v",
"verbose mode",
&lo->verbosemode,
false);
gt_option_parser_add_option(op, optionv);
/* -longoutput */
optionlongoutput = gt_option_new_bool("longoutput",
"additional motif/TSD output",
&lo->longoutput,
false);
gt_option_parser_add_option(op, optionlongoutput);
/* -out */
lo->fastaoutput = false; /* by default no FASTA output */
lo->str_fastaoutputfilename = gt_str_new();
optionout = gt_option_new_string("out",
"specify FASTA outputfilename",
lo->str_fastaoutputfilename, NULL);
gt_option_parser_add_option(op, optionout);
/* -outinner */
lo->fastaoutputinnerregion = false;
lo->str_fastaoutputfilenameinnerregion = gt_str_new();
optionoutinner = gt_option_new_string("outinner",
"specify FASTA outputfilename for inner regions",
lo->str_fastaoutputfilenameinnerregion, NULL);
gt_option_parser_add_option(op, optionoutinner);
/* -gff3 */
lo->gff3output = false; /* by default no gff3 output */
lo->str_gff3filename = gt_str_new();
optiongff3 = gt_option_new_string("gff3",
"specify GFF3 outputfilename",
lo->str_gff3filename, NULL);
gt_option_parser_add_option(op, optiongff3);
/* -offset */
optionoffset = gt_option_new_ulong("offset",
"offset added to GFF3 coordinates",
&lo->offset,
0UL);
gt_option_parser_add_option(op, optionoffset);
gt_option_is_extended_option(optionoffset);
/* implications */
gt_option_imply(optionmaxtsd, optionmintsd);
gt_option_imply(optionmotifmis, optionmotif);
gt_option_imply_either_2(optionlongoutput, optionmintsd, optionmotif);
gt_option_parser_refer_to_manual(op);
oprval = gt_option_parser_parse(op, parsed_args, argc, argv, gt_versionfunc,
err);
lo->vicinityforcorrectboundaries = (Seqpos) vicinityforcorrectboundaries;
if (oprval == OPTIONPARSER_OK)
{
if (lo->repeatinfo.lmin > lo->repeatinfo.lmax)
{
gt_error_set(err,"argument of -minlenltr is greater than argument of"
" -maxlenltr");
oprval = OPTIONPARSER_ERROR;
}
if (lo->repeatinfo.dmin > lo->repeatinfo.dmax)
{
gt_error_set(err,
"argument of -mindistltr is greater than argument of -maxdistltr");
oprval = OPTIONPARSER_ERROR;
}
if (lo->repeatinfo.lmax > lo->repeatinfo.dmin)
{
gt_error_set(err,"argument of -maxlenltr is greater than argument of"
" -mindistltr");
oprval = OPTIONPARSER_ERROR;
}
if (lo->minlengthTSD > lo->maxlengthTSD)
{
gt_error_set(err,
"argument of -mintsd is greater than argument of -maxtsd");
oprval = OPTIONPARSER_ERROR;
}
/* If option motif is set,
store characters, transform them later */
if (gt_option_is_set(optionmotif))
{
if (gt_str_length(lo->motif.str_motif) != 4UL)
{
gt_error_set(err,
"argument of -motif has not exactly 4 characters");
oprval = OPTIONPARSER_ERROR;
}
lo->motif.firstleft = (GtUchar) gt_str_get(lo->motif.str_motif)[0];
lo->motif.secondleft = (GtUchar) gt_str_get(lo->motif.str_motif)[1];
lo->motif.firstright = (GtUchar) gt_str_get(lo->motif.str_motif)[2];
lo->motif.secondright = (GtUchar) gt_str_get(lo->motif.str_motif)[3];
/* default if motif specified */
if (!gt_option_is_set(optionmotifmis))
{
lo->motif.allowedmismatches = 0;
}
}
/* If option overlaps is set */
if (gt_option_is_set(optionoverlaps))
{
if (strcmp(gt_str_get(lo->str_overlaps), "no") == 0)
{
lo->bestofoverlap = false;
lo->nooverlapallowed = true;
}
else if (strcmp(gt_str_get(lo->str_overlaps), "best") == 0 )
{
lo->bestofoverlap = true;
lo->nooverlapallowed = false;
}
else if (strcmp(gt_str_get(lo->str_overlaps), "all") == 0 )
{
lo->bestofoverlap = false;
lo->nooverlapallowed = false;
}
else
{
gt_assert(0); /* cannot happen */
}
}
else
{
/* default is "best" */
lo->bestofoverlap = true; /* take best prediction
if overlap occurs, default */
lo->nooverlapallowed = false; /* overlapping predictions (not)allowed*/
}
/* if FASTA output is set */
if (gt_option_is_set(optionout))
{
lo->fastaoutput = true;
}
/* if FASTA output inner region is set */
if (gt_option_is_set(optionoutinner))
{
lo->fastaoutputinnerregion = true;
}
/* if GFF3 output is set */
if (gt_option_is_set(optiongff3))
{
lo->gff3output = true;
}
if (gt_option_is_set(optionltrsearchseqrange))
{
if (lo->repeatinfo.ltrsearchseqrange.start >
lo->repeatinfo.ltrsearchseqrange.end)
{
gt_error_set(err,
"arguments of -range: first arg must be <= than second arg");
oprval = OPTIONPARSER_ERROR;
}
}
}
gt_option_parser_delete(op);
return oprval;
}
static GtOptionParser* gt_tir_option_parser_new(void *tool_arguments)
{
GtTirArguments *arguments = tool_arguments;
GtOptionParser *op;
GtOption *optionindex, /* index */
*optionseed, /* minseedlength */
*optionminlentir, /* minimal length of TIR */
*optionmaxlentir, /* maximal length of TIR */
*optionmindisttir, /* minimal distance of TIRs */
*optionmaxdisttir, /* maximal distance of TIRs */
*optionmat, /* arbitrary scores */
*optionmis,
*optionins,
*optiondel,
*optionxdrop, /* xdropbelowscore for extension alignment */
*optionsimilar, /* similarity threshold */
*optionoverlaps, /* for overlaps */
*optionmintsd, /* minimal length for Target Site Duplication */
*optionmaxtsd, /* maximal length for Target Site Duplication */
*optionvicinity, /* vicinity around TIRs to be searched for TSDs */
*optionhmms,
*optionevalcutoff,
*optionpdomcutoff,
*optionmaxgap;
static const char *overlaps[] = {
"best", /* default */
"no",
"all",
NULL
};
static const char *cutoffs[] = {
"NONE",
"GA",
"TC",
NULL
};
gt_assert(arguments);
/* init */
op = gt_option_parser_new("[option ...] -index INDEXNAME",
"Identify Terminal Inverted Repeat (TIR) elements,"
"such as DNA transposons.");
/* -index */
optionindex = gt_option_new_string("index",
"specify the name of the enhanced suffix "
"array index (mandatory)",
arguments->str_indexname, NULL);
gt_option_is_mandatory(optionindex);
gt_option_parser_add_option(op, optionindex);
/* -seed */
optionseed = gt_option_new_uword_min("seed",
"specify minimum seed length for "
"exact repeats",
&arguments->min_seed_length, 20UL, 2UL);
gt_option_parser_add_option(op, optionseed);
/* -minlentir */
optionminlentir = gt_option_new_uword_min_max("mintirlen",
"specify minimum length for "
"each TIR",
&arguments->min_TIR_length,
27UL, 1UL, GT_UNDEF_UWORD);
gt_option_parser_add_option(op, optionminlentir);
/* -maxlentir */
optionmaxlentir = gt_option_new_uword_min_max("maxtirlen",
"specify maximum length for "
"each TIR",
&arguments->max_TIR_length,
1000UL, 1UL, GT_UNDEF_UWORD);
gt_option_parser_add_option(op, optionmaxlentir);
/* -mindisttir */
optionmindisttir = gt_option_new_uword_min_max("mintirdist",
"specify minimum distance of "
"TIRs",
&arguments->min_TIR_distance,
100UL, 1UL, GT_UNDEF_UWORD);
gt_option_parser_add_option(op, optionmindisttir);
/* -maxdisttir */
optionmaxdisttir = gt_option_new_uword_min_max("maxtirdist",
"specify maximum distance of "
"TIRs",
&arguments->max_TIR_distance,
10000UL, 1UL, GT_UNDEF_UWORD);
gt_option_parser_add_option(op, optionmaxdisttir);
optionmat = gt_option_new_int_min("mat",
"specify matchscore for "
"extension-alignment",
&arguments->arbit_scores.mat, 2, 1);
gt_option_parser_add_option(op, optionmat);
/* -mis */
optionmis = gt_option_new_int_max("mis",
"specify mismatchscore for "
"extension-alignment",
&arguments->arbit_scores.mis, -2, -1);
gt_option_parser_add_option(op, optionmis);
/* -ins */
optionins = gt_option_new_int_max("ins",
"specify insertionscore for "
"extension-alignment",
&arguments->arbit_scores.ins, -3, -1);
gt_option_parser_add_option(op, optionins);
/* -del */
optiondel = gt_option_new_int_max("del",
"specify deletionscore for "
"extension-alignment",
&arguments->arbit_scores.del, -3, -1);
gt_option_parser_add_option(op, optiondel);
/* -xdrop */
optionxdrop = gt_option_new_int_min("xdrop",
"specify xdropbelowscore for "
"extension-alignment",
&arguments->xdrop_belowscore, (int) 5,
(int) 0);
gt_option_parser_add_option(op, optionxdrop);
/* -similar */
optionsimilar = gt_option_new_double_min_max("similar",
"specify similaritythreshold in "
"range [1..100%]",
&arguments->similarity_threshold,
(double) 85.0, (double) 0.0,
100.0);
gt_option_parser_add_option(op, optionsimilar);
/* -overlaps */
optionoverlaps = gt_option_new_choice("overlaps", "specify no|best|all",
arguments->str_overlaps,
overlaps[0], overlaps);
gt_option_parser_add_option(op, optionoverlaps);
arguments->optionoverlaps = gt_option_ref(optionoverlaps);
/* -mintsd */
optionmintsd = gt_option_new_uword_min_max("mintsd",
"specify minimum length for each "
"TSD",
&arguments->min_TSD_length,
2U, 0, GT_UNDEF_UINT);
gt_option_parser_add_option(op, optionmintsd);
/* -maxtsd */
optionmaxtsd = gt_option_new_uword_min_max("maxtsd",
"specify maximum length for each "
"TSD",
&arguments->max_TSD_length,
11U, 0, GT_UNDEF_UINT);
gt_option_parser_add_option(op, optionmaxtsd);
gt_option_imply(optionmaxtsd, optionmintsd);
/* -vicinity */
optionvicinity = gt_option_new_uword_min_max("vic",
"specify the number of "
"nucleotides (to the left and "
"to the right) that will be "
"searched for TSDs around 5' "
"and 3' boundary of predicted "
"TIRs",
&arguments->vicinity,
60U, 1U, 500U);
gt_option_parser_add_option(op, optionvicinity);
optionhmms = gt_option_new_filename_array("hmms",
"profile HMM models for domain detection "
"(separate by spaces, finish with --) in "
"HMMER3 format\n"
"Omit this option to disable pHMM search.",
arguments->hmm_files);
gt_option_parser_add_option(op, optionhmms);
optionevalcutoff = gt_option_new_probability("pdomevalcutoff",
"global E-value cutoff for pHMM search\n"
"default 1E-6",
&arguments->evalue_cutoff,
0.000001);
gt_option_parser_add_option(op, optionevalcutoff);
gt_option_hide_default(optionevalcutoff);
gt_option_imply(optionevalcutoff, optionhmms);
optionpdomcutoff = gt_option_new_choice("pdomcutoff",
"model-specific score cutoff\n"
"choose from TC (trusted cutoff) | "
"GA (gathering cutoff) | "
"NONE (no cutoffs)",
arguments->cutoffs, cutoffs[1], cutoffs);
gt_option_parser_add_option(op, optionpdomcutoff);
gt_option_imply(optionpdomcutoff, optionhmms);
/* XXX: make -pdomcutoff and -pdomevalcutoff mutually exclusive */
optionmaxgap = gt_option_new_uint("maxgaplen",
"maximal allowed gap size between fragments (in amino "
"acids) when chaining pHMM hits for a protein domain",
&arguments->chain_max_gap_length,
50U);
gt_option_parser_add_option(op, optionmaxgap);
gt_option_is_extended_option(optionmaxgap);
gt_option_imply(optionmaxgap, optionhmms);
return op;
}
static GtOPrval parsemkfmindex(Mkfmcallinfo *mkfmcallinfo,
int argc,
const char **argv,
GtError *err)
{
GtOptionParser *op;
GtOption *option, *optionfmout;
GtOPrval oprval;
int parsed_args;
gt_error_check(err);
mkfmcallinfo->indexnametab = gt_str_array_new();
mkfmcallinfo->outfmindex = gt_str_new();
mkfmcallinfo->leveldesc = gt_str_new();
op = gt_option_parser_new("[option ...] -ii indexfile [...]",
"Compute FM-index.");
gt_option_parser_set_mail_address(op, "<*****@*****.**>");
optionfmout = gt_option_new_string("fmout",
"specify name of FM-index to be generated\n"
"(mandatory if more than one input index "
"is specified)",
mkfmcallinfo->outfmindex, NULL);
gt_option_parser_add_option(op, optionfmout);
option = gt_option_new_filename_array("ii", "specify indices to be used",
mkfmcallinfo->indexnametab);
gt_option_is_mandatory(option);
gt_option_parser_add_option(op, option);
option = gt_option_new_string("size",
"specify size (tiny, small, medium, big)",
mkfmcallinfo->leveldesc, "medium");
gt_option_parser_add_option(op, option);
option = gt_option_new_bool("noindexpos",
"store no index positions (hence the positions of\n"
"matches in the index cannot be retrieved)",
&mkfmcallinfo->noindexpos,false);
gt_option_parser_add_option(op, option);
oprval = gt_option_parser_parse(op, &parsed_args, argc, argv, gt_versionfunc,
err);
if (oprval == GT_OPTION_PARSER_OK)
{
if (!gt_option_is_set(optionfmout))
{
if (gt_str_array_size(mkfmcallinfo->indexnametab) > 1UL)
{
gt_error_set(err,"if more than one index is given, then "
"option -fmout is mandatory");
oprval = GT_OPTION_PARSER_ERROR;
} else
{
char *basenameptr;
basenameptr = gt_basename(gt_str_array_get(mkfmcallinfo->indexnametab,
0));
gt_str_set(mkfmcallinfo->outfmindex,basenameptr);
gt_free(basenameptr);
}
}
}
gt_option_parser_delete(op);
if (oprval == GT_OPTION_PARSER_OK && parsed_args != argc)
{
gt_error_set(err,"superfluous program parameters");
oprval = GT_OPTION_PARSER_ERROR;
}
return oprval;
}
static GtOptionParser* gt_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_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 GtOptionParser *gt_tyr_occratio_option_parser_new(void *tool_arguments)
{
GtOptionParser *op;
GtOption *optionmersizes, *optionesa, *optionminmersize, *optionmaxmersize,
*optionstep, *optionoutput, *option;
Tyr_occratio_options *arguments = tool_arguments;
op = gt_option_parser_new("[options] -esa suffixerator-index [options]",
"Compute occurrence ratio for a set of sequences "
"represented by an enhanced suffix array.");
gt_option_parser_set_mailaddress(op,"<*****@*****.**>");
optionesa = gt_option_new_string("esa","specify suffixerator-index\n"
"(mandatory option)",
arguments->str_inputindex,
NULL);
gt_option_is_mandatory(optionesa);
gt_option_parser_add_option(op, optionesa);
optionminmersize
= gt_option_new_ulong_min("minmersize",
"specify minimum mer size for which "
"to compute the occurrence distribution",
&arguments->minmersize,0,1UL);
gt_option_parser_add_option(op, optionminmersize);
optionmaxmersize
= gt_option_new_ulong_min("maxmersize",
"specify maximum mer size for which "
"to compute the occurrence distribution",
&arguments->maxmersize,0,1UL);
gt_option_parser_add_option(op, optionmaxmersize);
optionstep
= gt_option_new_ulong_min("step",
"specify step size when specifying mer sizes",
&arguments->stepmersize,1UL,1UL);
gt_option_parser_add_option(op, optionstep);
optionmersizes = gt_option_new_stringarray(
"mersizes",
"specify mer sizes as non-empty sequence of "
"non decreasing positive integers",
arguments->mersizesstrings);
arguments->refoptionmersizes = gt_option_ref(optionmersizes);
gt_option_parser_add_option(op, optionmersizes);
optionoutput = gt_option_new_stringarray(
"output",
"use combination of the following keywords: "
"unique nonunique nonuniquemulti relative total "
"to specify kind of output",
arguments->outputspec);
gt_option_parser_add_option(op, optionoutput);
option = gt_option_new_bool("scan",
"read suffixerator-index sequentially "
"instead of mapping it to memory",
&arguments->scanfile,
false);
gt_option_parser_add_option(op, option);
option = gt_option_new_verbose(&arguments->verbose);
gt_option_parser_add_option(op, option);
gt_option_exclude(optionmersizes,optionminmersize);
gt_option_exclude(optionmersizes,optionmaxmersize);
gt_option_exclude(optionmersizes,optionstep);
return op;
}
static GtOptionParser* gt_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 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_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_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_tir_option_parser_new(void *tool_arguments)
{
GtTirArguments *arguments = tool_arguments;
GtOptionParser *op;
GtOption *optionindex, /* index */
*optionseed, /* minseedlength */
*optionminlentir, /* minimal length of TIR */
*optionmaxlentir, /* maximal length of TIR */
*optionmindisttir, /* minimal distance of TIRs */
*optionmaxdisttir, /* maximal distance of TIRs */
*optionmat, /* arbitrary scores */
*optionmis,
*optionins,
*optiondel,
*optionxdrop, /* xdropbelowscore for extension alignment */
*optionsimilar, /* similarity threshold */
*optionoverlaps, /* for overlaps */
*optionmintsd, /* minimal length for Target Site Duplication */
*optionmaxtsd, /* maximal length for Target Site Duplication */
*optionvicinity; /* vicinity around TIRs to be searched for TSDs */
static const char *overlaps[] = {
"best", /* default */
"no",
"all",
NULL
};
gt_assert(arguments);
/* init */
op = gt_option_parser_new("[option ...] -index INDEXNAME",
"Identify Terminal Inverted Repeat (TIR) elements,"
"such as DNA transposons.");
/* -index */
optionindex = gt_option_new_string("index",
"specify the name of the enhanced suffix "
"array index (mandatory)",
arguments->str_indexname, NULL);
gt_option_is_mandatory(optionindex);
gt_option_parser_add_option(op, optionindex);
/* -seed */
optionseed = gt_option_new_ulong_min("seed",
"specify minimum seed length for "
"exact repeats",
&arguments->min_seed_length, 20UL, 2UL);
gt_option_parser_add_option(op, optionseed);
/* -minlentir */
optionminlentir = gt_option_new_ulong_min_max("mintirlen",
"specify minimum length for "
"each TIR",
&arguments->min_TIR_length,
27UL, 1UL, GT_UNDEF_ULONG);
gt_option_parser_add_option(op, optionminlentir);
/* -maxlentir */
optionmaxlentir = gt_option_new_ulong_min_max("maxtirlen",
"specify maximum length for "
"each TIR",
&arguments->max_TIR_length,
1000UL, 1UL, GT_UNDEF_ULONG);
gt_option_parser_add_option(op, optionmaxlentir);
/* -mindisttir */
optionmindisttir = gt_option_new_ulong_min_max("mintirdist",
"specify minimum distance of "
"TIRs",
&arguments->min_TIR_distance,
100UL, 1UL, GT_UNDEF_ULONG);
gt_option_parser_add_option(op, optionmindisttir);
/* -maxdisttir */
optionmaxdisttir = gt_option_new_ulong_min_max("maxtirdist",
"specify maximum distance of "
"TIRs",
&arguments->max_TIR_distance,
10000UL, 1UL, GT_UNDEF_ULONG);
gt_option_parser_add_option(op, optionmaxdisttir);
optionmat = gt_option_new_int_min("mat",
"specify matchscore for "
"extension-alignment",
&arguments->arbit_scores.mat, 2, 1);
gt_option_parser_add_option(op, optionmat);
/* -mis */
optionmis = gt_option_new_int_max("mis",
"specify mismatchscore for "
"extension-alignment",
&arguments->arbit_scores.mis, -2, -1);
gt_option_parser_add_option(op, optionmis);
/* -ins */
optionins = gt_option_new_int_max("ins",
"specify insertionscore for "
"extension-alignment",
&arguments->arbit_scores.ins, -3, -1);
gt_option_parser_add_option(op, optionins);
/* -del */
optiondel = gt_option_new_int_max("del",
"specify deletionscore for "
"extension-alignment",
&arguments->arbit_scores.del, -3, -1);
gt_option_parser_add_option(op, optiondel);
/* -xdrop */
optionxdrop = gt_option_new_int_min("xdrop",
"specify xdropbelowscore for "
"extension-alignment",
&arguments->xdrop_belowscore, (int) 5,
(int) 0);
gt_option_parser_add_option(op, optionxdrop);
/* -similar */
optionsimilar = gt_option_new_double_min_max("similar",
"specify similaritythreshold in "
"range [1..100%]",
&arguments->similarity_threshold,
(double) 85.0, (double) 0.0,
100.0);
gt_option_parser_add_option(op, optionsimilar);
/* -overlaps */
optionoverlaps = gt_option_new_choice("overlaps", "specify no|best|all",
arguments->str_overlaps,
overlaps[0], overlaps);
gt_option_parser_add_option(op, optionoverlaps);
arguments->optionoverlaps = gt_option_ref(optionoverlaps);
/* -mintsd */
optionmintsd = gt_option_new_ulong_min_max("mintsd",
"specify minimum length for each "
"TSD",
&arguments->min_TSD_length,
2U, 0, GT_UNDEF_UINT);
gt_option_parser_add_option(op, optionmintsd);
/* -maxtsd */
optionmaxtsd = gt_option_new_ulong_min_max("maxtsd",
"specify maximum length for each "
"TSD",
&arguments->max_TSD_length,
11U, 0, GT_UNDEF_UINT);
gt_option_parser_add_option(op, optionmaxtsd);
gt_option_imply(optionmaxtsd, optionmintsd);
/* -vicinity */
optionvicinity = gt_option_new_ulong_min_max("vic",
"specify the number of "
"nucleotides (to the left and "
"to the right) that will be "
"searched for TSDs around 5' "
"and 3' boundary of predicted "
"TIRs",
&arguments->vicinity,
60U, 1U, 500U);
gt_option_parser_add_option(op, optionvicinity);
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;
}
