IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 11088


Ignore:
Timestamp:
Jan 12, 2007, 4:38:53 PM (19 years ago)
Author:
jhoblitt
Message:

add -limit, -code, & -faulted options to the appropriate modes

Location:
trunk/ippTools/src
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/ippTools/src/dettool.c

    r11047 r11088  
    167167        " WHERE"
    168168        "    detInputExp.exp_tag IS NULL"
     169        "    AND rawExp.obstype != 'object'"
    169170    );
    170171
    … …  
    188189    }
    189190    if (!psArrayLength(output)) {
    190         // XXX check psError here
    191191        psError(PS_ERR_UNKNOWN, false, "no pending rawExp rows found");
    192192        psFree(output);
    … …  
    17171717    }
    17181718
     1719    // default values
     1720    psS8 code = psMetadataLookupS8(&status, config->args, "-code");
     1721    if (!status) {
     1722        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -code");
     1723        return false;
     1724    }
     1725
    17191726    psArray *rawImfiles = rawImfileSelectRowObjects(config->dbh, where, 0);
    17201727    psFree(where);
    … …  
    17231730        return false;
    17241731    }
     1732
    17251733
    17261734    // create a new detProcessedImfile object
    … …  
    17351743        bg_mean_stdev,
    17361744        b1_uri,
    1737         b2_uri
     1745        b2_uri,
     1746        code
    17381747    );
    17391748    psFree(rawImfiles);
    … …  
    19501959    }
    19511960
     1961    // default values
     1962    psS8 code = psMetadataLookupS8(&status, config->args, "-code");
     1963    if (!status) {
     1964        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -code");
     1965        return false;
     1966    }
     1967
    19521968    psString query = psStringCopy(
    19531969        " SELECT DISTINCT"
    … …  
    20152031        bg_mean_stdev,
    20162032        b1_uri,
    2017         b2_uri
     2033        b2_uri,
     2034        code
    20182035    );
    20192036
    … …  
    20332050{
    20342051    PS_ASSERT_PTR_NON_NULL(config, false);
     2052
     2053    bool status = false;
     2054    psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
     2055    if (!status) {
     2056        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
     2057        return false;
     2058    }
     2059
     2060    bool faulted = psMetadataLookupU64(&status, config->args, "-faulted");
     2061    if (!status) {
     2062        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -faulted");
     2063        return false;
     2064    }
    20352065
    20362066    psString query = psStringCopy("SELECT * FROM detProcessedExp");
    … …  
    20402070        psStringAppend(&query, " %s", whereClause);
    20412071        psFree(whereClause);
     2072    }
     2073
     2074    if (faulted) {
     2075        // list only faulted rows
     2076        psStringAppend(&query, " %s", "AND detProcessedExp.fault != 0");
     2077    } else {
     2078        // don't list faulted rows
     2079        psStringAppend(&query, " %s", "AND detProcessedExp.fault = 0");
     2080    }
     2081
     2082    // treat limit == 0 as "no limit"
     2083    if (limit) {
     2084        psString limitString = psDBGenerateLimitSQL(limit);
     2085        psStringAppend(&query, " %s", limitString);
     2086        psFree(limitString);
    20422087    }
    20432088
    … …  
    22062251    PS_ASSERT_PTR_NON_NULL(config, false);
    22072252
     2253    bool status = false;
     2254    psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
     2255    if (!status) {
     2256        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
     2257        return false;
     2258    }
     2259
     2260    bool faulted = psMetadataLookupU64(&status, config->args, "-faulted");
     2261    if (!status) {
     2262        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -faulted");
     2263        return false;
     2264    }
     2265
    22082266    psString query = psStringCopy(
    22092267        " SELECT DISTINCT"
    … …  
    22482306    psFree(query);
    22492307
     2308    if (faulted) {
     2309        // list only faulted rows
     2310        psStringAppend(&query, " %s", "AND detProcessedImfile.fault != 0");
     2311    } else {
     2312        // don't list faulted rows
     2313        psStringAppend(&query, " %s", "AND detProcessedImfile.fault = 0");
     2314    }
     2315
     2316    // treat limit == 0 as "no limit"
     2317    if (limit) {
     2318        psString limitString = psDBGenerateLimitSQL(limit);
     2319        psStringAppend(&query, " %s", limitString);
     2320        psFree(limitString);
     2321    }
     2322
    22502323    psArray *output = p_psDBFetchResult(config->dbh);
    22512324    if (!output) {
    … …  
    23522425    }
    23532426
    2354     // iteration has a default value
     2427    // default values
    23552428    psS32 iteration = psMetadataLookupS32(&status, config->args, "-iteration");
    23562429    if (!status) {
    23572430        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -iteration");
     2431        return false;
     2432    }
     2433
     2434    psS8 code = psMetadataLookupS8(&status, config->args, "-code");
     2435    if (!status) {
     2436        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -code");
    23582437        return false;
    23592438    }
    … …  
    24002479            bg,
    24012480            bg_stdev,
    2402             bg_mean_stdev
     2481            bg_mean_stdev,
     2482            code
    24032483        );
    24042484
    … …  
    24182498{
    24192499    PS_ASSERT_PTR_NON_NULL(config, false);
     2500
     2501    bool status = false;
     2502    psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
     2503    if (!status) {
     2504        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
     2505        return false;
     2506    }
     2507
     2508    bool faulted = psMetadataLookupU64(&status, config->args, "-faulted");
     2509    if (!status) {
     2510        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -faulted");
     2511        return false;
     2512    }
    24202513
    24212514    // select detStackedImfile.*
    … …  
    24382531        psStringAppend(&query, " AND %s", whereClause);
    24392532        psFree(whereClause);
     2533    }
     2534
     2535    if (faulted) {
     2536        // list only faulted rows
     2537        psStringAppend(&query, " %s", "AND detStackedImfile.fault != 0");
     2538    } else {
     2539        // don't list faulted rows
     2540        psStringAppend(&query, " %s", "AND detStackedImfile.fault = 0");
     2541    }
     2542
     2543    // treat limit == 0 as "no limit"
     2544    if (limit) {
     2545        psString limitString = psDBGenerateLimitSQL(limit);
     2546        psStringAppend(&query, " %s", limitString);
     2547        psFree(limitString);
    24402548    }
    24412549
    … …  
    27082816    }
    27092817
     2818    // default values
     2819    psS8 code = psMetadataLookupS8(&status, config->args, "-code");
     2820    if (!status) {
     2821        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -code");
     2822        return false;
     2823    }
     2824
    27102825    return detNormalizedStatImfileRowAlloc(
    27112826        stackedImfile->det_id,
    27122827        stackedImfile->iteration,
    27132828        stackedImfile->class_id,
    2714         norm
     2829        norm,
     2830        code
    27152831    );
    27162832}
    … …  
    31043220    }
    31053221#endif
    3106 
     3222   
    31073223    // treat limit == 0 as "no limit"
    31083224    if (limit) {
    … …  
    32103326        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -iteration");        return false;
    32113327    }
     3328
     3329    psS8 code = psMetadataLookupS8(&status, config->args, "-code");
     3330    if (!status) {
     3331        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -code");
     3332        return false;
     3333    }
     3334
    32123335    // optional
    32133336    psString b1_uri = psMetadataLookupStr(&status, config->args, "-b1_uri");
    … …  
    32903413        bg_mean_stdev,
    32913414        b1_uri,
    3292         b2_uri
     3415        b2_uri,
     3416        code
    32933417    );
    32943418
    … …  
    33083432{
    33093433    PS_ASSERT_PTR_NON_NULL(config, false);
     3434
     3435    bool status = false;
     3436    psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
     3437    if (!status) {
     3438        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
     3439        return false;
     3440    }
     3441
     3442    bool faulted = psMetadataLookupU64(&status, config->args, "-faulted");
     3443    if (!status) {
     3444        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -faulted");
     3445        return false;
     3446    }
    33103447
    33113448    psString query = psStringCopy(
    … …  
    33263463    }
    33273464
     3465    if (faulted) {
     3466        // list only faulted rows
     3467        psStringAppend(&query, " %s", "AND detNormalizedExp.fault != 0");
     3468    } else {
     3469        // don't list faulted rows
     3470        psStringAppend(&query, " %s", "AND detNormalizedExp.fault = 0");
     3471    }
     3472
     3473    // treat limit == 0 as "no limit"
     3474    if (limit) {
     3475        psString limitString = psDBGenerateLimitSQL(limit);
     3476        psStringAppend(&query, " %s", limitString);
     3477        psFree(limitString);
     3478    }
     3479
    33283480    if (!p_psDBRunQuery(config->dbh, query)) {
    33293481        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    34183570    if (!status) {
    34193571        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -b2_uri");
     3572        return false;
     3573    }
     3574
     3575    // default values
     3576    psS8 code = psMetadataLookupS8(&status, config->args, "-code");
     3577    if (!status) {
     3578        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -code");
    34203579        return false;
    34213580    }
    … …  
    34303589        bg_mean_stdev,
    34313590        b1_uri,
    3432         b2_uri
     3591        b2_uri,
     3592        code
    34333593    );
    34343594}
    … …  
    35813741    PS_ASSERT_PTR_NON_NULL(config, false);
    35823742
     3743    bool status = false;
     3744    psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
     3745    if (!status) {
     3746        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
     3747        return false;
     3748    }
     3749
     3750    bool faulted = psMetadataLookupU64(&status, config->args, "-faulted");
     3751    if (!status) {
     3752        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -faulted");
     3753        return false;
     3754    }
     3755
    35833756    psString query = psStringCopy(
    35843757        "SELECT"
    … …  
    36023775        psStringAppend(&query, " AND %s", whereClause);
    36033776        psFree(whereClause);
     3777    }
     3778
     3779    if (faulted) {
     3780        // list only faulted rows
     3781        psStringAppend(&query, " %s", "AND detNormalizedImfile.fault != 0");
     3782    } else {
     3783        // don't list faulted rows
     3784        psStringAppend(&query, " %s", "AND detNormalizedImfile.fault = 0");
     3785    }
     3786
     3787    // treat limit == 0 as "no limit"
     3788    if (limit) {
     3789        psString limitString = psDBGenerateLimitSQL(limit);
     3790        psStringAppend(&query, " %s", limitString);
     3791        psFree(limitString);
    36043792    }
    36053793
    … …  
    36853873        "   0.0 as bg_mean_stdev,\n"
    36863874        "   'NULL' as b1_uri,\n"
    3687         "   'NULL' as b2_uri\n"
     3875        "   'NULL' as b2_uri,\n"
     3876        "    0 as fault\n"
    36883877        " FROM detRun\n"
    36893878        " JOIN detInputExp\n"
    … …  
    39154104    }
    39164105
     4106    // default values
     4107    psS8 code = psMetadataLookupS8(&status, config->args, "-code");
     4108    if (!status) {
     4109        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -code");
     4110        return false;
     4111    }
     4112
    39174113    // create a new detResidImfileRow and insert it
    39184114    return detResidImfileRowAlloc(
    … …  
    39274123            bg_mean_stdev,
    39284124            b1_uri,
    3929             b2_uri
     4125            b2_uri,
     4126            code
    39304127        );
    39314128}
    … …  
    39344131{
    39354132    PS_ASSERT_PTR_NON_NULL(config, false);
     4133
     4134    bool status = false;
     4135    psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
     4136    if (!status) {
     4137        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
     4138        return false;
     4139    }
     4140
     4141    bool faulted = psMetadataLookupU64(&status, config->args, "-faulted");
     4142    if (!status) {
     4143        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -faulted");
     4144        return false;
     4145    }
    39364146
    39374147    // select detResidImfile.*
    … …  
    39554165        psStringAppend(&query, " AND %s", whereClause);
    39564166        psFree(whereClause);
     4167    }
     4168
     4169    if (faulted) {
     4170        // list only faulted rows
     4171        psStringAppend(&query, " %s", "AND p2ProcessedImfile.fault != 0");
     4172    } else {
     4173        // don't list faulted rows
     4174        psStringAppend(&query, " %s", "AND p2ProcessedImfile.fault = 0");
     4175    }
     4176
     4177    // treat limit == 0 as "no limit"
     4178    if (limit) {
     4179        psString limitString = psDBGenerateLimitSQL(limit);
     4180        psStringAppend(&query, " %s", limitString);
     4181        psFree(limitString);
    39574182    }
    39584183
    … …  
    44094634        return false;
    44104635    }
     4636    // default values
     4637    psS8 code = psMetadataLookupS8(&status, config->args, "-code");
     4638    if (!status) {
     4639        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -code");
     4640        return false;
     4641    }
    44114642
    44124643    // create a new detResidImfileRow and insert it
    … …  
    44214652            b1_uri,
    44224653            b2_uri,
    4423             !reject
     4654            !reject,
     4655            code
    44244656        );
    44254657}
    … …  
    44284660{
    44294661    PS_ASSERT_PTR_NON_NULL(config, false);
     4662
     4663    bool status = false;
     4664    psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
     4665    if (!status) {
     4666        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
     4667        return false;
     4668    }
     4669
     4670    bool faulted = psMetadataLookupU64(&status, config->args, "-faulted");
     4671    if (!status) {
     4672        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -faulted");
     4673        return false;
     4674    }
    44304675
    44314676    psString query = psStringCopy(
    … …  
    44474692        psStringAppend(&query, " AND %s", whereClause);
    44484693        psFree(whereClause);
     4694    }
     4695
     4696    if (faulted) {
     4697        // list only faulted rows
     4698        psStringAppend(&query, " %s", "AND detResidExp.fault != 0");
     4699    } else {
     4700        // don't list faulted rows
     4701        psStringAppend(&query, " %s", "AND detResidExp.fault = 0");
     4702    }
     4703
     4704    // treat limit == 0 as "no limit"
     4705    if (limit) {
     4706        psString limitString = psDBGenerateLimitSQL(limit);
     4707        psStringAppend(&query, " %s", limitString);
     4708        psFree(limitString);
    44494709    }
    44504710
    … …  
    49725232        return NULL;
    49735233    }
     5234    // default values
     5235    psS8 code = psMetadataLookupS8(&status, config->args, "-code");
     5236    if (!status) {
     5237        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -code");
     5238        return false;
     5239    }
    49745240
    49755241    return detRunSummaryRowAlloc(
    … …  
    49795245            bg_stdev,
    49805246            bg_mean_stdev,
    4981             accept
     5247            accept,
     5248            code
    49825249        );
    49835250}
    … …  
    49865253{
    49875254    PS_ASSERT_PTR_NON_NULL(config, false);
     5255
     5256    bool status = false;
     5257    psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
     5258    if (!status) {
     5259        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
     5260        return false;
     5261    }
     5262
     5263    bool faulted = psMetadataLookupU64(&status, config->args, "-faulted");
     5264    if (!status) {
     5265        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -faulted");
     5266        return false;
     5267    }
    49885268
    49895269    psString query = psStringCopy(
    … …  
    50035283        psStringAppend(&query, " AND %s", whereClause);
    50045284        psFree(whereClause);
     5285    }
     5286
     5287    if (faulted) {
     5288        // list only faulted rows
     5289        psStringAppend(&query, " %s", "AND p2ProcessedImfile.fault != 0");
     5290    } else {
     5291        // don't list faulted rows
     5292        psStringAppend(&query, " %s", "AND p2ProcessedImfile.fault = 0");
     5293    }
     5294
     5295    // treat limit == 0 as "no limit"
     5296    if (limit) {
     5297        psString limitString = psDBGenerateLimitSQL(limit);
     5298        psStringAppend(&query, " %s", limitString);
     5299        psFree(limitString);
    50055300    }
    50065301
    … …  
    55645859            bg_stdev,
    55655860            bg_mean_stdev,
    5566             true // accept
     5861            true,   // accept
     5862            0       // fault code
    55675863    )) {
    55685864        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    56625958            bg_mean_stdev,
    56635959            b1_uri,
    5664             b2_uri
     5960            b2_uri,
     5961            0       // fault code
    56655962    )) {
    56665963        psError(PS_ERR_UNKNOWN, false, "database error");

  • trunk/ippTools/src/dettoolConfig.c

    r10741 r11088  
    231231    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-b2_uri",  0,
    232232            "define banana 2", NULL);
     233    psMetadataAddS8(addprocessedimfileArgs, PS_LIST_TAIL, "-code",  0,
     234            "set fault code (required)", 0);
    233235   
    234236    // -processedimfile
    … …  
    246248    psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-included",  0,
    247249            "restrict results to exposures 'includeded' in the current iteration", false);
     250    psMetadataAddU64(processedimfileArgs, PS_LIST_TAIL, "-limit",  0,
     251            "limit result set to N items", 0);
     252    psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-faulted",  0,
     253            "only return imfiles with a fault status set", false);
    248254    psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-simple",  0,
    249255            "use the simple output format", false);
    … …  
    274280    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-b2_uri",  0,
    275281            "define banana 2", NULL);
     282    psMetadataAddS8(addprocessedexpArgs, PS_LIST_TAIL, "-code",  0,
     283            "set fault code (required)", 0);
    276284
    277285    // -proccessedexp
    … …  
    281289    psMetadataAddStr(processedexpArgs, PS_LIST_TAIL, "-exp_tag",  0,
    282290            "define detrend ID (required)", NULL);
     291    psMetadataAddU64(processedexpArgs, PS_LIST_TAIL, "-limit",  0,
     292            "limit result set to N items", 0);
     293    psMetadataAddBool(processedexpArgs, PS_LIST_TAIL, "-faulted",  0,
     294            "only return imfiles with a fault status set", false);
    283295    psMetadataAddBool(processedexpArgs, PS_LIST_TAIL, "-simple",  0,
    284296            "use the simple output format", false);
    … …  
    309321    psMetadataAddStr(addstackedArgs, PS_LIST_TAIL, "-uri",  0,
    310322            "define URI (required)", NULL);
    311 
    312     // -tonormalize
    313     psMetadata *tonormalizeArgs = psMetadataAlloc();
    314     psMetadataAddU64(tonormalizeArgs, PS_LIST_TAIL, "-limit",  0,
    315             "limit result set to N items", 0);
    316     psMetadataAddBool(tonormalizeArgs, PS_LIST_TAIL, "-simple",  0,
    317             "use the simple output format", false);
    318 
    319     // -addnormstat
    320     psMetadata *addnormstatArgs = psMetadataAlloc();
    321     psMetadataAddStr(addnormstatArgs, PS_LIST_TAIL, "-det_id",  0,
    322             "define detrend ID (required)", NULL);
    323     psMetadataAddS32(addnormstatArgs, PS_LIST_TAIL, "-iteration",  0,
    324             "define iteration number", 0);
    325     psMetadataAddStr(addnormstatArgs, PS_LIST_TAIL, "-class_id",  0,
    326             "define class ID", NULL);
    327     psMetadataAddF32(addnormstatArgs, PS_LIST_TAIL, "-norm",  0,
    328             "define normal value (required)", NAN);
    329  
    330     // -tonormstat
    331     psMetadata *tonormstatArgs = psMetadataAlloc();
    332     psMetadataAddU64(tonormstatArgs, PS_LIST_TAIL, "-limit",  0,
    333             "limit result set to N items", 0);
    334     psMetadataAddBool(tonormstatArgs, PS_LIST_TAIL, "-simple",  0,
    335             "use the simple output format", false);
     323    psMetadataAddS8(addstackedArgs, PS_LIST_TAIL, "-code",  0,
     324            "set fault code (required)", 0);
    336325   
    337326    // -stacked
    … …  
    345334    psMetadataAddStr(stackedArgs, PS_LIST_TAIL, "-recip",  0,
    346335            "search for recipe", NULL);
     336    psMetadataAddU64(stackedArgs, PS_LIST_TAIL, "-limit",  0,
     337            "limit result set to N items", 0);
     338    psMetadataAddBool(stackedArgs, PS_LIST_TAIL, "-faulted",  0,
     339            "only return imfiles with a fault status set", false);
    347340    psMetadataAddBool(stackedArgs, PS_LIST_TAIL, "-simple",  0,
     341            "use the simple output format", false);
     342
     343    // -tonormalize
     344    psMetadata *tonormalizeArgs = psMetadataAlloc();
     345    psMetadataAddU64(tonormalizeArgs, PS_LIST_TAIL, "-limit",  0,
     346            "limit result set to N items", 0);
     347    psMetadataAddBool(tonormalizeArgs, PS_LIST_TAIL, "-simple",  0,
     348            "use the simple output format", false);
     349
     350    // -addnormstat
     351    psMetadata *addnormstatArgs = psMetadataAlloc();
     352    psMetadataAddStr(addnormstatArgs, PS_LIST_TAIL, "-det_id",  0,
     353            "define detrend ID (required)", NULL);
     354    psMetadataAddS32(addnormstatArgs, PS_LIST_TAIL, "-iteration",  0,
     355            "define iteration number", 0);
     356    psMetadataAddStr(addnormstatArgs, PS_LIST_TAIL, "-class_id",  0,
     357            "define class ID", NULL);
     358    psMetadataAddF32(addnormstatArgs, PS_LIST_TAIL, "-norm",  0,
     359            "define normal value (required)", NAN);
     360    psMetadataAddS8(addnormstatArgs, PS_LIST_TAIL, "-code",  0,
     361            "set fault code (required)", 0);
     362 
     363    // -tonormstat
     364    psMetadata *tonormstatArgs = psMetadataAlloc();
     365    psMetadataAddU64(tonormstatArgs, PS_LIST_TAIL, "-limit",  0,
     366            "limit result set to N items", 0);
     367    psMetadataAddBool(tonormstatArgs, PS_LIST_TAIL, "-simple",  0,
    348368            "use the simple output format", false);
    349369
    … …  
    368388    psMetadataAddStr(addnormalizedimfileArgs, PS_LIST_TAIL, "-b2_uri", 0,
    369389            "define banana 2", NULL);
     390    psMetadataAddS8(addnormalizedimfileArgs, PS_LIST_TAIL, "-code",  0,
     391            "set fault code (required)", 0);
    370392
    371393    // -tonormalizedexp
    … …  
    394416    psMetadataAddStr(addnormalizedexpArgs, PS_LIST_TAIL, "-b2_uri",  0,
    395417            "define banana 2", NULL);
     418    psMetadataAddS8(addnormalizedexpArgs, PS_LIST_TAIL, "-code",  0,
     419            "set fault code (required)", 0);
    396420
    397421    // -normalizedexp
    … …  
    413437    psMetadataAddStr(normalizedexpArgs, PS_LIST_TAIL, "-b2_uri",  0,
    414438            "define banana 2", NULL);
     439    psMetadataAddU64(normalizedexpArgs, PS_LIST_TAIL, "-limit",  0,
     440            "limit result set to N items", 0);
     441    psMetadataAddBool(normalizedexpArgs, PS_LIST_TAIL, "-faulted",  0,
     442            "only return imfiles with a fault status set", false);
    415443    psMetadataAddBool(normalizedexpArgs, PS_LIST_TAIL, "-simple",  0,
    416444            "use the simple output format", false);
    … …  
    433461    psMetadataAddStr(normalizedimfileArgs, PS_LIST_TAIL, "-recip",  0,
    434462            "search for recipe", NULL);
     463    psMetadataAddU64(normalizedimfileArgs, PS_LIST_TAIL, "-limit",  0,
     464            "limit result set to N items", 0);
     465    psMetadataAddBool(normalizedimfileArgs, PS_LIST_TAIL, "-faulted",  0,
     466            "only return imfiles with a fault status set", false);
    435467    psMetadataAddBool(normalizedimfileArgs, PS_LIST_TAIL, "-simple",  0,
    436468            "use the simple output format", false);
    … …  
    467499    psMetadataAddStr(addresidimfileArgs, PS_LIST_TAIL, "-b2_uri",  0,
    468500            "define banana 2", NULL);
     501    psMetadataAddS8(addresidimfileArgs, PS_LIST_TAIL, "-code",  0,
     502            "set fault code (required)", 0);
    469503
    470504    // -residimfile
    … …  
    480514    psMetadataAddStr(residimfileArgs, PS_LIST_TAIL, "-recip",  0,
    481515            "search for recipe", NULL);
     516    psMetadataAddU64(residimfileArgs, PS_LIST_TAIL, "-limit",  0,
     517            "limit result set to N items", 0);
     518    psMetadataAddBool(residimfileArgs, PS_LIST_TAIL, "-faulted",  0,
     519            "only return imfiles with a fault status set", false);
    482520    psMetadataAddBool(residimfileArgs, PS_LIST_TAIL, "-simple",  0,
    483521            "use the simple output format", false);
    … …  
    503541    psMetadataAddStr(addresidexpArgs, PS_LIST_TAIL, "-b2_uri",  0,
    504542            "define banana 2", NULL);
     543    psMetadataAddS8(addresidexpArgs, PS_LIST_TAIL, "-code",  0,
     544            "set fault code (required)", 0);
    505545    psMetadataAddBool(addresidexpArgs, PS_LIST_TAIL, "-reject",  0,
    506546            "exposure is not to be stacked in the next iteration", false);
    … …  
    516556    psMetadataAddStr(residexpArgs, PS_LIST_TAIL, "-recip",  0,
    517557            "search for recipe", NULL);
     558    psMetadataAddU64(residexpArgs, PS_LIST_TAIL, "-limit",  0,
     559            "limit result set to N items", 0);
     560    psMetadataAddBool(residexpArgs, PS_LIST_TAIL, "-faulted",  0,
     561            "only return imfiles with a fault status set", false);
    518562    psMetadataAddBool(residexpArgs, PS_LIST_TAIL, "-reject",  0,
    519563            "search for acceptable residuals", false);
    … …  
    563607    psMetadataAddF64(adddetrunsummaryArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,
    564608            "define exposue background mean stdev", NAN);
     609    psMetadataAddS8(adddetrunsummaryArgs, PS_LIST_TAIL, "-code",  0,
     610            "set fault code (required)", 0);
    565611    psMetadataAddBool(adddetrunsummaryArgs, PS_LIST_TAIL, "-accept",  0,
    566612            "declare that this detrun iteration is accepted as a master", false);
    … …  
    572618    psMetadataAddS32(detrunsummaryArgs, PS_LIST_TAIL, "-iteration",  0,
    573619            "search for iteration number", 0);
     620    psMetadataAddBool(detrunsummaryArgs, PS_LIST_TAIL, "-faulted",  0,
     621            "only return imfiles with a fault status set", false);
     622    psMetadataAddBool(detrunsummaryArgs, PS_LIST_TAIL, "-reject",  0,
     623            "search for acceptable residuals", false);
    574624    psMetadataAddBool(detrunsummaryArgs, PS_LIST_TAIL, "-simple",  0,
    575625            "use the simple output format", false);
Note: See TracChangeset for help on using the changeset viewer.