示例#1
0
//-------------------------------------------------------------------------
void CWinMaskApplication::Init(void)
{
    HideStdArgs(fHideLogfile | fHideConffile | fHideVersion | fHideDryRun);
    auto_ptr< CArgDescriptions > arg_desc( new CArgDescriptions );

    // Set the program description
    arg_desc->SetUsageContext( GetArguments().GetProgramBasename(),
                               USAGE_LINE );

    CWinMaskConfig::AddWinMaskArgs(*arg_desc);

    // Parse the arguments according to descriptions.
    SetupArgDescriptions(arg_desc.release());
}
示例#2
0
void CSeqDBPerfApp::Init()
{
    HideStdArgs(fHideConffile | fHideFullVersion | fHideXmlHelp | fHideDryRun);

    auto_ptr<CArgDescriptions> arg_desc(new CArgDescriptions);

    // Specify USAGE context
    arg_desc->SetUsageContext(GetArguments().GetProgramBasename(), 
                  "CSeqDB performance testing client");

    arg_desc->SetCurrentGroup("BLAST database options");
    arg_desc->AddDefaultKey("db", "dbname", "BLAST database name", 
                            CArgDescriptions::eString, "nr");

    arg_desc->AddDefaultKey("dbtype", "molecule_type",
                            "Molecule type stored in BLAST database",
                            CArgDescriptions::eString, "guess");
    arg_desc->SetConstraint("dbtype", &(*new CArgAllow_Strings,
                                        "nucl", "prot", "guess"));

    arg_desc->SetCurrentGroup("Retrieval options");
    arg_desc->AddFlag("scan_uncompressed", 
                      "Do a full database scan of uncompressed sequence data", true);
    arg_desc->AddFlag("scan_compressed", 
                      "Do a full database scan of compressed sequence data", true);
    arg_desc->AddFlag("get_metadata", 
                      "Retrieve BLAST database metadata", true);
    
    arg_desc->SetDependency("scan_compressed", CArgDescriptions::eExcludes, 
                            "scan_uncompressed");
    arg_desc->SetDependency("scan_compressed", CArgDescriptions::eExcludes, 
                            "get_metadata");
    arg_desc->SetDependency("scan_uncompressed", CArgDescriptions::eExcludes, 
                            "get_metadata"); 

    arg_desc->AddDefaultKey("num_threads", "number", 
                            "Number of threads to use (requires OpenMP)",
                            CArgDescriptions::eInteger, "1");
    arg_desc->SetConstraint("num_threads", new CArgAllow_Integers(0, kMax_Int));
    //arg_desc->AddFlag("one_db_handle", "Build only 1 CSeqDB object?", true);
    //arg_desc->SetDependency("one_db_handle", CArgDescriptions::eRequires, "num_threads");

    arg_desc->SetCurrentGroup("Output configuration options");
    arg_desc->AddDefaultKey("out", "output_file", "Output file name", 
                            CArgDescriptions::eOutputFile, "-");

    SetupArgDescriptions(arg_desc.release());
}
示例#3
0
void CVecScreenApp::Init()
{
    HideStdArgs(fHideLogfile | fHideConffile | fHideFullVersion | fHideXmlHelp | fHideDryRun);
    auto_ptr<CArgDescriptions> arg_desc(new CArgDescriptions);

    arg_desc->SetUsageContext(GetArguments().GetProgramBasename(),
                              "Vector screening tool, version " +
                              CVecScreenVersion().Print());
    arg_desc->SetCurrentGroup("Input query options");
    arg_desc->AddDefaultKey(kArgQuery, "input_file", 
                     "Input file name",
                     CArgDescriptions::eInputFile, kDfltArgQuery);

    arg_desc->SetCurrentGroup("BLAST database options");
    arg_desc->AddDefaultKey(kArgDb, "dbname", "BLAST database name", 
                            CArgDescriptions::eString, kDefaultVectorDb);

    arg_desc->SetCurrentGroup("Output configuration options");
    arg_desc->AddDefaultKey(kArgOutput, "output_file", "Output file name", 
                            CArgDescriptions::eOutputFile, "-");

    //arg_desc->AddDefaultKey("outfmt", "format",
    arg_desc->AddDefaultKey(kArgOutputFormat, "format",
            "VecScreen results options:\n"
            "  0 = Show alignments pairwise,\n"
            "  1 = Do not show alignments, just contaminated range offsets\n",
            CArgDescriptions::eInteger, 
            NStr::IntToString(kDfltArgOutputFormat));
    arg_desc->SetConstraint(kArgOutputFormat, 
       new CArgAllowValuesBetween(0, CVecscreenRun::CFormatter::eEndValue-1, true));
    // Produce Text output?
    arg_desc->AddFlag("text_output", "Produce text output?", true);

    arg_desc->SetCurrentGroup("");
    SetupArgDescriptions(arg_desc.release());
}
示例#4
0
BEGIN_NCBI_SCOPE


