static GtOptionParser* gt_sequniq_option_parser_new(void *tool_arguments) { GtSequniqArguments *arguments = tool_arguments; GtOptionParser *op; GtOption *seqit_option, *verbose_option, *width_option, *rev_option, *nofseqs_option; gt_assert(arguments); op = gt_option_parser_new("[option ...] sequence_file [...] ", "Filter out repeated sequences in given " "sequence files."); /* -seqit */ seqit_option = gt_option_new_bool("seqit", "use sequence iterator", &arguments->seqit, false); gt_option_is_development_option(seqit_option); gt_option_parser_add_option(op, seqit_option); /* -nofseqs */ nofseqs_option = gt_option_new_uword("nofseqs", "number of sequences " "(improves efficiency)\ndefault: unspecified", &arguments->nofseqs, 0); gt_option_is_development_option(nofseqs_option); gt_option_hide_default(nofseqs_option); gt_option_parser_add_option(op, nofseqs_option); /* -rev */ rev_option = gt_option_new_bool("rev", "also filter out sequences whose " "reverse complement is identical to a sequence already output", &arguments->rev, false); gt_option_parser_add_option(op, rev_option); /* -v */ verbose_option = gt_option_new_verbose(&arguments->verbose); gt_option_parser_add_option(op, verbose_option); /* -width */ width_option = gt_option_new_width(&arguments->width); gt_option_parser_add_option(op, width_option); gt_output_file_info_register_options(arguments->ofi, op, &arguments->outfp); /* option implications */ gt_option_imply(verbose_option, seqit_option); gt_option_parser_set_comment_func(op, gt_gtdata_show_help, NULL); gt_option_parser_set_min_args(op, 1U); return op; }
static GtOptionParser* gt_gff3validator_option_parser_new(void *tool_arguments) { GFF3ValidatorArguments *arguments = tool_arguments; GtOptionParser *op; GtOption *option; gt_assert(arguments); /* init */ op = gt_option_parser_new("[option ...] [GFF3_file ...]", "Strictly validate given GFF3 files."); /* typecheck options */ gt_typecheck_info_register_options(arguments->tci, op); /* xrfcheck options */ gt_xrfcheck_info_register_options(arguments->xci, op); /* -strict */ option = gt_option_new_bool("strict", "be very strict during GFF3 parsing " "(stricter than the specification requires)", &arguments->strict, false); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); return op; }
void gt_typecheck_info_register_options(GtTypecheckInfo *tci, GtOptionParser *op) { GtOption *typecheck_option, *built_in_option; gt_assert(tci && op); gt_assert(!tci->typecheck_option); /* can only called once */ /* -typecheck */ typecheck_option = gt_option_new_string("typecheck", "check GFF3 types against \"id\" and " "\"name\" tags in given OBO file and validate parent " "(part-of) relationships.\nIf no argument is given, " "the sofa.obo file from the gtdata/obo_files " "directory is used.\nIf an argument is given, it is " "used as an OBO filename.\nIn the case that such a " "file does not exist '.obo' is added to the argument " "and loading the resulting filename from the " "gtdata/obo_files directory is attempted.", tci->typecheck, NULL); gt_option_argument_is_optional(typecheck_option); gt_option_parser_add_option(op, typecheck_option); tci->typecheck_option = gt_option_ref(typecheck_option); /* -typecheck-built-in */ built_in_option = gt_option_new_bool("typecheck-built-in", "use built-in type checker", &tci->typecheck_built_in, false); gt_option_is_development_option(built_in_option); gt_option_parser_add_option(op, built_in_option); gt_option_exclude(typecheck_option, built_in_option); }
void gt_typecheck_info_register_options_with_default(GtTypecheckInfo *tci, GtOptionParser *op, const char *default_v) { GtOption *typecheck_option, *built_in_option; gt_assert(tci && op); gt_assert(!tci->typecheck_option); /* can only called once */ /* -typecheck */ typecheck_option = gt_option_new_string("typecheck", "use an ontology given in an OBO file " "to validate parent-child relationships.\n" "If no argument is given, " "the sofa.obo file from the gtdata/obo_files " "directory is used.\nIf an argument is given, it is " "used as an OBO filename.\nIn the case that such a " "file does not exist '.obo' is added to the argument " "and loading the resulting filename from the " "gtdata/obo_files directory is attempted.", tci->typecheck, default_v); gt_option_argument_is_optional(typecheck_option); gt_option_parser_add_option(op, typecheck_option); tci->typecheck_option = gt_option_ref(typecheck_option); /* -typecheck-built-in */ built_in_option = gt_option_new_bool("typecheck-built-in", "use built-in type checker", &tci->typecheck_built_in, false); gt_option_is_development_option(built_in_option); gt_option_parser_add_option(op, built_in_option); gt_option_exclude(typecheck_option, built_in_option); }
static GtOptionParser* gt_compreads_decompress_option_parser_new(void *tool_arguments) { GtCsrHcrDecodeArguments *arguments = tool_arguments; GtOptionParser *op; GtOption *option; gt_assert(arguments); /* init */ op = gt_option_parser_new("[option ...] (-file file)", "Decodes a file of compressed reads."); option = gt_option_new_bool("v", "be verbose", &arguments->verbose, false); gt_option_parser_add_option(op, option); option = gt_option_new_bool("descs","enable description decoding", &arguments->descs, false); gt_option_parser_add_option(op, option); option = gt_option_new_string("file", "specify base name of files containing" " HCR.", arguments->file, NULL); gt_option_is_mandatory(option); gt_option_parser_add_option(op, option); option = gt_option_new_string("name", "specify base name for decoded hcr" " (suffix will be \".fastq\")", arguments->name, NULL); gt_option_parser_add_option(op, option); option = gt_option_new_string("smap", "specify file containing alphabet" "description (file must be an .al1 file)." " If \"-smap\" is not set, dna alphabet is" " used.", arguments->smap, NULL); gt_option_parser_add_option(op, option); option = gt_option_new_range("range", "decode multiple consecutive reads." " If range is not specified, the " " entire file will be decoded.", &arguments->rng, NULL); gt_option_parser_add_option(op, option); option = gt_option_new_ulong("benchmark", "decode given number random reads " "and report the time to do this", &arguments->bench, 0); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); gt_option_parser_set_min_max_args(op, 0U, 0U); return op; }
static GtOptionParser* gt_cds_option_parser_new(void *tool_arguments) { CDSArguments *arguments = tool_arguments; GtOptionParser *op; GtOption *option; gt_assert(arguments); op = gt_option_parser_new("[option ...] [GFF3_file]", "Add CDS (coding sequence) features to exon " "features given in GFF3 file."); /* -minorflen */ option = gt_option_new_uint_min("minorflen", "set the minimum length an open " "reading frame (ORF) must have to be added " "as a CDS feature (measured in amino acids)", &arguments->minorflen, 64, 1); gt_option_parser_add_option(op, option); /* -startcodon */ option = gt_option_new_bool("startcodon", "require than an ORF must begin " "with a start codon", &arguments->start_codon, false); gt_option_parser_add_option(op, option); /* -finalstopcodon */ option = gt_option_new_bool("finalstopcodon", "require that the final ORF " "must end with a stop codon", &arguments->final_stop_codon, false); gt_option_parser_add_option(op, option); /* -genericstartcodons */ option = gt_option_new_bool("genericstartcodons", "use generic start codons", &arguments->generic_start_codons, false); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); /* -seqfile, -matchdesc, -usedesc and -regionmapping */ gt_seqid2file_register_options(op, arguments->s2fi); /* -v */ option = gt_option_new_verbose(&arguments->verbose); gt_option_parser_add_option(op, option); /* output file options */ gt_outputfile_register_options(op, &arguments->outfp, arguments->ofi); gt_option_parser_set_comment_func(op, gt_gtdata_show_help, NULL); gt_option_parser_set_max_args(op, 1); return op; }
static GtOptionParser *gt_tyr_search_option_parser_new(void *tool_arguments) { GtOptionParser *op; GtOption *option, *optiontyr, *optionqueries; Tyr_search_options *arguments = tool_arguments; op = gt_option_parser_new("[options] -tyr tallymer-index -q queryfile0 " "[queryfile1..] [options]", "Search a set of k-mers in an index constructed " "by \"gt tyr mkindex\"."); gt_option_parser_set_mailaddress(op,"<*****@*****.**>"); optiontyr = gt_option_new_string("tyr","specify tallymer-index", arguments->str_inputindex, NULL); gt_option_is_mandatory(optiontyr); gt_option_parser_add_option(op, optiontyr); optionqueries = gt_option_new_filenamearray("q","specify query file names", arguments->queryfilenames); gt_option_is_mandatory(optionqueries); gt_option_parser_add_option(op, optionqueries); option = gt_option_new_string("strand", "specify the strand to be searched: " "use f (for forward strand) or " "p (for reverse complemented strand) or " "fp (for both); default is f", arguments->strandspec, "f"); gt_option_parser_add_option(op, option); option = gt_option_new_stringarray("output", "specify output flags " "(qseqnum, qpos, counts, sequence)", arguments->showmodespec); gt_option_parser_add_option(op, option); option = gt_option_new_bool("test", "perform tests to verify program " "correctness", &arguments->performtest, false); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); option = gt_option_new_verbose(&arguments->verbose); gt_option_parser_add_option(op, option); return op; }
static GtOptionParser *gt_cge_spacedseed_option_parser_new(void *tool_arguments) { GtOptionParser *op; GtOption *option, *optionesaindex, *optionpckindex; Cge_spacedseed_options *arguments = tool_arguments; op = gt_option_parser_new("[options]", "Match spaced seeds."); gt_option_parser_set_mailaddress(op,"<*****@*****.**>"); optionesaindex = gt_option_new_string("esa", "Specify index (enhanced suffix array)", arguments->str_inputindex, NULL); gt_option_parser_add_option(op, optionesaindex); arguments->refoptionesaindex = gt_option_ref(optionesaindex); optionpckindex = gt_option_new_string("pck", "Specify index (packed index)", arguments->str_inputindex, NULL); gt_option_parser_add_option(op, optionpckindex); arguments->refoptionpckindex = gt_option_ref(optionpckindex); gt_option_exclude(optionesaindex,optionpckindex); gt_option_is_mandatory_either(optionesaindex,optionpckindex); option = gt_option_new_filenamearray("q", "Specify files containing the " "query sequences", arguments->queryfilenames); gt_option_parser_add_option(op, option); gt_option_is_mandatory(option); option = gt_option_new_bool("cmp","compare results of offline and online " "searches",&arguments->docompare,false); gt_option_parser_add_option(op, option); gt_option_is_development_option(option); option = gt_option_new_verbose(&arguments->verbose); gt_option_parser_add_option(op, option); return op; }
static GtOptionParser* gt_encseq_encode_option_parser_new(void *tool_arguments) { GtOptionParser *op; GtOption *option; GtEncseqEncodeArguments *arguments = (GtEncseqEncodeArguments*) tool_arguments; /* init */ op = gt_option_parser_new("sequence_file [sequence_file " "[sequence_file ...]]", "Encode sequence files (FASTA/FASTQ, GenBank, " "EMBL) efficiently."); /* -showstats */ option = gt_option_new_bool("showstats", "show compression results", &arguments->showstats, false); gt_option_parser_add_option(op, option); /* -no_esq_header */ option = gt_option_new_bool("no_esq_header", "omit the header in the .esq file", &arguments->no_esq_header, false); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); /* encoded sequence options */ arguments->eopts = gt_encseq_options_register_encoding(op, arguments->indexname, NULL); /* -v */ option = gt_option_new_verbose(&arguments->verbose); gt_option_parser_add_option(op, option); gt_option_parser_set_min_args(op, 1); return op; }
static GtOptionParser* gt_show_seedext_option_parser_new(void *tool_arguments) { GtShowSeedextArguments *arguments = tool_arguments; GtOptionParser *op; GtOption *option, *op_ali, *option_filename, *op_relax_polish, *op_seed_extend, *op_sortmatches, *op_showeoplist; gt_assert(arguments); /* init */ op = gt_option_parser_new("[options] -f <matchfilename>", "Parse output of a seed extension and show/verify " "the alignment."); /* -a */ op_ali = gt_option_new_bool("a", "show alignment", &arguments->show_alignment, false); gt_option_parser_add_option(op, op_ali); /* -seed-display */ option = gt_option_new_bool("seed-display", "Display seeds in #-line and by " "character + (instead of |) in middle " "row of alignment column", &arguments->seed_display, false); gt_option_parser_add_option(op, option); /* -seed-extend */ op_seed_extend = gt_option_new_bool("seed-extend", "read the seeds from the # seed: -lines and " "extend them; match lines are ignored; " "match coordindates are displayed", &arguments->seed_extend, false); gt_option_parser_add_option(op, op_seed_extend); /* -relax-polish */ op_relax_polish = gt_option_new_bool("relax-polish", "do not force alignments to have " "polished ends", &arguments->relax_polish,false); gt_option_parser_add_option(op, op_relax_polish); gt_option_is_development_option(op_relax_polish); gt_option_imply(op_relax_polish, op_ali); /* -sort */ op_sortmatches = gt_option_new_bool("sort","sort matches in ascending order " "of their end positon on the " "query", &arguments->sortmatches,false); gt_option_parser_add_option(op, op_sortmatches); /* -e */ op_showeoplist = gt_option_new_bool("e","show list of edit operations", &arguments->showeoplist,false); gt_option_parser_add_option(op, op_showeoplist); /* -f */ option_filename = gt_option_new_filename("f", "path to file with match coordinates", arguments->matchfilename); gt_option_is_mandatory(option_filename); gt_option_parser_add_option(op, option_filename); gt_option_exclude(op_seed_extend, op_sortmatches); gt_option_exclude(op_relax_polish, op_seed_extend); return op; }
static GtOptionParser* gt_condenser_search_option_parser_new (void *tool_arguments) { GtCondenserSearchArguments *arguments = tool_arguments; GtOptionParser *op; GtOption *option, *score_opt, *ceval_opt, *feval_opt, *blastp_opt, *blastn_opt; gt_assert(arguments); /* init */ op = gt_option_parser_new("[option ...]", "Perform a BLAST or " "HMMSEARCH on the given compressed database."); /* -blastn */ blastn_opt = gt_option_new_bool("blastn", "perform blastn search", &arguments->blastn, false); /* -blastp */ blastp_opt = gt_option_new_bool("blastp", "perform blastp search", &arguments->blastp, false); gt_option_exclude(blastn_opt, blastp_opt); gt_option_parser_add_option(op, blastn_opt); gt_option_parser_add_option(op, blastp_opt); /* -score */ score_opt = gt_option_new_uword("score", "bitscore threshold for BLAST(p) " "evalue calculation", &arguments->bitscore, (GtUword) 30); gt_option_parser_add_option(op, score_opt); /* -ce */ ceval_opt = gt_option_new_double("ce", "coarse e value for coarse blast search", &arguments->ceval, 5.0); gt_option_parser_add_option(op, ceval_opt); /* -fe */ feval_opt = gt_option_new_double("fe", "fine e value for fine blast search, " "defaults to calculated evalue from the " "given score", &arguments->feval, GT_UNDEF_DOUBLE); gt_option_hide_default(feval_opt); gt_option_parser_add_option(op, feval_opt); gt_option_exclude(score_opt, ceval_opt); gt_option_exclude(score_opt, feval_opt); /* -db */ option = gt_option_new_filename("db", "path of (compressed) fasta database", arguments->dbpath); gt_option_is_mandatory(option); gt_option_parser_add_option(op, option); /* -query */ option = gt_option_new_filename("query", "path of fasta query file", arguments->querypath); gt_option_is_mandatory(option); gt_option_parser_add_option(op, option); /* -verbose */ option = gt_option_new_bool("verbose", "verbose output", &arguments->verbose, false); gt_option_parser_add_option(op, option); /* -blastthreads */ option = gt_option_new_int_min("blastthreads", "how many threads for blast " "to use", &arguments->blthreads, 8, 1); gt_option_imply_either_2(option, blastn_opt, blastp_opt); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); gt_output_file_info_register_options(arguments->ofi, op, &arguments->outfp); return op; }
static GtOptionParser* gt_linspace_align_option_parser_new(void *tool_arguments) { GtLinspaceArguments *arguments = tool_arguments; GtOptionParser *op; GtOption *optionstrings, *optionfiles, *optionglobal, *optionlocal, *optiondna, *optionprotein, *optioncostmatrix, *optionlinearcosts, *optionaffinecosts, *optionoutputfile, *optionshowscore, *optionshowsequences, *optiondiagonal, *optiondiagonalbonds, *optionsimilarity, *optiontsfactor, *optionspacetime, *optionscoreonly, *optionwildcardsymbol; gt_assert(arguments); /* init */ op = gt_option_parser_new("[ss|ff] sequence1 sequence2 [dna|protein] " "[global|local] [a|l] costs/scores " "[additional options]", "Apply function to compute alignment."); gt_option_parser_set_mail_address(op, "<*****@*****.**>"); /* -bool */ optionglobal = gt_option_new_bool("global", "global alignment", &arguments->global, false); gt_option_parser_add_option(op, optionglobal); optionlocal = gt_option_new_bool("local", "local alignment", &arguments->local, false); gt_option_parser_add_option(op, optionlocal); optiondiagonal = gt_option_new_bool("d", "diagonalband alignment", &arguments->diagonal, false); gt_option_parser_add_option(op, optiondiagonal); optiondna = gt_option_new_bool("dna", "type of sequences: DNA", &arguments->dna, false); gt_option_parser_add_option(op, optiondna); optionprotein = gt_option_new_bool("protein", "type of sequences: protein", &arguments->protein, false); gt_option_parser_add_option(op, optionprotein); optionwildcardsymbol = gt_option_new_bool("wildcard", "show symbol used to " "represented wildcards in output", &arguments->wildcardshow, false); gt_option_parser_add_option(op, optionwildcardsymbol); /* special case, if given matrix includes cost values in place of scores */ optioncostmatrix = gt_option_new_bool("costmatrix", "describes type of " "given substituation matrix", &arguments->has_costmatrix, false); gt_option_parser_add_option(op, optioncostmatrix); optionshowscore = gt_option_new_bool("showscore", "show score for alignment, " "please note it will calculate costs " "for global alignments and scores for " "local alignemnts always, independtly " "of input ", &arguments->showscore, false); gt_option_parser_add_option(op, optionshowscore); optionshowsequences = gt_option_new_bool("showsequences", "show sequences u " "and v in front of alignment", &arguments->showsequences, false); gt_option_parser_add_option(op, optionshowsequences); optionscoreonly = gt_option_new_bool("showonlyscore", "show only score for " "generated alignment to compare with " "other algorithms", &arguments->scoreonly, false); gt_option_parser_add_option(op, optionscoreonly); optionspacetime = gt_option_new_bool("spacetime", "write space peak and time" " overall on stdout", &arguments->spacetime, false); gt_option_parser_add_option(op, optionspacetime); /* -str */ optionstrings = gt_option_new_string_array("ss", "input, use two strings", arguments->strings); gt_option_parser_add_option(op, optionstrings); optionfiles = gt_option_new_filename_array("ff", "input, use two files", arguments->files); gt_option_parser_add_option(op, optionfiles); optionlinearcosts = gt_option_new_string_array("l", "lineargapcosts, " "use match, mismatch and " "gapcost, alternatively " "substituationmatrix and " "gapcost", arguments->linearcosts); gt_option_parser_add_option(op, optionlinearcosts); optionaffinecosts = gt_option_new_string_array("a", "affinegapcosts, " "use match, mismatch, gap_extension " "and gap_opening, alternatively " "substituationmatrix, gap_extension " "and gap_opening", arguments->affinecosts); gt_option_parser_add_option(op, optionaffinecosts); optiondiagonalbonds = gt_option_new_string_array("lr", "specified left and " "right shift of diagonal", arguments->diagonalbonds); gt_option_parser_add_option(op, optiondiagonalbonds); optionoutputfile = gt_option_new_string("o", "print alignment, " "use outputfile", arguments->outputfile, "stdout"); gt_option_parser_add_option(op, optionoutputfile); /* -ulong */ optiontsfactor = gt_option_new_ulong("t", "timesquarefactor to organize " "time and space", &arguments->timesquarefactor,1); gt_option_parser_add_option(op, optiontsfactor); /* -double */ optionsimilarity = gt_option_new_probability("similarity", "specified left " "and right shift of diagonal by " "similarity of sequences, " "0 <= similarty <= 1", &arguments->similarity, 0); gt_option_parser_add_option(op, optionsimilarity); /* dependencies */ gt_option_is_mandatory_either(optionstrings, optionfiles); gt_option_is_mandatory_either(optiondna, optionprotein); gt_option_exclude(optionlocal, optionglobal); gt_option_exclude(optionlinearcosts, optionaffinecosts); gt_option_exclude(optiondna, optionprotein); gt_option_exclude(optionshowsequences, optionscoreonly); gt_option_exclude(optionsimilarity, optiondiagonalbonds); gt_option_imply_either_2(optionfiles, optionglobal, optionlocal); gt_option_imply_either_2(optiondna, optionstrings, optionfiles); gt_option_imply_either_2(optionstrings, optionglobal, optionlocal); gt_option_imply_either_2(optionprotein, optionstrings, optionfiles); gt_option_imply_either_2(optionlocal, optionlinearcosts, optionaffinecosts); gt_option_imply_either_2(optionglobal, optionlinearcosts, optionaffinecosts); gt_option_imply_either_2(optionshowscore,optionlinearcosts,optionaffinecosts); gt_option_imply_either_2(optionshowsequences, optionstrings, optionfiles); gt_option_imply_either_2(optionscoreonly,optionlinearcosts,optionaffinecosts); gt_option_imply(optiondiagonal, optionglobal); gt_option_imply(optiondiagonalbonds, optiondiagonal); gt_option_imply(optionsimilarity, optiondiagonal); gt_option_imply(optioncostmatrix, optionprotein); /* extended options */ gt_option_is_extended_option(optiontsfactor); gt_option_is_extended_option(optionshowscore); gt_option_is_extended_option(optionwildcardsymbol); gt_option_is_extended_option(optioncostmatrix); /* development option(s) */ gt_option_is_development_option(optionspacetime); gt_option_is_development_option(optionscoreonly);/*only useful to test*/ return op; }
static GtOptionParser* gt_readjoiner_assembly_option_parser_new( void *tool_arguments) { GtReadjoinerAssemblyArguments *arguments = tool_arguments; GtOptionParser *op; GtOption *option, *errors_option, *deadend_option, *v_option, *q_option, *bubble_option, *deadend_depth_option; gt_assert(arguments); /* init */ op = gt_option_parser_new("[option ...]", "Construct string graph and output contigs."); /* -readset */ option = gt_option_new_string("readset", "specify the readset name", arguments->readset, NULL); gt_option_parser_add_option(op, option); gt_option_is_mandatory(option); /* -spmfiles */ option = gt_option_new_uint_min("spmfiles", "number of SPM files to read\n" "this must be equal to the value of -j for the overlap phase", &arguments->nspmfiles, 1U, 1U); gt_option_is_extended_option(option); gt_option_parser_add_option(op, option); /* -l */ option = gt_option_new_uint_min("l", "specify the minimum SPM length", &arguments->minmatchlength, 0, 2U); gt_option_is_extended_option(option); gt_option_parser_add_option(op, option); /* -depthcutoff */ option = gt_option_new_uint_min("depthcutoff", "specify the minimal " "number of nodes in a contig", &arguments->depthcutoff, 3U, 1U); gt_option_is_extended_option(option); gt_option_parser_add_option(op, option); /* -lengthcutoff */ option = gt_option_new_uint_min("lengthcutoff", "specify the minimal " "length of a contig", &arguments->lengthcutoff, 100U, 1U); gt_option_is_extended_option(option); gt_option_parser_add_option(op, option); /* -redtrans */ option = gt_option_new_bool("redtrans", "reduce transitive edges", &arguments->redtrans, false); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); /* -errors */ errors_option = gt_option_new_bool("errors", "search graph features which " "may originate from sequencing errors and remove them", &arguments->errors, false); gt_option_is_extended_option(errors_option); gt_option_parser_add_option(op, errors_option); /* -bubble */ bubble_option = gt_option_new_uint("bubble", "number of rounds of p-bubble " "removal to perform", &arguments->bubble, 3U); gt_option_is_extended_option(bubble_option); gt_option_imply(bubble_option, errors_option); gt_option_parser_add_option(op, bubble_option); /* -deadend */ deadend_option = gt_option_new_uint("deadend", "number of rounds of " "dead end removal to perform a dead end", &arguments->deadend, 10U); gt_option_is_extended_option(deadend_option); gt_option_imply(deadend_option, errors_option); gt_option_parser_add_option(op, deadend_option); /* -deadend-depth */ deadend_depth_option = gt_option_new_uint_min("deadend-depth", "specify the " "maximal depth of a path to an end-vertex by which the path shall be " "considered a dead end", &arguments->deadend_depth, 10U, 1U); gt_option_is_extended_option(deadend_depth_option); gt_option_imply(deadend_depth_option, errors_option); gt_option_parser_add_option(op, deadend_depth_option); /* -paths2seq */ option = gt_option_new_bool("paths2seq", "read <indexname>" GT_READJOINER_SUFFIX_CONTIG_PATHS " and write " "<indexname>" GT_READJOINER_SUFFIX_CONTIGS, &arguments->paths2seq, false); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); /* -buffersize */ option = gt_option_new_string("buffersize", "specify size for read buffer" " of paths2seq phase (in bytes, the keywords 'MB' and 'GB' are allowed)", arguments->buffersizearg, NULL); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); arguments->refoptionbuffersize = gt_option_ref(option); /* -vd */ option = gt_option_new_bool("vd", "use verbose descriptions for contigs", &arguments->vd, false); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); /* -astat */ option = gt_option_new_bool("astat", "calculate A-statistics for each contig", &arguments->astat, false); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); /* -cov */ option = gt_option_new_double("cov", "average coverage value to use for the " "A-statistics calculation", &arguments->coverage, (double)0); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); /* -copynum */ option = gt_option_new_bool("copynum", "load reads copy numbers list from " "file for the A-statistics calculation", &arguments->copynum, false); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); /* -v */ v_option = gt_option_new_verbose(&arguments->verbose); gt_option_parser_add_option(op, v_option); /* -q */ q_option = gt_option_new_bool("q", "suppress standard output messages", &arguments->quiet, false); gt_option_parser_add_option(op, q_option); gt_option_exclude(q_option, v_option); /* -load */ option = gt_option_new_bool("load", "save the string graph from file", &arguments->load, false); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); /* -save */ option = gt_option_new_bool("save", "save the string graph to file", &arguments->save, false); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); /* -show_contigs_info */ option = gt_option_new_bool("cinfo", "output additional files required " "for contigs graph construction (eqlen only)", &arguments->show_contigs_info, false); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); gt_option_parser_set_version_func(op, gt_readjoiner_show_version); gt_option_parser_set_max_args(op, 0); return op; }
static GtOptionParser* gt_genomediff_option_parser_new(void *tool_arguments) { GtGenomediffArguments *arguments = tool_arguments; GtOptionParser *op; GtOption *option, *option_unitfile; static const char *indextypes[] = { "esa", "pck", "encseq", NULL }; gt_assert(arguments); /* init */ op = gt_option_parser_new("[option ...] " "(INDEX | -indexname NAME SEQFILE SEQFILE [...]) ", "Calculates Kr: pairwise distances between genomes."); /* options */ option = gt_option_new_choice("indextype", "specify type of index, one of: " "esa|pck|encseq. Where encseq is an encoded " "sequence and an enhanced suffix array will be " "constructed only in memory.", arguments->indextype, indextypes[2], indextypes); gt_option_parser_add_option(op, option); option = gt_option_new_string("indexname", "Basename of encseq to construct.", arguments->indexname, NULL); gt_option_parser_add_option(op, option); /*-unitfile*/ option_unitfile = gt_option_new_filename("unitfile", "specifies genomic units, " "see below for description.", arguments->unitfile); gt_option_parser_add_option(op, option_unitfile); arguments->ref_unitfile = gt_option_ref(option_unitfile); /* encseq options */ arguments->loadopts = gt_encseq_options_register_loading(op, arguments->indexname); gt_option_is_development_option( gt_encseq_options_lossless_option(arguments->loadopts)); /* esa options */ arguments->idxopts = gt_index_options_register_esa_noout(op); gt_option_is_development_option( gt_index_options_spmopt_option(arguments->idxopts)); /* scan */ option = gt_option_new_bool("scan", "do not load esa index but scan " "it sequentially.", &arguments->scanfile, true); gt_option_is_extended_option(option); gt_option_parser_add_option(op, option); /* dev options */ /* -max_n */ option = gt_option_new_uword("max_n", "Number of precalculated values " "for ln(n!) and pmax(x).", &arguments->max_ln_n_fac, 1000UL); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); /* -maxdepth */ option = gt_option_new_int("maxdepth", "max depth of .pbi-file, use with " "-indextype pck.", &arguments->user_max_depth, -1); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); /* thresholds */ /* divergence error */ option = gt_option_new_double("thr", "Threshold for difference (du, dl) in " "divergence calculation.\n" "default: 1e-9", &arguments->divergence_threshold, 1e-9); gt_option_is_extended_option(option); gt_option_hide_default(option); gt_option_parser_add_option(op, option); /* expected shulen error */ option = gt_option_new_double("abs_err", "absolute error for expected shulen " "calculation.\n" "default: 1e-5", &arguments->divergence_abs_err, 1e-5); gt_option_is_extended_option(option); gt_option_hide_default(option); gt_option_parser_add_option(op, option); /* relative expected shulen error */ option = gt_option_new_double("rel_err", "relative error for expected shulen " "calculation.\n" "default: 1e-3", &arguments->divergence_rel_err, 1e-3); gt_option_is_extended_option(option); gt_option_hide_default(option); gt_option_parser_add_option(op, option); /* M */ option = gt_option_new_double("M", "threshold for minimum logarithm.\n" "default: DBL_MIN", &arguments->divergence_m, DBL_MIN); gt_option_is_extended_option(option); gt_option_hide_default(option); gt_option_parser_add_option(op, option); /* -v */ option = gt_option_new_verbose(&arguments->verbose); gt_option_parser_add_option(op, option); /* mail */ gt_option_parser_set_mail_address(op, "<*****@*****.**>"); /* doc */ gt_option_parser_set_comment_func(op, gt_gtdata_show_help, NULL); return op; }
static GtOptionParser* gt_ltrdigest_option_parser_new(void *tool_arguments) { GtLTRdigestOptions *arguments = tool_arguments; GtOptionParser *op; GtOption *o, *ot, *oto; GtOption *oh, *oc, *oeval; static const char *cutoffs[] = {"NONE", "GA", "TC", NULL}; static GtRange pptlen_defaults = { 8UL, 30UL}, uboxlen_defaults = { 3UL, 30UL}, pbsalilen_defaults = {11UL, 30UL}, pbsoffsetlen_defaults = { 0UL, 5UL}, pbstrnaoffsetlen_defaults = { 0UL, 5UL}; gt_assert(arguments); /* init */ op = gt_option_parser_new("[option ...] gff3_file", "Identifies and annotates sequence features in LTR " "retrotransposon candidates."); /* Output files */ oto = gt_option_new_string("outfileprefix", "prefix for output files (e.g. 'foo' will create " "files called 'foo_*.csv' and 'foo_*.fas')\n" "Omit this option for GFF3 output only.", arguments->prefix, NULL); gt_option_parser_add_option(op, oto); gt_option_hide_default(oto); o = gt_option_new_bool("metadata", "output metadata (run conditions) to separate file", &arguments->print_metadata, true); gt_option_parser_add_option(op, o); gt_option_imply(o, oto); o = gt_option_new_uint("seqnamelen", "set maximal length of sequence names in FASTA headers" " (e.g. for clustalw or similar tools)", &arguments->seqnamelen, 20U); gt_option_parser_add_option(op, o); /* PPT search options */ o = gt_option_new_range("pptlen", "required PPT length range", &arguments->ppt_len, &pptlen_defaults); gt_option_parser_add_option(op, o); o = gt_option_new_range("uboxlen", "required U-box length range", &arguments->ubox_len, &uboxlen_defaults); gt_option_parser_add_option(op, o); o = gt_option_new_uint("uboxdist", "allowed U-box distance range from PPT", &arguments->max_ubox_dist, 0); gt_option_parser_add_option(op, o); o = gt_option_new_uint("pptradius", "radius around beginning of 3' LTR " "to search for PPT", &arguments->ppt_radius, 30U); gt_option_parser_add_option(op, o); o = gt_option_new_probability("pptrprob", "purine emission probability inside PPT", &arguments->ppt_purine_prob, PPT_PURINE_PROB); gt_option_parser_add_option(op, o); gt_option_is_extended_option(o); o = gt_option_new_probability("pptyprob", "pyrimidine emission probability inside PPT", &arguments->ppt_pyrimidine_prob, PPT_PYRIMIDINE_PROB); gt_option_parser_add_option(op, o); gt_option_is_extended_option(o); o = gt_option_new_probability("pptgprob", "background G emission probability outside PPT", &arguments->bkg_g_prob, BKG_G_PROB); gt_option_parser_add_option(op, o); gt_option_is_extended_option(o); o = gt_option_new_probability("pptcprob", "background C emission probability outside PPT", &arguments->bkg_c_prob, BKG_C_PROB); gt_option_parser_add_option(op, o); gt_option_is_extended_option(o); o = gt_option_new_probability("pptaprob", "background A emission probability outside PPT", &arguments->bkg_a_prob, BKG_A_PROB); gt_option_parser_add_option(op, o); gt_option_is_extended_option(o); o = gt_option_new_probability("ppttprob", "background T emission probability outside PPT", &arguments->bkg_t_prob, BKG_T_PROB); gt_option_parser_add_option(op, o); gt_option_is_extended_option(o); o = gt_option_new_probability("pptuprob", "U/T emission probability inside U-box", &arguments->ubox_u_prob, UBOX_U_PROB); gt_option_parser_add_option(op, o); gt_option_is_extended_option(o); /* PBS search options */ ot = gt_option_new_filename("trnas", "tRNA library in multiple FASTA format for PBS " "detection\n" "Omit this option to disable PBS search.", arguments->trna_lib); gt_option_parser_add_option(op, ot); gt_option_hide_default(ot); o = gt_option_new_range("pbsalilen", "required PBS/tRNA alignment length range", &arguments->alilen, &pbsalilen_defaults); gt_option_parser_add_option(op, o); gt_option_imply(o, ot); o = gt_option_new_range("pbsoffset", "allowed PBS offset from LTR boundary range", &arguments->offsetlen, &pbsoffsetlen_defaults); gt_option_parser_add_option(op, o); gt_option_imply(o, ot); o = gt_option_new_range("pbstrnaoffset", "allowed PBS/tRNA 3' end alignment offset range", &arguments->trnaoffsetlen, &pbstrnaoffsetlen_defaults); gt_option_parser_add_option(op, o); gt_option_imply(o, ot); o = gt_option_new_uint("pbsmaxedist", "maximal allowed PBS/tRNA alignment unit " "edit distance", &arguments->max_edist, 1U); gt_option_parser_add_option(op, o); gt_option_imply(o, ot); o = gt_option_new_uint("pbsradius", "radius around end of 5' LTR " "to search for PBS", &arguments->pbs_radius, 30U); gt_option_parser_add_option(op, o); gt_option_imply(o, ot); /* Protein domain search options */ oh = gt_option_new_filename_array("hmms", "profile HMM models for domain detection " "(separate by spaces, finish with --) in " "HMMER3 format\n" "Omit this option to disable pHMM search.", arguments->hmm_files); gt_option_parser_add_option(op, oh); oeval = gt_option_new_probability("pdomevalcutoff", "global E-value cutoff for pHMM search\n" "default 1E-6", &arguments->evalue_cutoff, 0.000001); gt_option_parser_add_option(op, oeval); gt_option_is_extended_option(oeval); gt_option_hide_default(oeval); gt_option_imply(oeval, oh); oc = gt_option_new_choice("pdomcutoff", "model-specific score cutoff\n" "choose from TC (trusted cutoff) | " "GA (gathering cutoff) | " "NONE (no cutoffs)", arguments->cutoffs, cutoffs[0], cutoffs); gt_option_parser_add_option(op, oc); gt_option_is_extended_option(oeval); gt_option_imply(oeval, oh); o = gt_option_new_bool("aliout", "output pHMM to amino acid sequence alignments", &arguments->write_alignments, false); gt_option_parser_add_option(op, o); gt_option_imply(o, oh); gt_option_imply(o, oto); o = gt_option_new_bool("aaout", "output amino acid sequences for protein domain " "hits", &arguments->write_aaseqs, false); gt_option_parser_add_option(op, o); gt_option_imply(o, oh); gt_option_imply(o, oto); o = gt_option_new_bool("allchains", "output features from all chains and unchained " "features, labeled with chain numbers", &arguments->output_all_chains, false); gt_option_parser_add_option(op, o); gt_option_imply(o, oh); o = gt_option_new_uint("maxgaplen", "maximal allowed gap size between fragments (in amino " "acids) when chaining pHMM hits for a protein domain", &arguments->chain_max_gap_length, 50U); gt_option_parser_add_option(op, o); gt_option_is_extended_option(o); gt_option_imply(o, oh); o = gt_option_new_uword("threads", "DEPRECATED, only included for compatibility reasons!" " Use the -j parameter of the 'gt' call instead.", &arguments->nthreads, 0); gt_option_parser_add_option(op, o); gt_option_is_development_option(o); /* Extended PBS options */ o = gt_option_new_int("pbsmatchscore", "match score for PBS/tRNA alignments", &arguments->ali_score_match, 5); gt_option_parser_add_option(op, o); gt_option_is_extended_option(o); gt_option_imply(o, ot); o = gt_option_new_int("pbsmismatchscore", "mismatch score for PBS/tRNA alignments", &arguments->ali_score_mismatch, -10); gt_option_parser_add_option(op, o); gt_option_is_extended_option(o); gt_option_imply(o, ot); o = gt_option_new_int("pbsinsertionscore", "insertion score for PBS/tRNA alignments", &arguments->ali_score_insertion, -20); gt_option_parser_add_option(op, o); gt_option_is_extended_option(o); gt_option_imply(o, ot); o = gt_option_new_int("pbsdeletionscore", "deletion score for PBS/tRNA alignments", &arguments->ali_score_deletion, -20); gt_option_parser_add_option(op, o); gt_option_is_extended_option(o); gt_option_imply(o, ot); /* verbosity */ o = gt_option_new_verbose(&arguments->verbose); gt_option_parser_add_option(op, o); /* output file options */ gt_output_file_info_register_options(arguments->ofi, op, &arguments->outfp); /* region mapping and sequence source options */ gt_seqid2file_register_options_ext(op, arguments->s2fi, false, false); return op; }
static GtOptionParser* gt_select_option_parser_new(void *tool_arguments) { SelectArguments *arguments = tool_arguments; GtOptionParser *op; GtOption *option, *contain_option, *overlap_option, *minaveragessp_option, *singleintron_option, *optiondroppedfile; gt_assert(arguments); static const char *filter_logic[] = { "AND", "OR", NULL }; /* init */ op = gt_option_parser_new("[option ...] [GFF3_file ...]", "Select certain features (specified by the used " "options) from given GFF3 file(s)."); /* -seqid */ option = gt_option_new_string("seqid", "select feature with the given " "sequence ID (all comments are selected). ", arguments->seqid, NULL); gt_option_parser_add_option(op, option); /* -source */ option = gt_option_new_string("source", "select feature with the given " "source (the source is column 2 in regular " "GFF3 lines)" , arguments->source, NULL); gt_option_parser_add_option(op, option); /* -contain */ contain_option = gt_option_new_range("contain", "select all features which " "are contained in the given range", &arguments->contain_range, NULL); gt_option_parser_add_option(op, contain_option); /* -overlap */ overlap_option = gt_option_new_range("overlap", "select all features which " "do overlap with the given range", &arguments->overlap_range, NULL); gt_option_parser_add_option(op, overlap_option); /* -strand */ option = gt_option_new_string(GT_STRAND_OPT, "select all top-level features" "(i.e., features without parents) whose strand " "equals the given one (must be one of '" GT_STRAND_CHARS"')", arguments->gt_strand_char, NULL); gt_option_parser_add_option(op, option); /* -targetstrand */ option = gt_option_new_string(TARGETGT_STRAND_OPT, "select all top-level " "features (i.e., features without parents) " "which have exactly one target attribute whose " "strand equals the given one (must be one of '" GT_STRAND_CHARS"')", arguments->targetgt_strand_char, NULL); gt_option_parser_add_option(op, option); /* -targetbest */ option = gt_option_new_bool("targetbest", "if multiple top-level features " "(i.e., features without parents) with exactly " "one target attribute have the same target_id, " "keep only the feature with the best score. If " "-"TARGETGT_STRAND_OPT" is used at the same time, " "this option is applied after " "-"TARGETGT_STRAND_OPT".\n" "Memory consumption is proportional to the input " "file size(s).", &arguments->targetbest, false); gt_option_parser_add_option(op, option); /* -hascds */ option = gt_option_new_bool("hascds", "select all top-level features which " "do have a CDS child", &arguments->has_CDS, false); gt_option_parser_add_option(op, option); /* -maxgenelength */ option = gt_option_new_uword_min("maxgenelength", "select genes up to the " "given maximum length", &arguments->max_gene_length, GT_UNDEF_UWORD, 1); gt_option_parser_add_option(op, option); /* -maxgenenum */ option = gt_option_new_uword("maxgenenum", "select the first genes up to the " "given maximum number", &arguments->max_gene_num, GT_UNDEF_UWORD); gt_option_parser_add_option(op, option); /* -mingenescore */ option = gt_option_new_double("mingenescore", "select genes with the given " "minimum score", &arguments->min_gene_score, GT_UNDEF_DOUBLE); gt_option_parser_add_option(op, option); /* -maxgenescore */ option = gt_option_new_double("maxgenescore", "select genes with the given " "maximum score", &arguments->max_gene_score, GT_UNDEF_DOUBLE); gt_option_parser_add_option(op, option); /* -minaveragessp */ minaveragessp_option = gt_option_new_probability("minaveragessp", "set the minimum average splice site probability", &arguments->min_average_splice_site_prob, GT_UNDEF_DOUBLE); gt_option_parser_add_option(op, minaveragessp_option); /* -singleintronfactor */ singleintron_option = gt_option_new_double_min("singleintronfactor", "factor to multiplicate the average splice site " "probability with for single introns before " "comparing it to the minimum average splice site " "probability", &arguments->single_intron_factor, 1.0, 1.0); gt_option_is_development_option(singleintron_option); gt_option_parser_add_option(op, singleintron_option); /* -featurenum */ option = gt_option_new_uword_min("featurenum", "select feature tree occurring " "at given position in input", &arguments->feature_num, GT_UNDEF_UWORD, 1); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); /* -filter_files */ option = gt_option_new_filename_array("rule_files", "specify Lua files to be used " "for selection", arguments->filter_files); gt_option_parser_add_option(op, option); /* -filter_logic */ option = gt_option_new_choice("rule_logic", "select how multiple Lua " "files should be combined\nchoose from AND|OR", arguments->filter_logic, filter_logic[0], filter_logic); gt_option_parser_add_option(op, option); /* -nh_file */ optiondroppedfile = gt_option_new_filename("dropped_file", "save non-selected features to " "file", arguments->dropped_file); gt_option_parser_add_option(op, optiondroppedfile); /* -v */ option = gt_option_new_verbose(&arguments->verbose); gt_option_parser_add_option(op, option); /* option exclusions */ gt_option_exclude(contain_option, overlap_option); /* option implications */ gt_option_imply(singleintron_option, minaveragessp_option); /* output file options */ gt_output_file_info_register_options(arguments->ofi, op, &arguments->outfp); gt_option_parser_set_comment_func(op, gt_gtdata_show_help, NULL); return op; }
static GtOptionParser* gt_matstat_option_parser_new(void *tool_arguments) { Gfmsubcallinfo *arguments = tool_arguments; GtOptionParser *op; gt_assert(arguments); op = gt_option_parser_new("[options ...] -query queryfile [...]", arguments->doms ? "Compute matching statistics." : "Compute length of minimum unique prefixes."); gt_option_parser_set_mail_address(op,"<*****@*****.**>"); arguments->optionfmindex = gt_option_new_string("fmi", "specify fmindex", arguments->indexname,NULL); gt_option_parser_add_option(op, arguments->optionfmindex); arguments->optionesaindex = gt_option_new_string("esa", "specify suffix array", arguments->indexname,NULL); gt_option_parser_add_option(op, arguments->optionesaindex); arguments->optionpckindex = gt_option_new_string("pck", "specify packed index", arguments->indexname,NULL); gt_option_parser_add_option(op, arguments->optionpckindex); gt_option_exclude(arguments->optionfmindex,arguments->optionesaindex); gt_option_exclude(arguments->optionpckindex,arguments->optionesaindex); gt_option_exclude(arguments->optionpckindex,arguments->optionfmindex); arguments->optionquery = gt_option_new_filename_array("query", "specify queryfiles", arguments->queryfilenames); gt_option_is_mandatory(arguments->optionquery); gt_option_parser_add_option(op, arguments->optionquery); arguments->optionmin = gt_option_new_uword_min("min", "only output length " "if >= given minimum length", &arguments->minlength. valueunsignedlong, 0,(GtUword) 1); gt_option_parser_add_option(op, arguments->optionmin); arguments->optionmax = gt_option_new_uword_min("max", "only output length " "if <= given maximum length", &arguments->maxlength. valueunsignedlong, 0,(GtUword) 1); gt_option_parser_add_option(op, arguments->optionmax); arguments->optionoutput = gt_option_new_string_array("output", arguments->doms ? "set output flags (sequence, querypos, subjectpos)" : "set output flags (sequence, querypos)", arguments->flagsoutputoption); gt_option_parser_add_option(op, arguments->optionoutput); if (arguments->doms) { arguments->optionverify = gt_option_new_bool("verify", "verify witness positions", &arguments->verifywitnesspos, false); gt_option_is_development_option(arguments->optionverify); gt_option_parser_add_option(op, arguments->optionverify); } else { arguments->verifywitnesspos = false; } gt_option_parser_refer_to_manual(op); return op; }
static GtOptionParser *gt_tyr_mkindex_option_parser_new(void *tool_arguments) { GtOptionParser *op; GtOption *option, *optionminocc, *optionmaxocc, *optionpl, *optionstoreindex, *optionstorecounts, *optionscan, *optionesa; Tyr_mkindex_options *arguments = tool_arguments; op = gt_option_parser_new("[options] -esa suffixerator-index [options]", "Count and index k-mers in the given enhanced " "suffix array for a fixed value of k."); gt_option_parser_set_mailaddress(op,"<*****@*****.**>"); optionesa = gt_option_new_string("esa","specify suffixerator-index\n" "(mandatory option)", arguments->str_inputindex, NULL); gt_option_is_mandatory(optionesa); gt_option_parser_add_option(op, optionesa); option = gt_option_new_ulong("mersize", "Specify the mer size.", &arguments->mersize, 20UL); gt_option_parser_add_option(op, option); optionminocc = gt_option_new_ulong("minocc", "Specify the minimum occurrence number for " "the mers to output/index", &arguments->userdefinedminocc, 0); gt_option_parser_add_option(op, optionminocc); optionmaxocc = gt_option_new_ulong("maxocc", "Specify the maximum occurrence number for " "the mers to output/index", &arguments->userdefinedmaxocc, 0); gt_option_parser_add_option(op, optionmaxocc); optionpl = gt_option_new_uint_min("pl", "specify prefix length for bucket boundary construction\n" "recommendation: use without argument;\n" "then a reasonable prefix length is automatically determined", &arguments->userdefinedprefixlength, 0, 1U); gt_option_argument_is_optional(optionpl); gt_option_parser_add_option(op, optionpl); arguments->refoptionpl = gt_option_ref(optionpl); optionstoreindex = gt_option_new_string("indexname", "store the mers specified by options " "-maxocc and -minocc in an index", arguments->str_storeindex, NULL); gt_option_parser_add_option(op, optionstoreindex); optionstorecounts = gt_option_new_bool("counts", "store counts of the mers", &arguments->storecounts,false); gt_option_parser_add_option(op, optionstorecounts); option = gt_option_new_bool("test", "perform tests to verify program " "correctness", &arguments->performtest, false); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); optionscan = gt_option_new_bool("scan", "read enhanced suffix array sequentially " "instead of mapping it to memory", &arguments->scanfile, false); gt_option_parser_add_option(op, optionscan); option = gt_option_new_verbose(&arguments->verbose); gt_option_parser_add_option(op, option); gt_option_imply(optionpl, optionstoreindex); gt_option_imply(optionstorecounts, optionstoreindex); gt_option_imply_either_2(optionstoreindex,optionminocc,optionmaxocc); return op; }
static GtOptionParser *gt_repfind_option_parser_new(void *tool_arguments) { GtOptionParser *op; GtOption *option, *reverseoption, *queryoption, *extendseedoption, *scanoption, *sampleoption, *forwardoption, *spmoption; Maxpairsoptions *arguments = tool_arguments; op = gt_option_parser_new("[options] -ii indexname", "Compute maximal repeats."); gt_option_parser_set_mail_address(op,"<*****@*****.**>"); option = gt_option_new_uint_min("l","Specify minimum length of repeats", &arguments->userdefinedleastlength, 20U, 1U); gt_option_parser_add_option(op, option); forwardoption = gt_option_new_bool("f","Compute maximal forward repeats", &arguments->forward, true); gt_option_parser_add_option(op, forwardoption); arguments->refforwardoption = gt_option_ref(forwardoption); reverseoption = gt_option_new_bool("r","Compute maximal reverse matches", &arguments->reverse, false); gt_option_parser_add_option(op, reverseoption); sampleoption = gt_option_new_uword_min("samples","Specify number of samples", &arguments->samples, 0, 1UL); gt_option_is_development_option(sampleoption); gt_option_parser_add_option(op, sampleoption); spmoption = gt_option_new_bool("spm","Search for suffix prefix matches", &arguments->searchspm, false); gt_option_is_development_option(spmoption); gt_option_parser_add_option(op, spmoption); extendseedoption = gt_option_new_bool("extend","Extend seed to both sides", &arguments->extendseed, false); gt_option_is_development_option(extendseedoption); gt_option_parser_add_option(op, extendseedoption); scanoption = gt_option_new_bool("scan","scan index rather than mapping " "it to main memory", &arguments->scanfile, false); gt_option_parser_add_option(op, scanoption); option = gt_option_new_string("ii", "Specify input index", arguments->indexname, NULL); gt_option_parser_add_option(op, option); gt_option_is_mandatory(option); queryoption = gt_option_new_filename_array("q", "Specify query files", arguments->queryfiles); gt_option_is_development_option(queryoption); gt_option_parser_add_option(op, queryoption); option = gt_option_new_bool("v", "be verbose ", &arguments->beverbose, false); gt_option_parser_add_option(op, option); gt_option_exclude(queryoption,sampleoption); gt_option_exclude(queryoption,scanoption); gt_option_exclude(queryoption,reverseoption); gt_option_exclude(queryoption,spmoption); gt_option_exclude(reverseoption,spmoption); gt_option_exclude(queryoption,spmoption); gt_option_exclude(sampleoption,spmoption); return op; }
static GtOptionParser* gt_sketch_option_parser_new(void *tool_arguments) { GtSketchArguments *arguments = tool_arguments; GtOptionParser *op; GtOption *option, *option2; static const char *formats[] = { "png", #ifdef CAIRO_HAS_PDF_SURFACE "pdf", #endif #ifdef CAIRO_HAS_SVG_SURFACE "svg", #endif #ifdef CAIRO_HAS_PS_SURFACE "ps", #endif NULL }; static const char *inputs[] = { "gff", "bed", "gtf", NULL }; gt_assert(arguments); /* init */ op = gt_option_parser_new("[option ...] image_file [GFF3_file ...]", "Create graphical representation of GFF3 " "annotation files."); /* -pipe */ option = gt_option_new_bool("pipe", "use pipe mode (i.e., show all gff3 " "features on stdout)", &arguments->pipe, false); gt_option_parser_add_option(op, option); /* -flattenfiles */ option = gt_option_new_bool("flattenfiles", "do not group tracks by source " "file name and remove file names from track " "description", &arguments->flattenfiles, false); gt_option_parser_add_option(op, option); /* -seqid */ option = gt_option_new_string("seqid", "sequence region identifier\n" "default: first one in file", arguments->seqid, NULL); gt_option_parser_add_option(op, option); gt_option_hide_default(option); /* -start */ option = gt_option_new_uword_min("start", "start position\n" "default: first region start", &arguments->start, GT_UNDEF_UWORD, 1); gt_option_parser_add_option(op, option); gt_option_hide_default(option); /* -end */ option2 = gt_option_new_uword("end", "end position\ndefault: last region end", &arguments->end, GT_UNDEF_UWORD); gt_option_parser_add_option(op, option2); /* -start and -end must be given together */ gt_option_imply(option, option2); gt_option_imply(option2, option); gt_option_hide_default(option2); /* -width */ option = gt_option_new_uint_min("width", "target image width (in pixel)", &arguments->width, 800, 1); gt_option_parser_add_option(op, option); /* -style */ option = gt_option_new_string("style", "style file to use", arguments->stylefile, gt_str_get(arguments->stylefile)); gt_option_parser_add_option(op, option); /* -format */ option = gt_option_new_choice("format", "output graphics format\n" "choose from png" #ifdef CAIRO_HAS_PDF_SURFACE "|pdf" #endif #ifdef CAIRO_HAS_SVG_SURFACE "|svg" #endif #ifdef CAIRO_HAS_PS_SURFACE "|ps" #endif "", arguments->format, formats[0], formats); gt_option_parser_add_option(op, option); /* -input */ option = gt_option_new_choice("input", "input data format\n" "choose from gff|bed|gtf", arguments->input, inputs[0], inputs); gt_option_parser_add_option(op, option); /* -addintrons */ option = gt_option_new_bool("addintrons", "add intron features between " "existing exon features (before drawing)", &arguments->addintrons, false); gt_option_parser_add_option(op, option); /* -unsafe */ option = gt_option_new_bool("unsafe", "enable unsafe mode for style file", &arguments->unsafe, false); gt_option_parser_add_option(op, option); /* -showrecmaps */ option = gt_option_new_bool("showrecmaps", "show RecMaps after image creation", &arguments->showrecmaps, false); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); /* -streams */ option = gt_option_new_bool("streams", "use streams to write data to file", &arguments->use_streams, false); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); /* -v */ option = gt_option_new_verbose(&arguments->verbose); gt_option_parser_add_option(op, option); /* -force */ option = gt_option_new_bool(GT_FORCE_OPT_CSTR, "force writing to output file", &arguments->force, false); gt_option_parser_add_option(op, option); gt_option_parser_set_min_args(op, 1); return op; }
static GtOptionParser *gt_idxlocali_option_parser_new (void *tool_arguments) { IdxlocaliOptions *arguments = tool_arguments; GtOptionParser *op; GtOption *option, *optionesaindex, *optionpckindex, *optiononline, *optioncmp; gt_assert (arguments != NULL); arguments->indexname = gt_str_new (); arguments->queryfiles = gt_str_array_new (); op = gt_option_parser_new ("[options] -q query-file-names [-esa|-pck] indexname", "Find all local alignments using suffix tree."); gt_option_parser_set_mailaddress (op, "<*****@*****.**>"); option = gt_option_new_filenamearray ("q","Specify files containing the " "query sequences", arguments->queryfiles); gt_option_parser_add_option (op, option); option = gt_option_new_long ("match", "Specify match score", &arguments->matchscore, 1L); gt_option_parser_add_option (op, option); option = gt_option_new_long ("mismatch", "Specify mismatch score", &arguments->mismatchscore, -3L); gt_option_parser_add_option (op, option); option = gt_option_new_long ("gapstart", "Specify gap start score", &arguments->gapstart, -5L); gt_option_parser_add_option (op, option); option = gt_option_new_long ("gapextend", "Specify gap extension score", &arguments->gapextend, -2L); gt_option_parser_add_option (op, option); option = gt_option_new_ulong_min ("th", "Specify the threshold", &arguments->threshold, 0, 1UL); gt_option_parser_add_option (op, option); gt_option_is_mandatory (option); optionesaindex = gt_option_new_string ("esa", "Specify index " "(enhanced suffix array)", arguments->indexname, NULL); gt_option_parser_add_option (op, optionesaindex); arguments->refoptionesaindex = gt_option_ref (optionesaindex); optionpckindex = gt_option_new_string ("pck", "Specify index (packed index)", arguments->indexname, NULL); gt_option_parser_add_option (op, optionpckindex); arguments->refoptionpckindex = gt_option_ref (optionpckindex); gt_option_exclude (optionesaindex, optionpckindex); gt_option_is_mandatory_either (optionesaindex, optionpckindex); optiononline = gt_option_new_bool("online","Perform online searches", &arguments->doonline, false); gt_option_parser_add_option(op, optiononline); gt_option_is_development_option(optiononline); optioncmp = gt_option_new_bool("cmp","Compare results of offline and online " "searches", &arguments->docompare, false); gt_option_parser_add_option(op,optioncmp); gt_option_exclude(optiononline,optioncmp); option = gt_option_new_bool("s", "Show alignments", &arguments->showalignment, false); gt_option_parser_add_option (op, option); option = gt_option_new_verbose(&arguments->verbose); gt_option_parser_add_option(op, option); return op; }
static GtOptionParser* gt_encseq2spm_option_parser_new(void *tool_arguments) { GtEncseq2spmArguments *arguments = tool_arguments; GtOptionParser *op; GtOption *option, *optionparts, *optionmemlimit; gt_assert(arguments); /* init */ op = gt_option_parser_new("[option ...] [file]", "Compute suffix prefix matches " "from encoded sequence."); /* -l */ option = gt_option_new_uint_min("l", "specify the minimum length", &arguments->minmatchlength, 0, 1U); gt_option_parser_add_option(op, option); gt_option_is_mandatory(option); /* -parts */ optionparts = gt_option_new_uint("parts", "specify the number of parts", &arguments->numofparts, 0U); gt_option_parser_add_option(op, optionparts); /* -memlimit */ optionmemlimit = gt_option_new_string("memlimit", "specify maximal amount of memory to be used during " "index construction (in bytes, the keywords 'MB' " "and 'GB' are allowed)", arguments->memlimitarg, NULL); gt_option_parser_add_option(op, optionmemlimit); gt_option_exclude(optionmemlimit, optionparts); arguments->refoptionmemlimit = gt_option_ref(optionmemlimit); /* -checksuftab */ option = gt_option_new_bool("checksuftab", "check the suffix table", &arguments->checksuftab, false); gt_option_parser_add_option(op, option); gt_option_is_development_option(option); /* -singlestrand */ option = gt_option_new_bool("singlestrand", "use only the forward strand " "of the sequence", &arguments->singlestrand, false); gt_option_parser_add_option(op, option); /* -spm */ option = gt_option_new_string("spm", "specify output for spms", arguments->spmspec, NULL); gt_option_parser_add_option(op, option); /* -ii */ option = gt_option_new_string("ii", "specify the input sequence", arguments->encseqinput, NULL); gt_option_parser_add_option(op, option); gt_option_is_mandatory(option); /* -onlyaccum */ option = gt_option_new_bool("onlyaccum", "only accumulate codes", &arguments->onlyaccum, false); gt_option_parser_add_option(op, option); gt_option_is_development_option(option); /* -onlyallfirstcodes */ option = gt_option_new_bool("onlyallfirstcodes", "only determines allcodes", &arguments->onlyallfirstcodes, false); gt_option_parser_add_option(op, option); gt_option_is_development_option(option); /* -addbscachedepth */ option = gt_option_new_uint("addbscachedepth", "only determines allcodes", &arguments->addbscache_depth, 5U); gt_option_parser_add_option(op, option); gt_option_is_development_option(option); /* -phase2extra */ option = gt_option_new_string("phase2extra", "specify amount of additional space required for " "the second phase of the computation involving the " "processing of the intervals (in bytes, " "the keywords 'MB' and 'GB' are allowed)", arguments->phase2extraarg, NULL); gt_option_parser_add_option(op, option); arguments->refoptionphase2extra = gt_option_ref(option); gt_option_is_development_option(option); /* -radixlarge */ option = gt_option_new_bool("radixlarge", "use large tables for radixsort", &arguments->radixlarge, false); gt_option_parser_add_option(op, option); gt_option_is_development_option(option); /* -radixparts */ option = gt_option_new_uint("radixparts", "specify the number of parts " "for radixsort", &arguments->radixparts, 1U); gt_option_parser_add_option(op, option); gt_option_is_development_option(option); /* -singlescan */ option = gt_option_new_uint("singlescan", "run a single scan: 1=fast; " "2=fast with check; 3=fast with output; " "4=sfx-mapped4-version", &arguments->singlescan, 0); gt_option_parser_add_option(op, option); gt_option_is_development_option(option); /* -forcek */ option = gt_option_new_uint("forcek", "specify the value of k", &arguments->forcek, 0); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); option = gt_option_new_verbose(&arguments->verbose); gt_option_parser_add_option(op, option); return op; }
static GtIndexOptions* gt_index_options_register_generic_output(GtOptionParser *op, GtIndexOptions *idxo, GtStr *indexname, GtEncseqOptions *encopts) { gt_assert(idxo != NULL); gt_assert(op != NULL && idxo->type != GT_INDEX_OPTIONS_UNDEFINED && encopts != NULL); idxo->encopts = encopts; idxo->indexname = indexname != NULL ? gt_str_ref(indexname) : NULL; idxo->optionkys = gt_option_new_string("kys", "output/sort according to keys of the form " "|key| in fasta header", idxo->kysargumentstring, "nosort"); gt_option_argument_is_optional(idxo->optionkys); gt_option_imply(idxo->optionkys, gt_encseq_options_sds_option(idxo->encopts)); gt_option_parser_add_option(op, idxo->optionkys); gt_encseq_options_add_readmode_option(op, idxo->dir); if (idxo->type == GT_INDEX_OPTIONS_ESA) { idxo->optionoutsuftab = gt_option_new_bool("suf", "output suffix array (suftab) to file", &idxo->outsuftab, false); gt_option_parser_add_option(op, idxo->optionoutsuftab); idxo->optionoutlcptab = gt_option_new_bool("lcp", "output lcp table (lcptab) to file", &idxo->outlcptab, false); gt_option_parser_add_option(op, idxo->optionoutlcptab); idxo->option = gt_option_new_bool("lcpdist", "output distributions of values in lcptab", &idxo->lcpdist, false); gt_option_is_extended_option(idxo->option); gt_option_imply(idxo->option, idxo->optionoutlcptab); gt_option_parser_add_option(op, idxo->option); idxo->option = gt_option_new_bool("swallow-tail", "swallow the tail of the suffix array and lcptab", &idxo->swallow_tail, false); gt_option_is_development_option(idxo->option); gt_option_parser_add_option(op, idxo->option); idxo->optionoutbwttab = gt_option_new_bool("bwt", "output Burrows-Wheeler Transformation " "(bwttab) to file", &idxo->outbwttab, false); gt_option_exclude(idxo->optionspmopt, idxo->optionoutbwttab); gt_option_parser_add_option(op, idxo->optionoutbwttab); idxo->optionoutbcktab = gt_option_new_bool("bck", "output bucket table to file", &idxo->outbcktab, false); gt_option_parser_add_option(op, idxo->optionoutbcktab); } else { idxo->optionoutsuftab = idxo->optionoutlcptab = idxo->optionoutbwttab = NULL; idxo->sfxstrategy.spmopt_minlength = 0; #ifndef S_SPLINT_S gt_registerPackedIndexOptions(op, &idxo->bwtIdxParams, BWTDEFOPT_CONSTRUCTION, idxo->indexname); #endif } gt_option_parser_register_hook(op, gt_index_options_check_set_out_opts, idxo); return idxo; }
static GtOptionParser* gt_condenseq_compress_option_parser_new(void *tool_arguments) { GtCondenseqCompressArguments *arguments = tool_arguments; GtOptionParser *op; GtOption *option, *option_fraction; gt_assert(arguments); /* init */ op = gt_option_parser_new("[options] INPUTENCSEQ", "Compresses a GtEncseq to a UniqueEncseq."); /* -indexname */ option = gt_option_new_string("indexname", "path and basename of files to store", arguments->indexname, NULL); gt_option_parser_add_option(op, option); /* -kmersize */ option = gt_option_new_uint_min("kmersize", "kmer-size used for the seeds, default " "depends on alphabet size", &arguments->kmersize, GT_UNDEF_UINT, 2U); gt_option_parser_add_option(op, option); /* -windowsize */ option = gt_option_new_uint("windowsize", "Size of window in which to search for hit pairs " "of kmers, has to be larger than kmersize" , &arguments->windowsize, GT_UNDEF_UINT); gt_option_parser_add_option(op, option); /* -initsize */ option = gt_option_new_uword("initsize", "length of inital unique database in bases, " "should be larger than -alignlength", &arguments->initsize, GT_UNDEF_UWORD); gt_option_parser_add_option(op, option); /* -alignlength */ option = gt_option_new_uword("alignlength", "required minimal length of an xdrop-alignment, " "should be larger than -windowsize", &arguments->minalignlength, GT_UNDEF_UWORD); gt_option_parser_add_option(op, option); /* -cutoff */ option = gt_option_new_uword("cutoff", "if a kmer is found more often than this value " "it will be ignored for alignment searches. " "Setting this to 0 will disable cutoffs, " "leaving it undefined will use a cutoff based " "on the mean number of occurences of a k-word.", &arguments->cutoff_value, GT_UNDEF_UWORD); gt_option_is_extended_option(option); gt_option_parser_add_option(op, option); /* -fraction */ option_fraction = gt_option_new_uword("fraction", "when cutoffs aren'd disabled and no specific " "value is set the mean number of occurrences " "of each kmer divided by -fraction will be used " "as cutoff", &arguments->fraction, (GtUword) 2); gt_option_is_extended_option(option_fraction); gt_option_exclude(option, option_fraction); gt_option_parser_add_option(op, option_fraction); /* -disable_prune */ option = gt_option_new_bool("disable_prune", "when cutoffs and this option are set, " "the database will still save every kmer, even " "though only cutoff many kmers will be used.", &arguments->prune, false); gt_option_is_extended_option(option); gt_option_parser_add_option(op, option); /* -mat */ option = gt_option_new_int("mat", "matchscore for extension-alignment, " "requirements: mat > mis, mat > 2ins, mat > 2del", &arguments->scores.mat, 2); gt_option_is_extended_option(option); gt_option_parser_add_option(op, option); /* -mis */ option = gt_option_new_int("mis", "mismatchscore for extension-alignment, ", &arguments->scores.mis, -1); gt_option_is_extended_option(option); gt_option_parser_add_option(op, option); /* -ins */ option = gt_option_new_int("ins", "insertionscore for extension-alignment", &arguments->scores.ins, -2); gt_option_is_extended_option(option); gt_option_parser_add_option(op, option); /* -del */ option = gt_option_new_int("del", "deletionscore for extension-alignment", &arguments->scores.del, -2); gt_option_is_extended_option(option); gt_option_parser_add_option(op, option); /* -xdrop */ option = gt_option_new_word("xdrop", "xdrop score for extension-alignment", &arguments->xdrop, (GtWord) 3); gt_option_is_extended_option(option); gt_option_parser_add_option(op, option); /* -brute_force */ option = gt_option_new_bool("brute_force", "disable filtering of seeds. " "Incompatible with -diagonals yes " "or -full_diags yes", &arguments->brute, false); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); /* -diagonals */ option = gt_option_new_bool("diagonals", "use sparse diagonals. " "Incompatible with -brute_force yes. " "Disabling both diagonals will result in simple " "filtering of seed positions.", &arguments->diags, false); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); /* -full_diags */ option = gt_option_new_bool("full_diags", "use full (time efficient " "space inefficient) diagonals. " "Incompatible with -brute_force yes. " "Disabling both diagonals will result in simple " "filtering of seed positions.", &arguments->full_diags, false); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); /* -clean_percent */ option = gt_option_new_uint("diags_clean", "Percentage of sparse diagonals that is allowed " "to be marked as deletable. Sensible default is " "set." , &arguments->clean_percent, GT_UNDEF_UINT); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); /* -verbose */ option = gt_option_new_bool("verbose", "enable verbose output", &arguments->verbose, false); gt_option_parser_add_option(op, option); /* -kdb*/ option = gt_option_new_bool("kdb", "prints out the kmer database (frequency " "of each kmer), if -verbose each startposition " "will be shown instead", &arguments->kdb, false); gt_option_parser_add_option(op, option); return op; }
static GtIndexOptions* gt_index_options_register_generic_create( GtOptionParser *op, GtIndexOptionsIndexType t) { GtIndexOptions *idxo; gt_assert(op != NULL && t != GT_INDEX_OPTIONS_UNDEFINED); idxo = gt_index_options_new(); idxo->type = t; idxo->optionprefixlength = gt_option_new_uint_min("pl", "specify prefix length for bucket sort\n" "recommendation: use without argument;\n" "then a reasonable prefix length is " "automatically determined.", &idxo->prefixlength, GT_PREFIXLENGTH_AUTOMATIC, 1U); gt_option_argument_is_optional(idxo->optionprefixlength); gt_option_parser_add_option(op, idxo->optionprefixlength); idxo->optionuserdefinedsortmaxdepth = gt_option_new_uint_min("sortmaxdepth","sort only up to the given depth.", &idxo->sfxstrategy.userdefinedsortmaxdepth, 0, 1U); gt_option_parser_add_option(op, idxo->optionuserdefinedsortmaxdepth); gt_option_is_development_option(idxo->optionuserdefinedsortmaxdepth); idxo->optiondifferencecover = gt_option_new_uint_min("dc", "specify difference cover value", &idxo->sfxstrategy.differencecover, 0, 4U); gt_option_parser_add_option(op, idxo->optiondifferencecover); gt_option_exclude(idxo->optionuserdefinedsortmaxdepth, idxo->optiondifferencecover); idxo->optioncmpcharbychar = gt_option_new_bool("cmpcharbychar", "compare suffixes character " "by character", &idxo->sfxstrategy.cmpcharbychar, false); gt_option_is_development_option(idxo->optioncmpcharbychar); gt_option_parser_add_option(op, idxo->optioncmpcharbychar); idxo->optionnoshortreadsort = gt_option_new_bool("noshortreadsort", "do not use short read sort", &idxo->sfxstrategy.noshortreadsort, false); gt_option_is_development_option(idxo->optionnoshortreadsort); gt_option_parser_add_option(op, idxo->optionnoshortreadsort); idxo->optionmaxwidthrealmedian = gt_option_new_uword("maxwidthrealmedian", "compute real median for " "intervals of at most the " "given widthprefixes", &idxo->sfxstrategy. maxwidthrealmedian, 1UL); gt_option_is_development_option(idxo->optionmaxwidthrealmedian); gt_option_parser_add_option(op, idxo->optionmaxwidthrealmedian); idxo->optionalgbounds = gt_option_new_string_array("algbds", "length boundaries for the different " "algorithms to sort buckets of suffixes\n" "first number: maxbound for insertion sort\n" "second number: maxbound for blindtrie sort\n" "third number: maxbound for counting sort", idxo->algbounds); gt_option_is_development_option(idxo->optionalgbounds); gt_option_parser_add_option(op, idxo->optionalgbounds); idxo->optionstorespecialcodes = gt_option_new_bool("storespecialcodes", "store special codes (this may speed up the program)", &idxo->sfxstrategy.storespecialcodes,false); gt_option_is_development_option(idxo->optionstorespecialcodes); gt_option_parser_add_option(op, idxo->optionstorespecialcodes); idxo->optionparts = gt_option_new_uint_max("parts", "specify number of parts in which the index " "construction is performed", &idxo->numofparts, 1U, (unsigned) ((1 << 22) - 1)); gt_option_is_development_option(idxo->optionparts); gt_option_parser_add_option(op, idxo->optionparts); if (idxo->type == GT_INDEX_OPTIONS_ESA) { idxo->optionspmopt = gt_option_new_uint_min("spmopt", "optimize esa-construction for " "suffix-prefix matching", &idxo->sfxstrategy.spmopt_minlength, 0,1U); gt_option_parser_add_option(op, idxo->optionspmopt); gt_option_exclude(idxo->optionspmopt, idxo->optiondifferencecover); idxo->optionmemlimit = gt_option_new_string("memlimit", "specify maximal amount of memory to be used during " "index construction (in bytes, the keywords 'MB' " "and 'GB' are allowed)", idxo->memlimit, NULL); gt_option_parser_add_option(op, idxo->optionmemlimit); gt_option_exclude(idxo->optionmemlimit, idxo->optionparts); } idxo->option = gt_option_new_bool("iterscan", "use iteratorbased-kmer scanning", &idxo->sfxstrategy.iteratorbasedkmerscanning, false); gt_option_is_development_option(idxo->option); gt_option_parser_add_option(op, idxo->option); idxo->option = gt_option_new_bool("samplewithprefixlengthnull", "sort sample with prefixlength=0", &idxo->sfxstrategy.samplewithprefixlengthnull, false); gt_option_is_development_option(idxo->option); gt_option_parser_add_option(op, idxo->option); idxo->option = gt_option_new_bool("suftabuint", "use uint32_t for suftab", &idxo->sfxstrategy.suftabuint, false); gt_option_is_development_option(idxo->option); gt_option_parser_add_option(op, idxo->option); idxo->option = gt_option_new_bool("onlybucketinsertion", "perform only bucket insertion", &idxo->sfxstrategy.onlybucketinsertion, false); gt_option_is_development_option(idxo->option); gt_option_parser_add_option(op, idxo->option); idxo->option = gt_option_new_bool("kmerswithencseqreader", "always perform kmerscanning with encseq-reader", &idxo->sfxstrategy.kmerswithencseqreader, false); gt_option_is_development_option(idxo->option); gt_option_parser_add_option(op, idxo->option); idxo->option = gt_option_new_bool("dccheck", "check intermediate results in difference cover", &idxo->sfxstrategy.dccheck, false); gt_option_is_development_option(idxo->option); gt_option_parser_add_option(op, idxo->option); idxo->option = gt_option_new_bool("withradixsort", "use radixsort to sort the buckets", &idxo->sfxstrategy.withradixsort, false); gt_option_is_development_option(idxo->option); gt_option_parser_add_option(op, idxo->option); idxo->option = gt_option_new_bool("compressedoutput", "output suftab and lcptab in compressed " "form", &idxo->sfxstrategy.compressedoutput, false); gt_option_is_development_option(idxo->option); gt_option_parser_add_option(op, idxo->option); gt_option_parser_register_hook(op, gt_index_options_check_set_create_opts, idxo); return idxo; }
static GtOptionParser* gtr_option_parser_new(GtR *gtr) { GtOptionParser *op; GtOption *o, *only_option, *debug_option, *debugfp_option; gt_assert(gtr); op = gt_option_parser_new("[option ...] [tool | script] [argument ...]", "The GenomeTools genome analysis system."); gt_option_parser_set_comment_func(op, show_gtr_help, gtr->tools); o = gt_option_new_bool("i", "enter interactive mode after executing 'tool' or " "'script'", >r->interactive, false); gt_option_hide_default(o); gt_option_parser_add_option(op, o); o = gt_option_new_bool("q", "suppress warnings", >r->quiet, false); gt_option_hide_default(o); gt_option_parser_add_option(op, o); o = gt_option_new_uint_min("j", "set number of parallel threads used at once", >_jobs, 1, 1); gt_option_is_development_option(o); gt_option_parser_add_option(op, o); o = gt_option_new_bool("test", "perform unit tests and exit", >r->test, false); gt_option_hide_default(o); gt_option_parser_add_option(op, o); only_option = gt_option_new_string("only", "perform single unit test " "(requires -test)", gtr->test_only, ""); gt_option_imply(only_option, o); gt_option_is_development_option(only_option); gt_option_hide_default(only_option); gt_option_parser_add_option(op, only_option); debug_option = gt_option_new_debug(>r->debug); gt_option_parser_add_option(op, debug_option); debugfp_option = gt_option_new_string("debugfp", "set file pointer for debugging output\n" "use ``stdout'' for standard output\n" "use ``stderr'' for standard error\n" "or any other string to use the " "corresponding file (will be overwritten " "without warning!)", gtr->debugfp, "stderr"); gt_option_is_development_option(debugfp_option); gt_option_parser_add_option(op, debugfp_option); gt_option_imply(debugfp_option, debug_option); o = gt_option_new_uint("seed", "set seed for random number generator manually.\n" "0 generates a seed from current time and process id", >r->seed, gtr->seed); gt_option_hide_default(o); gt_option_parser_add_option(op, o); o = gt_option_new_bool("64bit", "exit with code 0 if this is a 64bit binary, " "with 1 otherwise", >r->check64bit, false); gt_option_is_development_option(o); gt_option_parser_add_option(op, o); o = gt_option_new_bool("list", "list all tools and exit", >r->list, false); gt_option_is_development_option(o); gt_option_hide_default(o); gt_option_parser_add_option(op, o); o = gt_option_new_filename("testspacepeak", "alloc 64 MB and mmap the given " "file", gtr->testspacepeak); gt_option_is_development_option(o); gt_option_parser_add_option(op, o); o = gt_option_new_string("createman", "create man page sources in directory", gtr->manoutdir, ""); gt_option_is_development_option(o); gt_option_parser_add_option(op, o); return op; }
static GtOptionParser* gt_gff3_option_parser_new(void *tool_arguments) { GFF3Arguments *arguments = tool_arguments; GtOptionParser *op; GtOption *sort_option, *load_option, *strict_option, *tidy_option, *mergefeat_option, *addintrons_option, *offset_option, *offsetfile_option, *setsource_option, *option; gt_assert(arguments); /* init */ op = gt_option_parser_new("[option ...] [GFF3_file ...]", "Parse, possibly " "transform, and output GFF3 files."); /* -sort */ sort_option = gt_option_new_bool("sort", "sort the GFF3 features (memory " "consumption is proportional to the input " "file size(s))", &arguments->sort, false); gt_option_parser_add_option(op, sort_option); /* -strict */ strict_option = gt_option_new_bool("strict", "be very strict during GFF3 " "parsing (stricter than the specification " "requires)", &arguments->strict, false); gt_option_is_development_option(strict_option); gt_option_parser_add_option(op, strict_option); /* -tidy */ tidy_option = gt_option_new_bool("tidy", "try to tidy the GFF3 files up " "during parsing", &arguments->tidy, false); gt_option_parser_add_option(op, tidy_option); gt_option_exclude(strict_option, tidy_option); /* -retainids */ option = gt_option_new_bool("retainids", "when available, use the original IDs provided " "in the source file\n" "(memory consumption is proportional to the " "input file size(s))", &arguments->retainids, false); gt_option_parser_add_option(op, option); /* -checkids */ option = gt_option_new_bool("checkids", "make sure the ID attributes are unique " "within the scope of each GFF3_file, as required " "by GFF3 specification\n" "(memory consumption is proportional to the " "input file size(s))", &arguments->checkids, false); gt_option_parser_add_option(op, option); /* -addids */ option = gt_option_new_bool("addids", "add missing \"" GT_GFF_SEQUENCE_REGION"\" lines automatically", &arguments->addids, true); gt_option_parser_add_option(op, option); /* -fixregionboundaries */ option = gt_option_new_bool("fixregionboundaries", "automatically adjust \"" GT_GFF_SEQUENCE_REGION"\" lines to contain all " "their features (memory consumption is " "proportional to the input file size(s))", &arguments->fixboundaries, false); gt_option_parser_add_option(op, option); /* -mergefeat */ mergefeat_option = gt_option_new_bool("mergefeat", "merge adjacent features of the same " "type", &arguments->mergefeat, false); gt_option_is_development_option(mergefeat_option); gt_option_imply(mergefeat_option, sort_option); gt_option_parser_add_option(op, mergefeat_option); /* -load */ load_option = gt_option_new_bool("load", "load the GFF3 features into memory " "(requires space proportional to the input " "file size(s))", &arguments->load, false); gt_option_is_development_option(load_option); gt_option_parser_add_option(op, load_option); /* -addintrons */ addintrons_option = gt_option_new_bool("addintrons", "add intron features " "between existing exon features", &arguments->addintrons, false); gt_option_parser_add_option(op, addintrons_option); /* -offset */ offset_option = gt_option_new_word("offset", "transform all features by the " "given offset", &arguments->offset, GT_UNDEF_WORD); gt_option_parser_add_option(op, offset_option); /* -offsetfile */ offsetfile_option = gt_option_new_filename("offsetfile", "transform all " "features by the offsets given in " "file", arguments->offsetfile); gt_option_parser_add_option(op, offsetfile_option); gt_option_exclude(offset_option, offsetfile_option); /* -setsource */ setsource_option = gt_option_new_string("setsource", "set the 'source' " "value (2nd column) of each feature", arguments->newsource, NULL); gt_option_parser_add_option(op, setsource_option); /* typecheck options */ gt_typecheck_info_register_options(arguments->tci, op); /* -show */ option = gt_option_new_bool("show", "show GFF3 output", &arguments->show, true); gt_option_parser_add_option(op, option); /* -v */ option = gt_option_new_verbose(&arguments->verbose); gt_option_parser_add_option(op, option); /* -width */ option = gt_option_new_width(&arguments->width); gt_option_parser_add_option(op, option); /* output file options */ gt_output_file_info_register_options(arguments->ofi, op, &arguments->outfp); /* set comment function */ gt_option_parser_set_comment_func(op, gt_gtdata_show_help, NULL); return op; }
static GtOptionParser* gt_gdiffcalc_option_parser_new(void *tool_arguments) { GtGenomediffArguments *arguments = tool_arguments; GtOptionParser *op; GtOption *option, *option_unitfile; gt_assert(arguments); /* init */ op = gt_option_parser_new("[option ...] " "-indexname NAME AVGSHULEN) ", "Calculates Kr: pairwise distances between genomes."); /* options */ option = gt_option_new_string("indexname", "Basename of encseq to construct.", arguments->indexname, NULL); gt_option_is_mandatory(option); gt_option_parser_add_option(op, option); /*-unitfile*/ option_unitfile = gt_option_new_filename("unitfile", "specifies genomic units, see below for description", arguments->unitfile); gt_option_parser_add_option(op, option_unitfile); arguments->ref_unitfile = gt_option_ref(option_unitfile); /* encseq options */ arguments->loadopts = gt_encseq_options_register_loading(op, arguments->indexname); gt_option_is_development_option( gt_encseq_options_lossless_option(arguments->loadopts)); /* dev options */ /* -max_n */ option = gt_option_new_uword("max_n", "Number of precalculated values " "for ln(n!) and pmax(x)", &arguments->max_ln_n_fac, 1000UL); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); /* thresholds */ /* divergence error */ option = gt_option_new_double("thr", "Threshold for difference (du, dl) in " "divergence calculation.\n" "default: 1e-9", &arguments->divergence_threshold, 1e-9); gt_option_is_extended_option(option); gt_option_hide_default(option); gt_option_parser_add_option(op, option); /* expected shulen error */ option = gt_option_new_double("abs_err", "absolute error for expected shulen " "calculation.\n" "default: 1e-5", &arguments->divergence_abs_err, 1e-5); gt_option_is_extended_option(option); gt_option_hide_default(option); gt_option_parser_add_option(op, option); /* relative expected shulen error */ option = gt_option_new_double("rel_err", "relative error for expected shulen " "calculation.\n" "default: 1e-3", &arguments->divergence_rel_err, 1e-3); gt_option_is_extended_option(option); gt_option_hide_default(option); gt_option_parser_add_option(op, option); /* M */ option = gt_option_new_double("M", "threshold for minimum logarithm.\n" "default: DBL_MIN", &arguments->divergence_m, DBL_MIN); gt_option_is_extended_option(option); gt_option_hide_default(option); gt_option_parser_add_option(op, option); /* -v */ option = gt_option_new_verbose(&arguments->verbose); gt_option_parser_add_option(op, option); /* mail */ gt_option_parser_set_mail_address(op, "<*****@*****.**>"); /* doc */ gt_option_parser_set_comment_func(op, gt_gtdata_show_help, NULL); return op; }
static GtOptionParser* gt_seed_extend_option_parser_new(void *tool_arguments) { GtSeedExtendArguments *arguments = tool_arguments; GtOptionParser *op; GtOption *option, *op_gre, *op_xdr, *op_cam, *op_his, *op_dif, *op_pmh, *op_len, *op_err, *op_xbe, *op_sup, *op_frq, *op_mem, *op_ali, *op_bia; gt_assert(arguments != NULL); /* init */ op = gt_option_parser_new("[option ...] encseq_basename [encseq_basename]", "Calculate local alignments using the seed and " "extend algorithm."); /* DIAGBANDSEED OPTIONS */ /* -ii */ option = gt_option_new_string("ii", "Input index for encseq encoded sequences", arguments->dbs_indexname, ""); gt_option_is_mandatory(option); gt_option_parser_add_option(op, option); /* -qii */ option = gt_option_new_string("qii", "Query input index (encseq)", arguments->dbs_queryname, ""); gt_option_parser_add_option(op, option); /* -seedlength */ op_len = gt_option_new_uint_min_max("seedlength", "Minimum length of a seed", &arguments->dbs_seedlength, 14UL, 1UL, 32UL); gt_option_parser_add_option(op, op_len); /* -diagbandwidth */ option = gt_option_new_uword("diagbandwidth", "Logarithm of diagonal band width (for filter)", &arguments->dbs_logdiagbandwidth, 6UL); gt_option_parser_add_option(op, option); /* -mincoverage */ option = gt_option_new_uword("mincoverage", "Minimum coverage in two neighbouring diagonal " "bands (for filter)", &arguments->dbs_mincoverage, 35UL); gt_option_parser_add_option(op, option); /* -maxfreq */ op_frq = gt_option_new_uword_min("maxfreq", "Maximum frequency of a k-mer (for filter)", &arguments->dbs_maxfreq, GT_UWORD_MAX, 1UL); gt_option_parser_add_option(op, op_frq); /* -t */ op_sup = gt_option_new_uword_min("t", "Suppress k-mers occurring at least t times " "(for filter)", &arguments->dbs_suppress, GT_UWORD_MAX, 2UL); gt_option_exclude(op_sup, op_frq); gt_option_is_development_option(op_sup); gt_option_parser_add_option(op, op_sup); /* -memlimit */ op_mem = gt_option_new_string("memlimit", "Maximum memory usage to determine the maximum " "frequency of a k-mer (for filter)", arguments->dbs_memlimit_str, ""); gt_option_parser_add_option(op, op_mem); /* -debug-kmer */ option = gt_option_new_bool("debug-kmer", "Output KmerPos lists", &arguments->dbs_debug_kmer, false); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); /* -debug-seedpair */ option = gt_option_new_bool("debug-seedpair", "Output SeedPair lists", &arguments->dbs_debug_seedpair, false); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); /* -verify */ option = gt_option_new_bool("verify", "Check that k-mer seeds occur in the sequences", &arguments->dbs_verify, false); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); /* SEED EXTENSION OPTIONS */ /* -extendxdrop */ op_xdr = gt_option_new_uword_min_max("extendxdrop", "Extend seed to both sides using xdrop " "algorithm, optional parameter " "specifies sensitivity", &arguments->se_extendxdrop, 97UL, 90UL, 100UL); gt_option_argument_is_optional(op_xdr); gt_option_parser_add_option(op, op_xdr); arguments->se_option_xdrop = gt_option_ref(op_xdr); /* -xdropbelow */ op_xbe = gt_option_new_word("xdropbelow", "Specify xdrop cutoff score (0 means " "automatically defined depending on minidentity)", &arguments->se_xdropbelowscore, 0L); gt_option_imply(op_xbe, op_xdr); gt_option_parser_add_option(op, op_xbe); /* -extendgreedy */ op_gre = gt_option_new_uword_min_max("extendgreedy", "Extend seed to both sides using greedy " "algorithm, optional parameter " "specifies sensitivity", &arguments->se_extendgreedy, 97UL, 90UL, 100UL); gt_option_argument_is_optional(op_gre); gt_option_exclude(op_gre, op_xdr); gt_option_parser_add_option(op, op_gre); arguments->se_option_greedy = gt_option_ref(op_gre); /* -history */ op_his = gt_option_new_uword_min_max("history", "Size of (mis)match history in range [1" "..64] (trimming for greedy extension)", &arguments->se_historysize, 60UL, 1UL, 64UL); gt_option_imply(op_his, op_gre); gt_option_parser_add_option(op, op_his); /* -maxalilendiff */ op_dif = gt_option_new_uword("maxalilendiff", "Maximum difference of alignment length " "(trimming for greedy extension)", &arguments->se_maxalilendiff, 0UL); gt_option_imply(op_dif, op_gre); gt_option_is_development_option(op_dif); gt_option_parser_add_option(op, op_dif); /* -percmathistory */ op_pmh = gt_option_new_uword_min_max("percmathistory", "percentage of matches required in " "history (for greedy extension)", &arguments->se_perc_match_hist, 0UL, 1UL, 100UL); gt_option_imply(op_pmh, op_gre); gt_option_is_development_option(op_pmh); gt_option_parser_add_option(op, op_pmh); /* -bias-parameters */ op_bia = gt_option_new_bool("bias-parameters", "Use -maxalilendiff 30 and let percmathistory " "depend on minidentiy and DNA base distribution", &arguments->bias_parameters, false); gt_option_imply(op_bia, op_gre); gt_option_exclude(op_bia, op_pmh); gt_option_exclude(op_bia, op_dif); gt_option_is_development_option(op_bia); gt_option_parser_add_option(op, op_bia); /* -cam */ op_cam = gt_option_new_string("cam", gt_cam_extendgreedy_comment(), arguments->se_char_access_mode, ""); gt_option_is_development_option(op_cam); gt_option_parser_add_option(op, op_cam); /* -l */ op_len = gt_option_new_uword_min("l", "Minimum alignment length " "(for seed extension)", &arguments->se_alignlength, 20UL, 1UL); gt_option_imply_either_2(op_len, op_xdr, op_gre); gt_option_parser_add_option(op, op_len); /* -minidentity */ op_err = gt_option_new_uword_min_max("minidentity", "Minimum identity of matches " "(for seed extension)", &arguments->se_minidentity, 80UL, GT_EXTEND_MIN_IDENTITY_PERCENTAGE, 99UL); gt_option_imply_either_2(op_err, op_xdr, op_gre); gt_option_parser_add_option(op, op_err); /* -a */ op_ali = gt_option_new_uword_min("a", "show alignments/sequences (optional " "argument is number of columns per line)", &arguments->se_alignmentwidth, 70, 20); gt_option_argument_is_optional(op_ali); gt_option_parser_add_option(op, op_ali); arguments->se_option_withali = gt_option_ref(op_ali); /* -mirror */ option = gt_option_new_bool("mirror", "Add reverse complement reads", &arguments->mirror, false); gt_option_parser_add_option(op, option); /* -overlappingseeds */ option = gt_option_new_bool("overlappingseeds", "Allow overlapping SeedPairs", &arguments->overlappingseeds, false); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); /* -benchmark */ option = gt_option_new_bool("benchmark", "Measure total running time and be silent", &arguments->benchmark, false); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); /* -seed-display */ option = gt_option_new_bool("seed-display", "Display seeds in #-line", &arguments->seed_display, false); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); /* -v */ option = gt_option_new_verbose(&arguments->verbose); gt_option_parser_add_option(op, option); return op; }
static GtOptionParser* gt_eval_option_parser_new(void *tool_arguments) { EvalArguments *arguments = tool_arguments; GtOptionParser *op; GtOption *option, *ltroption, *ltrdeltaoption; gt_assert(arguments); op = gt_option_parser_new("reference_file prediction_file ", "Compare annotation files and show " "accuracy measures (prediction vs. reference)."); /* -exondiff */ option = gt_option_new_bool("exondiff", "show a diff for the exons", &arguments->exondiff, false); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); /* -exondiffcollapsed */ option = gt_option_new_bool("exondiffcollapsed", "show a diff for the " "collapsed exons", &arguments->exondiffcollapsed, false); gt_option_is_development_option(option); gt_option_parser_add_option(op, option); /* -nuc */ option = gt_option_new_bool("nuc", "evaluate nucleotide level (memory consumption " "is proportional to the input file sizes)", &arguments->nuceval, true); gt_option_parser_add_option(op, option); /* -ltr */ ltroption = gt_option_new_bool("ltr", "evaluate a LTR retrotransposon " "prediction instead of a gene prediction\n" "(all LTR_retrotransposon elements are " "considered to have an undetermined strand)", &arguments->evalLTR, false); gt_option_parser_add_option(op, ltroption); /* -ltrdelta */ ltrdeltaoption = gt_option_new_uword("ltrdelta", "set allowed delta for LTR " "borders to be considered equal", &arguments->LTRdelta, 20); gt_option_parser_add_option(op, ltrdeltaoption); /* -v */ option = gt_option_new_verbose(&arguments->verbose); gt_option_parser_add_option(op, option); /* output file options */ gt_output_file_info_register_options(arguments->ofi, op, &arguments->outfp); /* option implications */ gt_option_imply(ltrdeltaoption, ltroption); /* set comment function */ gt_option_parser_set_comment_func(op, gt_gtdata_show_help, NULL); /* set minimum and maximum number of arguments */ gt_option_parser_set_min_max_args(op, 2, 2); return op; }