static GtOptionParser* gt_seqfilter_option_parser_new(void *tool_arguments) { SeqFilterArguments *arguments = tool_arguments; GtOption *option; GtOptionParser *op; gt_assert(arguments); op = gt_option_parser_new("[option ...] [sequence_file ...]", "Filter the given sequence file(s) and show the " "results on stdout."); /* -minlength */ option = gt_option_new_uword("minlength", "set minimum length a sequence must " "have to pass the filter", &arguments->minlength, GT_UNDEF_UWORD); gt_option_parser_add_option(op, option); /* -maxlength */ option = gt_option_new_uword("maxlength", "set maximum length a sequence can " "have to pass the filter", &arguments->maxlength, GT_UNDEF_UWORD); gt_option_parser_add_option(op, option); /* -maxseqnum */ option = gt_option_new_uword("maxseqnum", "set the maximum number of " "sequences which can pass the filter", &arguments->maxseqnum, GT_UNDEF_UWORD); gt_option_parser_add_option(op, option); /* -sample */ option = gt_option_new_double_min_max("sample", "set a probability for each " "sequence to pass the filter", &arguments->sample_prob, SEQFILTER_DEF_PROB, SEQFILTER_MIN_PROB, SEQFILTER_MAX_PROB); gt_option_parser_add_option(op, option); /* -step */ option = gt_option_new_uword_min("step", "only every 'step'-th sequence " "passes the filter", &arguments->step, SEQFILTER_DEF_STEP, SEQFILTER_MIN_STEP); gt_option_parser_add_option(op, option); /* -width */ option = gt_option_new_width(&arguments->width); gt_option_parser_add_option(op, option); gt_output_file_info_register_options(arguments->ofi, op, &arguments->outfp); return op; }
static GtOptionParser* gt_splitfasta_option_parser_new(void *tool_arguments) { SplitfastaArguments *arguments = tool_arguments; GtOptionParser *op; GtOption *targetsize_option, *splitdesc_option, *o, *numfiles_option; gt_assert(arguments); op = gt_option_parser_new("[option ...] fastafile","Split the supplied fasta " "file."); numfiles_option = gt_option_new_uint_min("numfiles", "set the number of target files " "", &arguments->num_files, 0, 1); gt_option_parser_add_option(op, numfiles_option); targetsize_option = gt_option_new_uword_min("targetsize", "set the target file " "size in MB", &arguments->max_filesize_in_MB, 50, 1); gt_option_parser_add_option(op, targetsize_option); splitdesc_option = gt_option_new_string("splitdesc", "put every fasta entry in " "a separate file named by its " "description in the given directory", arguments->splitdesc, NULL); gt_option_parser_add_option(op, splitdesc_option); gt_option_exclude(targetsize_option, splitdesc_option); gt_option_exclude(numfiles_option, splitdesc_option); gt_option_exclude(numfiles_option, targetsize_option); o = gt_option_new_width(&arguments->width); gt_option_parser_add_option(op, o); o = gt_option_new_bool(GT_FORCE_OPT_CSTR, "force writing to output file", &arguments->force, false); gt_option_parser_add_option(op, o); gt_option_parser_set_min_max_args(op, 1, 1); return op; }
static GtOptionParser* gt_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_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_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_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_kmer_database_option_parser_new(void *tool_arguments) { GtKmerDatabaseArguments *arguments = tool_arguments; GtOptionParser *op; GtOption *option, *option_verbose, *option_use_cutoff, *option_hash, *option_mean_cutoff; gt_assert(arguments); /* init */ op = gt_option_parser_new("[option ...] [file]", "Makes a GtKmerDatabase from the input file."); /* -kmersize */ option = gt_option_new_uint_min_max("kmersize", "kmersize used", &arguments->kmersize, 3U, 1U, 10U); gt_option_parser_add_option(op, option); /* -verbose */ option_verbose = gt_option_new_bool("verbose", "prints out results of " "merging", &arguments->verbose, false); gt_option_parser_add_option(op, option_verbose); /* -merge_only */ option = gt_option_new_bool("merge_only", "only uses merge to build DB, " "doesn_t build two DBs to compare merge with a " "different method (much faster). It also allows " "for random intervals which are biffer than the " "maximum buffer size (will be split internally).", &arguments->merge_only, false); gt_option_parser_add_option(op, option); /* -use_cutoff */ option_use_cutoff = gt_option_new_bool("use_cutoff", "uses a cutoff. see " "-set_cutoff description. Only works " "with merge_only", &arguments->cutoff, false); gt_option_parser_add_option(op, option_use_cutoff); gt_option_imply(option_use_cutoff, option); /* -set_cutoff */ option = gt_option_new_uword_min("set_cutoff", "kmers occuring more often " "than this value won't be saved", &arguments->cutoff_value, (GtUword) 30, (GtUword) 1); gt_option_parser_add_option(op, option); gt_option_imply(option, option_use_cutoff); /* -mean_cutoff */ option_mean_cutoff = gt_option_new_bool("mean_cutoff", "2*mean of kmer " "occurrence will be" " used as cutoff value", &arguments->mean_cutoff, false); gt_option_parser_add_option(op, option_mean_cutoff); gt_option_imply(option_mean_cutoff, option_use_cutoff); gt_option_exclude(option_mean_cutoff, option); /* -disable_prune */ option = gt_option_new_bool("disable_prune", "disables the removel of kmers, " "which occure more often than the cutoff.", &arguments->prune, false); gt_option_parser_add_option(op, option); gt_option_imply(option, option_use_cutoff); /* -use_hash */ option_hash = gt_option_new_bool("use_hash", "saves each kmer in kdb and " "also in a hash. afterwards both will be " "accessed and time for saving and " "accessing will be shown.", &arguments->use_hash, false); gt_option_parser_add_option(op, option_hash); gt_option_exclude(option_hash, option_use_cutoff); gt_option_exclude(option_hash, option_verbose); /* -benchmark */ option = gt_option_new_bool("benchmark", "measures the time the tool takes to" " fill the database. Doesn't test for consistency" " though!", &arguments->bench, false); gt_option_parser_add_option(op, option); /* -bsize */ option = gt_option_new_uword_min("bsize", "size of the buffer", &arguments->sb_size, (GtUword) 100000, (GtUword) 2); gt_option_parser_add_option(op, option); gt_option_exclude(option, option_hash); /* -outfile */ option = gt_option_new_string("outfile", "specifies file for verbose output", arguments->print_filename, NULL); gt_option_parser_add_option(op, option); return op; }
static GtOptionParser* gt_tir_option_parser_new(void *tool_arguments) { GtTirArguments *arguments = tool_arguments; GtOptionParser *op; GtOption *optionindex, /* index */ *optionseed, /* minseedlength */ *optionminlentir, /* minimal length of TIR */ *optionmaxlentir, /* maximal length of TIR */ *optionmindisttir, /* minimal distance of TIRs */ *optionmaxdisttir, /* maximal distance of TIRs */ *optionmat, /* arbitrary scores */ *optionmis, *optionins, *optiondel, *optionxdrop, /* xdropbelowscore for extension alignment */ *optionsimilar, /* similarity threshold */ *optionoverlaps, /* for overlaps */ *optionmintsd, /* minimal length for Target Site Duplication */ *optionmaxtsd, /* maximal length for Target Site Duplication */ *optionvicinity, /* vicinity around TIRs to be searched for TSDs */ *optionhmms, *optionevalcutoff, *optionpdomcutoff, *optionmaxgap; static const char *overlaps[] = { "best", /* default */ "no", "all", NULL }; static const char *cutoffs[] = { "NONE", "GA", "TC", NULL }; gt_assert(arguments); /* init */ op = gt_option_parser_new("[option ...] -index INDEXNAME", "Identify Terminal Inverted Repeat (TIR) elements," "such as DNA transposons."); /* -index */ optionindex = gt_option_new_string("index", "specify the name of the enhanced suffix " "array index (mandatory)", arguments->str_indexname, NULL); gt_option_is_mandatory(optionindex); gt_option_parser_add_option(op, optionindex); /* -seed */ optionseed = gt_option_new_uword_min("seed", "specify minimum seed length for " "exact repeats", &arguments->min_seed_length, 20UL, 2UL); gt_option_parser_add_option(op, optionseed); /* -minlentir */ optionminlentir = gt_option_new_uword_min_max("mintirlen", "specify minimum length for " "each TIR", &arguments->min_TIR_length, 27UL, 1UL, GT_UNDEF_UWORD); gt_option_parser_add_option(op, optionminlentir); /* -maxlentir */ optionmaxlentir = gt_option_new_uword_min_max("maxtirlen", "specify maximum length for " "each TIR", &arguments->max_TIR_length, 1000UL, 1UL, GT_UNDEF_UWORD); gt_option_parser_add_option(op, optionmaxlentir); /* -mindisttir */ optionmindisttir = gt_option_new_uword_min_max("mintirdist", "specify minimum distance of " "TIRs", &arguments->min_TIR_distance, 100UL, 1UL, GT_UNDEF_UWORD); gt_option_parser_add_option(op, optionmindisttir); /* -maxdisttir */ optionmaxdisttir = gt_option_new_uword_min_max("maxtirdist", "specify maximum distance of " "TIRs", &arguments->max_TIR_distance, 10000UL, 1UL, GT_UNDEF_UWORD); gt_option_parser_add_option(op, optionmaxdisttir); optionmat = gt_option_new_int_min("mat", "specify matchscore for " "extension-alignment", &arguments->arbit_scores.mat, 2, 1); gt_option_parser_add_option(op, optionmat); /* -mis */ optionmis = gt_option_new_int_max("mis", "specify mismatchscore for " "extension-alignment", &arguments->arbit_scores.mis, -2, -1); gt_option_parser_add_option(op, optionmis); /* -ins */ optionins = gt_option_new_int_max("ins", "specify insertionscore for " "extension-alignment", &arguments->arbit_scores.ins, -3, -1); gt_option_parser_add_option(op, optionins); /* -del */ optiondel = gt_option_new_int_max("del", "specify deletionscore for " "extension-alignment", &arguments->arbit_scores.del, -3, -1); gt_option_parser_add_option(op, optiondel); /* -xdrop */ optionxdrop = gt_option_new_int_min("xdrop", "specify xdropbelowscore for " "extension-alignment", &arguments->xdrop_belowscore, (int) 5, (int) 0); gt_option_parser_add_option(op, optionxdrop); /* -similar */ optionsimilar = gt_option_new_double_min_max("similar", "specify similaritythreshold in " "range [1..100%]", &arguments->similarity_threshold, (double) 85.0, (double) 0.0, 100.0); gt_option_parser_add_option(op, optionsimilar); /* -overlaps */ optionoverlaps = gt_option_new_choice("overlaps", "specify no|best|all", arguments->str_overlaps, overlaps[0], overlaps); gt_option_parser_add_option(op, optionoverlaps); arguments->optionoverlaps = gt_option_ref(optionoverlaps); /* -mintsd */ optionmintsd = gt_option_new_uword_min_max("mintsd", "specify minimum length for each " "TSD", &arguments->min_TSD_length, 2U, 0, GT_UNDEF_UINT); gt_option_parser_add_option(op, optionmintsd); /* -maxtsd */ optionmaxtsd = gt_option_new_uword_min_max("maxtsd", "specify maximum length for each " "TSD", &arguments->max_TSD_length, 11U, 0, GT_UNDEF_UINT); gt_option_parser_add_option(op, optionmaxtsd); gt_option_imply(optionmaxtsd, optionmintsd); /* -vicinity */ optionvicinity = gt_option_new_uword_min_max("vic", "specify the number of " "nucleotides (to the left and " "to the right) that will be " "searched for TSDs around 5' " "and 3' boundary of predicted " "TIRs", &arguments->vicinity, 60U, 1U, 500U); gt_option_parser_add_option(op, optionvicinity); optionhmms = gt_option_new_filename_array("hmms", "profile HMM models for domain detection " "(separate by spaces, finish with --) in " "HMMER3 format\n" "Omit this option to disable pHMM search.", arguments->hmm_files); gt_option_parser_add_option(op, optionhmms); optionevalcutoff = gt_option_new_probability("pdomevalcutoff", "global E-value cutoff for pHMM search\n" "default 1E-6", &arguments->evalue_cutoff, 0.000001); gt_option_parser_add_option(op, optionevalcutoff); gt_option_hide_default(optionevalcutoff); gt_option_imply(optionevalcutoff, optionhmms); optionpdomcutoff = gt_option_new_choice("pdomcutoff", "model-specific score cutoff\n" "choose from TC (trusted cutoff) | " "GA (gathering cutoff) | " "NONE (no cutoffs)", arguments->cutoffs, cutoffs[1], cutoffs); gt_option_parser_add_option(op, optionpdomcutoff); gt_option_imply(optionpdomcutoff, optionhmms); /* XXX: make -pdomcutoff and -pdomevalcutoff mutually exclusive */ optionmaxgap = gt_option_new_uint("maxgaplen", "maximal allowed gap size between fragments (in amino " "acids) when chaining pHMM hits for a protein domain", &arguments->chain_max_gap_length, 50U); gt_option_parser_add_option(op, optionmaxgap); gt_option_is_extended_option(optionmaxgap); gt_option_imply(optionmaxgap, optionhmms); return op; }
static GtOptionParser* gt_sketch_page_option_parser_new(void *tool_arguments) { SketchPageArguments *arguments = tool_arguments; GtOptionParser *op; static const char *formats[] = { #ifdef CAIRO_HAS_PDF_SURFACE "pdf", #endif #ifdef CAIRO_HAS_PS_SURFACE "ps", #endif NULL }; GtOption *o; op = gt_option_parser_new("outfile annotationfile", "Draw a multi-page PDF/PS representation of " "an annotation file."); o = gt_option_new_string("seqid", "sequence region to draw\n" "default: first in file", arguments->seqid, NULL); gt_option_parser_add_option(op, o); gt_option_hide_default(o); o = gt_option_new_string("text", "text to show in header\n" "default: file name", arguments->text, NULL); gt_option_parser_add_option(op, o); gt_option_hide_default(o); o = gt_option_new_double("fontsize", "header and footer font size " "(in points)", &arguments->theight, 10.0); gt_option_parser_add_option(op, o); o = gt_option_new_range("range", "range to draw (e.g. 100 10000)\n" "default: full range", &arguments->range, NULL); gt_option_parser_add_option(op, o); gt_option_hide_default(o); o = gt_option_new_uword_min("linewidth", "base width of a single " "repeated unit", &arguments->width, 2000, 1000); gt_option_is_mandatory(o); gt_option_parser_add_option(op, o); o = gt_option_new_double("width", "page width in millimeters " "(default: DIN A4)", &arguments->pwidth, 210.0); gt_option_parser_add_option(op, o); o = gt_option_new_double("height", "page height in millimeters " "(default: DIN A4)", &arguments->pheight, 297.0); gt_option_parser_add_option(op, o); o = gt_option_new_choice("format", "output format\n" "choose from: " #ifdef CAIRO_HAS_PDF_SURFACE "pdf" #ifdef CAIRO_HAS_PS_SURFACE "|" #endif #endif #ifdef CAIRO_HAS_PS_SURFACE "ps" #endif "", arguments->format, formats[0], formats ); gt_option_parser_add_option(op, o); o = gt_option_new_string("style", "style file to use\n" "default: gtdata/sketch/default.style", arguments->stylefile, gt_str_get(arguments->stylefile)); gt_option_parser_add_option(op, o); gt_option_hide_default(o); o = gt_option_new_filename("seqfile", "sequence file for GC content view", arguments->seqfile); gt_option_parser_add_option(op, o); gt_option_is_extended_option(o); gt_option_parser_set_min_max_args(op, 2, 2); return op; }
static GtOptionParser* gt_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_idxlocali_option_parser_new(void *tool_arguments) { IdxlocaliOptions *arguments = tool_arguments; GtOptionParser *op; GtOption *option, *optionesaindex, *optionpckindex, *optiononline, *optioncmp; gt_assert(arguments != NULL); arguments->indexname = gt_str_new (); arguments->queryfiles = gt_str_array_new (); op = gt_option_parser_new ("[options] -q query-file-names [-esa|-pck] indexname", "Find all local alignments using suffix tree."); gt_option_parser_set_mail_address(op, "<*****@*****.**>"); option = gt_option_new_filename_array("q","Specify files containing the " "query sequences", arguments->queryfiles); gt_option_parser_add_option (op, option); option = gt_option_new_word("match", "Specify match score", &arguments->matchscore, 1L); gt_option_parser_add_option(op, option); option = gt_option_new_word("mismatch", "Specify mismatch score", &arguments->mismatchscore, -3L); gt_option_parser_add_option(op, option); option = gt_option_new_word("gapstart", "Specify gap start score", &arguments->gapstart, -5L); gt_option_parser_add_option(op, option); option = gt_option_new_word("gapextend", "Specify gap extension score", &arguments->gapextend, -2L); gt_option_parser_add_option(op, option); option = gt_option_new_uword_min("th", "Specify the threshold", &arguments->threshold, 0, 1UL); gt_option_parser_add_option(op, option); gt_option_is_mandatory(option); optionesaindex = gt_option_new_string("esa", "Specify index " "(enhanced suffix array)", arguments->indexname, NULL); gt_option_parser_add_option(op, optionesaindex); arguments->refoptionesaindex = gt_option_ref(optionesaindex); optionpckindex = gt_option_new_string("pck", "Specify index (packed index)", arguments->indexname, NULL); gt_option_parser_add_option(op, optionpckindex); arguments->refoptionpckindex = gt_option_ref (optionpckindex); gt_option_exclude (optionesaindex, optionpckindex); gt_option_is_mandatory_either(optionesaindex, optionpckindex); optiononline = gt_option_new_bool("online","Perform online searches", &arguments->doonline, false); gt_option_parser_add_option(op, optiononline); gt_option_is_development_option(optiononline); optioncmp = gt_option_new_bool("cmp","Compare results of offline and online " "searches", &arguments->docompare, false); gt_option_parser_add_option(op,optioncmp); gt_option_exclude(optiononline,optioncmp); option = gt_option_new_bool("s", "Show alignments", &arguments->showalignment, false); gt_option_parser_add_option(op, option); option = gt_option_new_verbose(&arguments->verbose); gt_option_parser_add_option(op, option); return op; }