void CCompartApp::Init()
{
    HideStdArgs(fHideLogfile | fHideConffile | fHideVersion);

    auto_ptr<CArgDescriptions> argdescr(new CArgDescriptions);
    argdescr->SetUsageContext(GetArguments().GetProgramName(),
                              "Compart v.1.35. Unless -qdb and -sdb are specified, "
                              "the tool expects tabular blast hits at stdin collated "
                              "by query and subject, e.g. with 'sort -k 1,1 -k 2,2'");

    argdescr->AddOptionalKey ("qdb", "qdb", "cDNA BLAST database", 
                              CArgDescriptions::eString);

    argdescr->AddOptionalKey ("sdb", "sdb", "Genomic BLAST database", 
                              CArgDescriptions::eString);

    argdescr->AddFlag ("ho", "Print raw hits only - no compartments");

    argdescr->AddDefaultKey("penalty", "penalty", "Per-compartment penalty",
                            CArgDescriptions::eDouble, "0.55");
    
    argdescr->AddDefaultKey("min_idty", "min_idty", "Minimal overall identity. Note: in current implementation  there is no sense to set different 'min_idty' and 'min_singleton_idty' (minimum is used anyway).",
                            CArgDescriptions::eDouble, "0.70");
    
    argdescr->AddDefaultKey("min_singleton_idty", "min_singleton_idty", 
                            "Minimal identity for singleton compartments. "
                            "The actual parameter passed to the compartmentization "
                            "procedure is least of this parameter multipled "
                            "by the seq length, and min_singleton_idty_bps. Note: in current implementation  there is no sense to set different 'min_idty' and 'min_singleton_idty' (minimum is used anyway).",
                            CArgDescriptions::eDouble, "0.70");

    argdescr->AddDefaultKey("min_singleton_idty_bps", "min_singleton_idty_bps", 
                            "Minimal identity for singleton compartments "
                            "in base pairs. Default = parameter disabled.",
                            CArgDescriptions::eInteger, "9999999");

    argdescr->AddDefaultKey ("max_intron", "max_intron", 
                             "Maximum intron length (in base pairs)",
                             CArgDescriptions::eInteger,
                             NStr::IntToString
                             (CCompartmentFinder<THit>::s_GetDefaultMaxIntron()));

    argdescr->AddDefaultKey("dropoff", "dropoff", 
                            "Max score drop-off during hit extension.",
                            CArgDescriptions::eInteger,
                            NStr::IntToString(CElementaryMatching::
                                              s_GetDefaultDropOff()));

    argdescr->AddDefaultKey("min_query_len", "min_query_len", 
                            "Minimum length for individual cDNA sequences.",
                            CArgDescriptions::eInteger, "50");

    argdescr->AddDefaultKey("min_hit_len", "min_hit_len", 
                            "Minimum length for reported hits in hits-only mode. "
                            "No effect in compartments mode.",
                            CArgDescriptions::eInteger, "16");
   
    argdescr->AddDefaultKey ("maxvol", "maxvol", 
                             "Maximum index volume size in MB (approximate)",
                             CArgDescriptions::eInteger,
                             "512");

    argdescr->AddFlag("noxf", "[With external hits] Suppress overlap x-filtering: "
                      "print all compartment hits intact.");

    argdescr->AddOptionalKey("seqlens", "seqlens", 
                             "[With external hits] Two-column file with sequence IDs "
                             "and their lengths. If none supplied, the program will "
                             "attempt fetching the lengths from GenBank. "
                             "Cannot be used with -qdb.",
                             CArgDescriptions::eInputFile);

    argdescr->AddDefaultKey("N", "N", 
                            "[With external hits] Max number of compartments "
                            "per query (0 = All).",
                            CArgDescriptions::eInteger, "0");

    CArgAllow* constrain01 (new CArgAllow_Doubles(0.0, 1.0));
    argdescr->SetConstraint("penalty", constrain01);
    argdescr->SetConstraint("min_idty", constrain01);
    argdescr->SetConstraint("min_singleton_idty", constrain01);

    CArgAllow_Integers* constrain_maxvol (new CArgAllow_Integers(128,1024));
    argdescr->SetConstraint("maxvol", constrain_maxvol);

    CArgAllow_Integers* constrain_minqlen (new CArgAllow_Integers(21,99999));
    argdescr->SetConstraint("min_query_len", constrain_minqlen);

    CArgAllow_Integers* constrain_minhitlen (new CArgAllow_Integers(1,99999));
    argdescr->SetConstraint("min_hit_len", constrain_minhitlen);

    SetupArgDescriptions(argdescr.release());
}
示例#5
0
文件: nwa.cpp 项目: DmitrySigaev/ncbi
void CAppNWA::Init()
{
    HideStdArgs(fHideLogfile | fHideConffile | fHideVersion);

    auto_ptr<CArgDescriptions> argdescr(new CArgDescriptions);
    argdescr->SetUsageContext(GetArguments().GetProgramName(),
                              "Demo application using xalgoalign library");

    argdescr->AddDefaultKey
        ("matrix", "matrix", "scoring matrix",
         CArgDescriptions::eString, "nucl");

    argdescr->AddKey
        ("seq1", "seq1",
         "the first input sequence in fasta file",
         CArgDescriptions::eString);
    argdescr->AddKey
        ("seq2", "seq2",
         "the second input sequence in fasta file",
         CArgDescriptions::eString);

    argdescr->AddDefaultKey
        ("esf", "esf",
         "End-space free alignment. Format: lrLR where each character "
         "can be z (free end) or x (regular end) representing "
         "left and right ends. First sequence's ends are specified first.", 
         CArgDescriptions::eString,
         "xxxx");

    argdescr->AddDefaultKey
        ("Wm", "match", "match bonus (nucleotide sequences)",
         CArgDescriptions::eInteger,
         NStr::IntToString(CNWAligner::GetDefaultWm()).c_str());

    argdescr->AddDefaultKey
        ("Wms", "mismatch", "mismatch penalty (nucleotide sequences)",
         CArgDescriptions::eInteger,
         NStr::IntToString(CNWAligner::GetDefaultWms()).c_str());

    argdescr->AddDefaultKey
        ("Wg", "gap", "gap opening penalty",
         CArgDescriptions::eInteger,
         NStr::IntToString(CNWAligner::GetDefaultWg()).c_str());

    argdescr->AddDefaultKey
        ("Ws", "space", "gap extension (space) penalty",
         CArgDescriptions::eInteger,
         NStr::IntToString(CNWAligner::GetDefaultWs()).c_str());

    argdescr->AddDefaultKey
        ("band", "band", "Band width in banded alignment",
         CArgDescriptions::eInteger, "-1");

    argdescr->AddDefaultKey
        ("shift", "shift", 
         "Band shift in banded alignment "
         "(specify negative value to indicate second sequence)",
         CArgDescriptions::eInteger, "0");

    argdescr->AddFlag("mm",
                      "Use linear-memory alignment algorithm (Myers & Miller)");

    argdescr->AddFlag("mt", "Use multiple threads");

    // output formats
    argdescr->AddOptionalKey
        ("o1", "o1", "Filename for type 1 output", CArgDescriptions::eString);

    argdescr->AddOptionalKey
        ("o2", "o2", "Filename for type 2 output", CArgDescriptions::eString);

    argdescr->AddOptionalKey
        ("ofasta", "ofasta",
         "Generate gapped FastA output for the aligner sequences",
         CArgDescriptions::eString);

    argdescr->AddOptionalKey
        ("oasn", "oasn", "ASN.1 output filename", CArgDescriptions::eString);

    CArgAllow_Strings* paa_st = new CArgAllow_Strings;
    paa_st->Allow("nucl")->Allow("blosum62");
    argdescr->SetConstraint("matrix", paa_st);

    CArgAllow_Strings* paa_esf = new CArgAllow_Strings;
    paa_esf->Allow("xxxx")->Allow("xxxz")->Allow("xxzx")->Allow("xxzz");
    paa_esf->Allow("xzxx")->Allow("xzxz")->Allow("xzzx")->Allow("xzzz");
    paa_esf->Allow("zxxx")->Allow("zxxz")->Allow("zxzx")->Allow("zxzz");
    paa_esf->Allow("zzxx")->Allow("zzxz")->Allow("zzzx")->Allow("zzzz");
    argdescr->SetConstraint("esf", paa_esf);

    SetupArgDescriptions(argdescr.release());
}
示例#6
0
void CAlignmentRefiner::Init(void)
{
    // Create command-line argument descriptions class
    auto_ptr<CArgDescriptions> argDescr(new CArgDescriptions);

    // Specify USAGE context
    argDescr->SetUsageContext(GetArguments().GetProgramBasename(),
                              "Alignment Refinement w/ 'Leave One Out'");

    HideStdArgs(fHideLogfile | fHideConffile | fHideDryRun | fHideXmlHelp);

    //  *Mandatory*  
     // input CD/Fasta file name
    argDescr->AddKey("i", "CdFilenameIn", "full filename of input CD w/ alignment to refine (ascii or binary)", argDescr->eString);

    //  base name for output CD file
    argDescr->AddDefaultKey("o", "CdBasenameOut", "basename of output CD(s) containing refined alignment; output saved to 'basename_<number>.cn3'; ascii text by default", argDescr->eString, "refiner");

    // output binary?
    argDescr->AddFlag("ob", "output binary data");

    // File for data from the refinement process
    argDescr->AddOptionalKey
        ("details", "filename",
         "create a file to save refinenment process details",
         CArgDescriptions::eOutputFile,
         CArgDescriptions::fPreOpen);

    // quiet reporting of details (only at end of temp steps and trials)
    argDescr->AddFlag("q", "shortened report; only Error level messages");


    //  Number of cycles per trial (a cycle consists of a LOO phase followed by a 
    //  block-editing phase, either of which may be disabled for all cycles)
    //  In each LOO phase, each row is left out exactly once unless overriden by the 'nr' option.
    //  The alignment is NOT reset after a cycle; alignment IS reset after a trial.
    argDescr->AddDefaultKey("nc", "integer", "number of cycles per trial; a cycle consists of one leave-one-out (LOO) phase, followed by a block editing phase.  Either, but not both, of the phases in a cycle may be turned off.\n(Note:  alignments do NOT reset between cycles)\n", argDescr->eInteger, "1");
    argDescr->SetConstraint("nc", new CArgAllow_Integers(1, N_MAX_CYCLES));

    // Convergence criteria
    argDescr->AddDefaultKey("convSameScore", "double", "when >= this % of LOO attempts fail to change the score, stop further cycles", argDescr->eDouble, "0.95");
    argDescr->SetConstraint("convSameScore", new CArgAllow_Doubles(0, 1.0));




    //
    //  Leave-one-out parameters & options
    //

    argDescr->SetCurrentGroup("  Leave-one-out phase parameters and options  ");

    //  disable LOO phase
    argDescr->AddFlag("no_LOO", "do not perform the LOO phase of each cycle", true);
    argDescr->SetDependency("no_LOO", CArgDescriptions::eExcludes, "selection_order");

    //  *Mandatory*  
    //  Row selection order for LOO: randomly or based on the self-hit to the initial alignment.
    argDescr->AddKey("selection_order", "integer", "Method for row selection in LOO phase:\n0 == randomly (use -n option to specify the number of separate trials)\n1 == increasing self-hit row score to input alignment's PSSM\n2 == decreasing self-hit row score to input alignment's PSSM\n", argDescr->eInteger);
    argDescr->SetConstraint("selection_order", new CArgAllow_Integers(0, 2));
    argDescr->AddAlias("so", "selection_order");

    //  switch from 'leave-one-out' to 'leave-N-out':  recompute PSSM only after
    //  lno rows refined.
    argDescr->AddDefaultKey("lno", "integer", "leave-N-out mode:  speed up program by recomputing PSSM after 'lno' rows have been left out\n(values exceeding the number of rows interpreted as Nrows - 1)\nFor best results, value should be < 20% of number of rows in input alignment.\n", argDescr->eInteger, "1");
    argDescr->SetConstraint("lno", new CArgAllow_Integers(0, kMax_Int));

    //  Number of row LOO events per cycle (may be equal to, more than or less than 
    //  number of rows in the CD, and it is not guaranteed that each row will be chosen)
//    argDescr->AddOptionalKey("nr", "integer", "absolute number of LOO attempts per LOO cycle (defaults to all eligible rows in alignment except the master)\n", argDescr->eInteger);
//    argDescr->SetConstraint("nr", new CArgAllow_Integers(1, N_MAX_ROWS));

    //  declare whether structures are to be among the rows left out
    argDescr->AddFlag("fix_structs", "do not perform LOO refinement on structures (i.e., those sequences having a PDB identifier)", true);


    //
    //  Block aligner parameters / constraints on search space
    //

    //  leave-one-out arguments used by block aligner
    argDescr->AddDefaultKey("p", "double", "percentile parameter for loop-length cutoff in block aligner", argDescr->eDouble, "1.0");
    argDescr->SetConstraint("p", new CArgAllow_Doubles(0, 10.0));
    argDescr->AddDefaultKey("x", "integer", "extension parameter for loop-length cutoff in block aligner", argDescr->eInteger, "0");
    argDescr->SetConstraint("x", new CArgAllow_Integers(0, kMax_Int));
    argDescr->AddDefaultKey("c", "integer", "cutoff parameter for loop-length cutoff in block aligner", argDescr->eInteger, "0");
    argDescr->SetConstraint("c", new CArgAllow_Integers(0, kMax_Int));

    //  Constraints on sequence length used in search for improved alignments
    argDescr->AddFlag("fs", "allow refiner to use full sequence (by default, refinement is constrained to initial aligned footprint)", true);
    argDescr->AddDefaultKey("ex","integer", "footprint extension size (symmetric for N- and C-termini); positive values extend the footprint; negative values shrink the footprint and can be used with -fs; relevant extension overriden by -nex and/or -cex", argDescr->eInteger, "0");
    argDescr->AddOptionalKey("nex","integer", "N-terminal footprint extension size; positive values extend the footprint; negative values shrink the footprint and can be used with -fs; overrides any N-terminal extension from -ex", argDescr->eInteger);
    argDescr->AddOptionalKey("cex","integer", "C-terminal footprint extension size; positive values extend the footprint; negative values shrink the footprint and can be used with -fs; overrides any C-terminal extension from -ex\n", argDescr->eInteger);


    //  Block freezing/un-freezing
    argDescr->AddFlag("ab", "realign all blocks; overrides -f and -l options", true);
    argDescr->AddOptionalKey("f", "integer", "first block to realign (post-IBM, from 1); overridden if -ab set", argDescr->eInteger);
    argDescr->SetConstraint("f", new CArgAllow_Integers(1, kMax_Int));
    argDescr->AddOptionalKey("l", "integer", "last block to realign (post-IBM, from 1); overridden if -ab set", argDescr->eInteger);
    argDescr->SetConstraint("l", new CArgAllow_Integers(1, kMax_Int));
//    argDescr->AddExtra(0, 25, "Block number (post-IBM, from 1) to freeze:  can override -ab or -f, -l for a specific block(s) in a range of unfrozen blocks\n", argDescr->eInteger);
    argDescr->AddExtra(0, 25, "Row OR block numbers to exclude from LOO (from 1 to # rows/blocks); master == row 1 is always excluded\n(See 'extras_are_blocks' flag.)\n", argDescr->eInteger);

    //  Flag to tell whether the extra args are row numbers (if not present) or block numbers (if present).
    argDescr->AddFlag("extras_are_blocks", "treat extra arguments as block numbers (default is to treat them as row numbers)", true);

    argDescr->SetCurrentGroup("");


    //
    //  Random selection order related options
    //

    argDescr->SetCurrentGroup("  Random selection order specific options  ");

    //  Number of trials
    argDescr->AddDefaultKey("n", "integer", "number of independent trials (restarts from original alignment)\nNOTE:  only relevant if use random selection order of rows; ignored if deterministic selection order used (see 'selection_order')", argDescr->eInteger, "3");
    argDescr->SetConstraint("n", new CArgAllow_Integers(1, N_MAX_TRIALS));

    argDescr->AddDefaultKey("nout", "integer", "number of output CDs; save CDs from the top 'nout' trials", argDescr->eInteger, "1");
    argDescr->SetConstraint("nout", new CArgAllow_Integers(1, N_MAX_TRIALS));

    argDescr->AddDefaultKey("convScoreChange", "double", "when avg. deviation <= this % of mean score for M trials, stop further trials", argDescr->eDouble, "0.001");
    argDescr->SetConstraint("convScoreChange", new CArgAllow_Doubles(0, 1.0));

    // Specify seed to RNG
    argDescr->AddOptionalKey("seed", "positive_integer", "specify the seed for random number generation\n", argDescr->eInteger);
    argDescr->SetConstraint("seed", new CArgAllow_Integers(1000, kMax_Int-1));


    argDescr->SetCurrentGroup("");


    //
    //  Block editing options
    //

    argDescr->SetCurrentGroup("  Block-editing phase parameters and options  ");

    argDescr->AddFlag("be_fix", "do not modify block boundaries", true);
    argDescr->AddFlag("be_noShrink", "do not attempt to shrink block boundaries", true);
    argDescr->AddFlag("be_shrinkFirst", "if set, try to shrink before extending a block; requires be_alg = both\n\n", true);

    argDescr->AddDefaultKey("be_minSize", "integer", "smallest allowed block width (set to 0 to allow block deletion events);\nblocks that start smaller than min size are not truncated.", argDescr->eInteger, "1");
    argDescr->SetConstraint("be_minSize", new CArgAllow_Integers(0, 1000));

    //  Scoring methods and algorithms for block edits.
    argDescr->AddDefaultKey("be_alg", "string", "block editing method", argDescr->eString, "both");
    argDescr->SetConstraint("be_alg", &(*new CArgAllow_Strings, "extend", "greedyExt", "shrink", "both"));
    argDescr->AddDefaultKey("be_score", "string", "column scoring method", argDescr->eString, "3.3.3");
    argDescr->SetConstraint("be_score", &(*new CArgAllow_Strings, "vote", "sumScores", "median", "scoreWeight", "compound", "3.3.3"));


    /////////////////////////
    //  The following three options define the parameters for the 'compound' scoring method.
    //  '3.3.3' is a special shortcut compound method that uses 3, .3, .3 for these values,
    //  respectively.  
    //  For future:  Use 'compound' to use same three scorers w/ non-default values.
    /////////////////////////
    argDescr->AddDefaultKey("be_median", "integer", "if be_score = 'median', '3.3.3', value column median must equal or exceed", argDescr->eInteger, "3");
    argDescr->SetConstraint("be_median", new CArgAllow_Integers(-10, 20));
    argDescr->AddDefaultKey("be_negScore", "double", "negative score fraction:  fraction of total column score less than zero\nto be added to a block, column's fraction must have at least this value\n** used for 'scoreWeight', 'compound', '3.3.3' scoring only", argDescr->eDouble, ".3");
    argDescr->SetConstraint("be_negScore", new CArgAllow_Doubles(0, 1));
    argDescr->AddDefaultKey("be_negRows", "double", "negative rows fraction:  largest fraction of rows in a column with a negative value\nfor the column to be added to a block\n** used for 'compound', '3.3.3' scoring only", argDescr->eDouble, ".3");
    argDescr->SetConstraint("be_negRows", new CArgAllow_Doubles(0, 1));



    argDescr->AddDefaultKey("be_minScore", "integer", "if be_score = 'vote', score at or above which a row votes 'yes'", argDescr->eInteger, "0");
    argDescr->SetConstraint("be_minScore", new CArgAllow_Integers(-100, 100));
    argDescr->AddOptionalKey("be_eThresh", "double", "extension threshold:\n column score at or above which a column is added to a block\nif not given, assumes same values as 'be_sThresh', or if neither is present an error is reported\n** with 'vote' scoring, must be in [0, 1]", argDescr->eDouble);
//    argDescr->SetConstraint("be_eThresh", new CArgAllow_Doubles(-1000, 1000));
    argDescr->AddOptionalKey("be_sThresh", "double", "shrinkage threshold (ignored if -be_noShrink not specified):\n column score below which a column is removed from a block\nif not given, assumes same values as 'be_eThresh', or if neither is present an error is reported\n** with 'vote' scoring, must be in [0, 1]\n", argDescr->eDouble);
//    argDescr->SetConstraint("be_sThresh", new CArgAllow_Doubles(-1000, 1000));

    argDescr->SetCurrentGroup("");



    // argDescr->AddFlag("qd", "shortened details report; only report details at end of cycles and trials.  Has an affect only if '-details' is provided");

    // Setup arg.descriptions for this application
    SetupArgDescriptions(argDescr.release());
}