IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 18491


Ignore:
Timestamp:
Jul 11, 2008, 5:40:18 PM (18 years ago)
Author:
eugene
Message:

deprecating config->where; make command-line args consistent

Location:
branches/eam_branch_20080706/ippTools
Files:
4 added
19 edited

Legend:

Unmodified
Added
Removed

  • branches/eam_branch_20080706/ippTools/notes.txt

    r18467 r18491  
     1
     22008.07.11 EAM
     3
     4  * break dettool.c into files for each detrend stage
     5  * require -iteration in more places? (esp -add...)
     6  * allow %s, %d arguments in the *.sql files or not?
     7  * adddetrunsummary has the ability to set values for multiple detRunSummary entries.  why?
    18
    292008.07.09 EAM

  • branches/eam_branch_20080706/ippTools/share/dettool_tonormalizedexp.sql

    r15855 r18491  
     1-- this is used by both 'tonormalizedexp' and 'addnormalizedexp'
     2
    13SELECT
    24    *

  • branches/eam_branch_20080706/ippTools/share/dettool_toresidexp.sql

    r15769 r18491  
     1-- this is used by both 'toresidexp' and 'addresidexp'
     2
    13-- which returns a list of exposures for which all component class ids have had
    24-- residuals created.  This list includes the detrend id, iteration, exposure

  • branches/eam_branch_20080706/ippTools/share/difftool_queue.sql

    r17712 r18491  
    33        stackRun.tess_id,
    44        stackRun.stack_id,
     5        diffInputSkyfile.template,
    56        warpSkyfile.warp_id
    67FROM stackSumSkyfile

  • branches/eam_branch_20080706/ippTools/src/caltool.c

    r18336 r18491  
    110110
    111111    psString query = psStringCopy("SELECT * FROM calDB");
    112 
    113     if (config->where) {
    114         psString whereClause = psDBGenerateWhereSQL(config->where, NULL);
    115         psStringAppend(&query, " %s", whereClause);
    116         psFree(whereClause);
    117     }
    118112
    119113    // treat limit == 0 as "no limit"
    … …  
    195189    PS_ASSERT_PTR_NON_NULL(config, false);
    196190
     191    psMetadata *where = psMetadataAlloc();
     192    PXOPT_COPY_STR(config->args, where,  "-cal_id",     "cal_id", "==");
     193
    197194    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    198195    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     196    PXOPT_LOOKUP_BOOL(faulted, config->args, "-simple", false);
    199197
    200198    psString query = psStringCopy("SELECT * FROM calRun");
    201199
    202     if (config->where) {
    203         psString whereClause = psDBGenerateWhereSQL(config->where, NULL);
     200    if (faulted) {
     201        // list only faulted rows
     202        psStringAppend(&query, " %s", "WHERE fault != 0");
     203    } else {
     204        // don't list faulted rows
     205        psStringAppend(&query, " %s", "WHERE fault = 0");
     206    }
     207
     208    if (psListLength(where->list)) {
     209        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    204210        psStringAppend(&query, " %s", whereClause);
    205211        psFree(whereClause);
    206212    }
     213    psFree(where);
    207214
    208215    // treat limit == 0 as "no limit"
    209216    if (limit) {
    210217        psString limitString = psDBGenerateLimitSQL(limit);
    211         psStringAppend(&query, " %s", limitString);
     218        psStringAppend(&query, " AND %s", limitString);
    212219        psFree(limitString);
    213220    }

  • branches/eam_branch_20080706/ippTools/src/caltoolConfig.c

    r18468 r18491  
    4949    // -adddb
    5050    psMetadata *adddbArgs = psMetadataAlloc();
    51     psMetadataAddStr(adddbArgs, PS_LIST_TAIL, "-dvodb",  0,
    52             "define DVO db (required)", NULL);
     51    psMetadataAddStr(adddbArgs, PS_LIST_TAIL, "-dvodb",  0,            "define DVO db (required)", NULL);
    5352
    5453    // -dbs
    5554    psMetadata *dbsArgs = psMetadataAlloc();
    56     psMetadataAddU64(dbsArgs, PS_LIST_TAIL, "-limit",  0,
    57             "limit result set to N items", 0);
    58     psMetadataAddBool(dbsArgs, PS_LIST_TAIL, "-simple", 0,
    59             "use the simple output format", false);
     55    psMetadataAddU64(dbsArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     56    psMetadataAddBool(dbsArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
    6057
    6158    // -addrun
    6259    psMetadata *addrunArgs = psMetadataAlloc();
    63     psMetadataAddStr(addrunArgs, PS_LIST_TAIL, "-cal_id",  0,
    64             "define calibration DB ID (required)", NULL);
    65     psMetadataAddStr(addrunArgs, PS_LIST_TAIL, "-region",  0,
    66             "define region (required)", NULL);
    67     psMetadataAddStr(addrunArgs, PS_LIST_TAIL, "-last_step",  0,
    68             "define last step (required)", NULL);
    69     psMetadataAddStr(addrunArgs, PS_LIST_TAIL, "-state",  0,
    70             "define state (required)", NULL);
     60    psMetadataAddStr(addrunArgs, PS_LIST_TAIL, "-cal_id",  0,            "define calibration DB ID (required)", NULL);
     61    psMetadataAddStr(addrunArgs, PS_LIST_TAIL, "-region",  0,            "define region (required)", NULL);
     62    psMetadataAddStr(addrunArgs, PS_LIST_TAIL, "-last_step",  0,            "define last step (required)", NULL);
     63    psMetadataAddStr(addrunArgs, PS_LIST_TAIL, "-state",  0,            "define state (required)", NULL);
    7164
    7265    // -runs
    7366    psMetadata *runsArgs = psMetadataAlloc();
    74     psMetadataAddStr(runsArgs, PS_LIST_TAIL, "-cal_id",  0,
    75             "search for calibration ID", NULL);
    76     psMetadataAddU64(runsArgs, PS_LIST_TAIL, "-limit",  0,
    77             "limit result set to N items", 0);
    78     psMetadataAddBool(runsArgs, PS_LIST_TAIL, "-faulted",  0,
    79             "only return imfiles with a fault status set", false);
    80     psMetadataAddBool(runsArgs, PS_LIST_TAIL, "-simple",  0,
    81             "use the simple output format", false);
     67    psMetadataAddStr(runsArgs, PS_LIST_TAIL, "-cal_id",  0,            "search for calibration ID", NULL);
     68    psMetadataAddU64(runsArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     69    psMetadataAddBool(runsArgs, PS_LIST_TAIL, "-faulted",  0,            "only return imfiles with a fault status set", false);
     70    psMetadataAddBool(runsArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    8271
    8372    psFree(now);
    … …  
    8675    psMetadata *modes = psMetadataAlloc();
    8776
    88     PXOPT_ADD_MODE("-adddb",   "add a DVO calibration DB",
    89         CALTOOL_MODE_ADDDB,     adddbArgs);
    90     PXOPT_ADD_MODE("-dbs",     "list DVO calibration DBs",
    91         CALTOOL_MODE_DBS,       dbsArgs);
    92     PXOPT_ADD_MODE("-addrun",  "add the results of a calibration run",
    93         CALTOOL_MODE_ADDRUN,    addrunArgs);
    94     PXOPT_ADD_MODE("-runs",    "list the results of calibration runs",
    95         CALTOOL_MODE_RUNS,      runsArgs);
     77    PXOPT_ADD_MODE("-adddb",   "add a DVO calibration DB",        CALTOOL_MODE_ADDDB,     adddbArgs);
     78    PXOPT_ADD_MODE("-dbs",     "list DVO calibration DBs",        CALTOOL_MODE_DBS,       dbsArgs);
     79    PXOPT_ADD_MODE("-addrun",  "add the results of a calibration run",        CALTOOL_MODE_ADDRUN,    addrunArgs);
     80    PXOPT_ADD_MODE("-runs",    "list the results of calibration runs",        CALTOOL_MODE_RUNS,      runsArgs);
    9681
    9782    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {
    … …  
    10590    psFree(argSets);
    10691    psFree(modes);
    107 
    108     // generate SQL where clause
    109     config->where = psMetadataAlloc();
    110 
    111     PXOPT_ADD_WHERE_STR(det_id);
    112     PXOPT_ADD_WHERE_S32(iteration);
    113     PXOPT_ADD_WHERE_S16_ALIAS("-code", "fault");
    114 
    115     if (config->where->list->n < 1) {
    116         psFree(config->where);
    117         config->where = NULL;
    118     }
    11992
    12093    // define Database handle, if used

  • branches/eam_branch_20080706/ippTools/src/camtoolConfig.c

    r18468 r18491  
    300300    psFree(modes);
    301301
    302     // generate SQL where clause
    303     // XXX config->where = psMetadataAlloc();
    304     // XXX PXOPT_ADD_WHERE_S64(cam_id);
    305     // XXX PXOPT_ADD_WHERE_S64(chip_id);
    306     // XXX PXOPT_ADD_WHERE_STR_ALIAS("-inst","camera");
    307     // XXX PXOPT_ADD_WHERE_S32(imfiles);
    308     // XXX PXOPT_ADD_WHERE_STR(telescope);
    309     // XXX PXOPT_ADD_WHERE_STR(exp_type);
    310     // XXX PXOPT_ADD_WHERE_STR(class_id);
    311     // XXX PXOPT_ADD_WHERE_STR(filter);
    312     // XXX PXOPT_ADD_WHERE_STR_ALIAS("-code","fault");
    313     // XXX if (psListLength(config->where->list) < 1) {
    314     // XXX     psFree(config->where);
    315     // XXX     config->where = NULL;
    316     // XXX }
    317 
    318 
    319302    // define Database handle, if used
    320303    config->dbh = psMemIncrRefCounter(pmConfigDB(config->modules));

  • branches/eam_branch_20080706/ippTools/src/detselectConfig.c

    r18468 r18491  
    8383    psFree(modes);
    8484
    85     // setup search criterion
    86     // generate SQL where clause
    87     // config->where = psMetadataAlloc();
    88 
    89     // PXOPT_ADD_WHERE_STR(det_id);
    90     // PXOPT_ADD_WHERE_S32(iteration);
    91     // PXOPT_ADD_WHERE_STR(exp_id);
    92     // PXOPT_ADD_WHERE_STR_ALIAS("-inst","camera");
    93     // PXOPT_ADD_WHERE_STR(telescope);
    94     // PXOPT_ADD_WHERE_STR(det_type);
    95     // PXOPT_ADD_WHERE_STR_ALIAS("-type","det_type");
    96     // PXOPT_ADD_WHERE_STR(exp_type);
    97     // PXOPT_ADD_WHERE_S32(imfiles);
    98     // PXOPT_ADD_WHERE_STR(class);
    99     // PXOPT_ADD_WHERE_STR(class_id);
    100     // PXOPT_ADD_WHERE_STR(filter);
    101 
    102     //    PXOPT_ADD_WHERE_F32(exp_time);
    103     //    PXOPT_ADD_WHERE_F64(ccd_temp);
    104     //    PXOPT_ADD_WHERE_F32(airmass);
    105     //    PXOPT_ADD_WHERE_TIME_STR(use_begin);
    106     //    PXOPT_ADD_WHERE_TIME_STR(use_end);
    107 
    108     // if (config->where->list->n < 1) {
    109     //     psFree(config->where);
    110     //     config->where = NULL;
    111     // }
    112 
    113 
    11485    // define Database handle, if used
    11586    config->dbh = psMemIncrRefCounter(pmConfigDB(config->modules));

  • branches/eam_branch_20080706/ippTools/src/dettool.c

    r18480 r18491  
    23602360    PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    23612361
    2362     psString query = pxDataGet("dettool_revertstacked.sql");
     2362    psString query = pxDataGet("dettool_normalizedimfile.sql");
    23632363    if (!query) {
    23642364        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");

  • branches/eam_branch_20080706/ippTools/src/difftool.c

    r18336 r18491  
    104104
    105105    // default
     106    PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
    106107    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    107     PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
    108108
    109109    diffRunRow *run = diffRunRowAlloc(
    … …  
    282282    PS_ASSERT_PTR_NON_NULL(config, false);
    283283
     284    psMetadata *where = psMetadataAlloc();
     285
     286    PXOPT_COPY_S64(config->args, where,  "-diff_id", "diff_id", "==");
     287    PXOPT_COPY_S64(config->args, where, "-warp_id", "warp_id", "==");
     288    PXOPT_COPY_STR(config->args, where, "-skycell_id", "skycell_id", "==");
     289    PXOPT_COPY_STR(config->args, where,  "-tess_id", "tess_id", "==");
     290    PXOPT_COPY_STR(config->args, where,  "-kind", "kind", "==");
     291
    284292    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    285293    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     294    PXOPT_LOOKUP_BOOL(template, config->args, "-template", false);
    286295
    287296    // find all rawImfiles matching the default query
    … …  
    292301    }
    293302
    294     if (config->where) {
    295         psString whereClause = psDBGenerateWhereSQL(config->where, NULL);
    296         psStringAppend(&query, " %s", whereClause);
     303    if (template) {
     304        // list only faulted rows
     305        psStringAppend(&query, " %s", "WHERE diffInputSkyfile.template != 0");
     306    } else {
     307        // don't list faulted rows
     308        psStringAppend(&query, " %s", "WHERE diffInputSkyfile.template = 0");
     309    }
     310
     311    if (psListLength(where->list)) {
     312        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     313        psStringAppend(&query, " AND %s", whereClause);
    297314        psFree(whereClause);
    298315    }
     316    psFree(where);
    299317
    300318    // treat limit == 0 as "no limit"
    … …  
    351369    PS_ASSERT_PTR_NON_NULL(config, false);
    352370
     371    psMetadata *where = psMetadataAlloc();
     372    PXOPT_COPY_S64(config->args, where,  "-diff_id", "diff_id", "==");
     373
    353374    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    354375    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    … …  
    360381    }
    361382
    362     if (config->where) {
    363         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "diffSkyfile");
     383    if (psListLength(where->list)) {
     384        psString whereClause = psDBGenerateWhereConditionSQL(where, "diffSkyfile");
    364385        psStringAppend(&query, " AND %s", whereClause);
    365386        psFree(whereClause);
    366387    }
     388    psFree(where);
    367389
    368390    // treat limit == 0 as "no limit"
    … …  
    418440{
    419441    PS_ASSERT_PTR_NON_NULL(config, false);
    420 
    421     // required
    422     PXOPT_LOOKUP_S64(diff_id, config->args, "-diff_id", true, false);
    423 
    424     // default to 0
     442   
     443    PXOPT_LOOKUP_S64(diff_id, config->args, "-diff_id", true, false); // required
    425444    PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
    426 
    427     PXOPT_LOOKUP_STR(uri, config->args, "-uri", false, false);
    428     if (code == 0 && !uri) {
    429         psError(PS_ERR_UNKNOWN, true, "-uri is required");
    430         return false;
    431     }
    432 
    433     PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", false, false);
    434     if (code == 0 && !path_base) {
    435         psError(PS_ERR_UNKNOWN, true, "-path_base is required");
    436         return false;
    437     }
     445    PXOPT_LOOKUP_STR(uri, config->args, "-uri", (code == 0), false);
     446    PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", (code == 0), false);
    438447
    439448    // optional
    … …  
    441450    PXOPT_LOOKUP_F64(bg_stdev, config->args, "-bg_stdev", false, false);
    442451    PXOPT_LOOKUP_F32(dtime_diff, config->args, "-dtime_diff", false, false);
    443     PXOPT_LOOKUP_STR(hostname, config->args, "-hostname", false, false);
    444     PXOPT_LOOKUP_F32(good_frac, config->args, "-good_frac", false, false);
    445452    PXOPT_LOOKUP_S32(stamps_num, config->args, "-stamps_num", false, false);
    446453    PXOPT_LOOKUP_F32(stamps_rms, config->args, "-stamps_rms", false, false);
    447454    PXOPT_LOOKUP_S32(sources, config->args, "-sources", false, false);
     455    PXOPT_LOOKUP_STR(hostname, config->args, "-hostname", false, false);
     456    PXOPT_LOOKUP_F32(good_frac, config->args, "-good_frac", false, false);
    448457
    449458    if (!psDBTransaction(config->dbh)) {
    … …  
    495504    PS_ASSERT_PTR_NON_NULL(config, false);
    496505
     506    psMetadata *where = psMetadataAlloc();
     507    PXOPT_COPY_S64(config->args, where,  "-diff_id", "diff_id", "==");
     508    PXOPT_COPY_STR(config->args, where, "-skycell_id", "skycell_id", "==");
     509    PXOPT_COPY_STR(config->args, where, "-tess_id", "tess_id", "==");
     510
    497511    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    498512    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    … …  
    504518    }
    505519
    506     if (config->where) {
    507         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "diffSkyfile");
     520    if (psListLength(where->list)) {
     521        psString whereClause = psDBGenerateWhereConditionSQL(where, "diffSkyfile");
    508522        psStringAppend(&query, " AND %s", whereClause);
    509523        psFree(whereClause);
    510524    }
     525    psFree(where);
    511526
    512527    // treat limit == 0 as "no limit"
    … …  
    563578    PS_ASSERT_PTR_NON_NULL(config, false);
    564579
     580    psMetadata *where = psMetadataAlloc();
     581    PXOPT_COPY_S64(config->args, where,  "-diff_id", "diff_id", "==");
     582    PXOPT_COPY_S16(config->args, where, "-code",     "fault", "==");
     583
    565584    psString query = pxDataGet("difftool_revertdiffskyfile.sql");
    566585    if (!query) {
    … …  
    569588    }
    570589
    571     if (config->where) {
    572         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "diffSkyfile");
     590    if (psListLength(where->list)) {
     591        psString whereClause = psDBGenerateWhereConditionSQL(where, "diffSkyfile");
    573592        psStringAppend(&query, " AND %s", whereClause);
    574593        psFree(whereClause);
    575594    }
     595    psFree(where);
    576596
    577597    if (!p_psDBRunQuery(config->dbh, query)) {
    … …  
    741761    PS_ASSERT_PTR_NON_NULL(config, false);
    742762
    743     // required options
    744     PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false);
    745     PXOPT_LOOKUP_STR(skycell_id, config->args, "-skycell_id", true, false);
    746     PXOPT_LOOKUP_STR(tess_id, config->args, "-tess_id", true, false);
    747 
    748     // optional
     763    PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false); // required options
     764    PXOPT_LOOKUP_STR(skycell_id, config->args, "-skycell_id", true, false); // required options
     765    PXOPT_LOOKUP_STR(tess_id, config->args, "-tess_id", true, false); // required options
     766    PXOPT_LOOKUP_S64(template_warp_id, config->args, "-template_warp_id", false, false);
    749767    PXOPT_LOOKUP_S64(template_stack_id, config->args, "-template_stack_id", false, false);
    750     PXOPT_LOOKUP_S64(template_warp_id, config->args, "-template_warp_id", false, false);
     768    PXOPT_LOOKUP_S64(input_warp_id, config->args, "-input_warp_id", false, false);
     769    PXOPT_LOOKUP_S64(input_stack_id, config->args, "-input_stack_id", false, false);
    751770
    752771    if (template_stack_id && template_warp_id) {
    … …  
    760779    }
    761780
    762     PXOPT_LOOKUP_S64(input_stack_id, config->args, "-input_stack_id", false, false);
    763     PXOPT_LOOKUP_S64(input_warp_id, config->args, "-input_warp_id", false, false);
    764781    if (input_stack_id && input_warp_id) {
    765782        psError(PS_ERR_BAD_PARAMETER_VALUE, true, "Only one input can be defined.");
    … …  
    787804    PS_ASSERT_PTR_NON_NULL(config, false);
    788805
    789     // required options
    790     PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false);
    791 
    792     // default
     806    psMetadata *where = psMetadataAlloc();
     807
     808    PXOPT_COPY_S64(config->args, where,  "-diff_id", "diff_id", "==");
     809    PXOPT_COPY_S64(config->args, where, "-warp_id", "warp_id", "==");
     810    PXOPT_COPY_STR(config->args, where, "-skycell_id", "skycell_id", "==");
     811    PXOPT_COPY_STR(config->args, where,  "-tess_id", "tess_id", "==");
     812    PXOPT_COPY_STR(config->args, where,  "-kind", "kind", "==");
     813    PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false); // required options
     814    PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
     815    PXOPT_LOOKUP_BOOL(template, config->args, "-template", false);
    793816    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    794     PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
    795817
    796818    // find all things to queue
    … …  
    801823    }
    802824
    803     if (config->where) {
    804         psString whereClause = psDBGenerateWhereSQL(config->where, NULL);
    805         psStringAppend(&query, " %s", whereClause);
     825    if (template) {
     826        // list only faulted rows
     827        psStringAppend(&query, " %s", "WHERE diffInputSkyfile.template != 0");
     828    } else {
     829        // don't list faulted rows
     830        psStringAppend(&query, " %s", "WHERE diffInputSkyfile.template = 0");
     831    }
     832
     833    if (psListLength(where->list)) {
     834        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     835        psStringAppend(&query, " AND %s", whereClause);
    806836        psFree(whereClause);
    807837    }
     838    psFree(where);
    808839
    809840    if (!p_psDBRunQuery(config->dbh, query)) {

  • branches/eam_branch_20080706/ippTools/src/difftoolConfig.c

    r18468 r18491  
    4747    // -definerun
    4848    psMetadata *definerunArgs = psMetadataAlloc();
    49     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-workdir", 0,
    50             "define workdir (required)", NULL);
    51     psMetadataAddTime(definerunArgs, PS_LIST_TAIL, "-registered",  0,
    52             "time detrend run was registered", now);
    53     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-skycell_id",  0,
    54             "define skycell ID (required)", NULL);
    55     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-tess_id",  0,
    56             "define tessellation ID (required)", NULL);
    57     psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-simple",  0,
    58             "use the simple output format", false);
     49    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-workdir", 0,            "define workdir (required)", NULL);
     50    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-skycell_id",  0,            "define skycell ID (required)", NULL);
     51    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-tess_id",  0,            "define tessellation ID (required)", NULL);
     52    psMetadataAddTime(definerunArgs, PS_LIST_TAIL, "-registered",  0,            "time detrend run was registered", now);
     53    psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    5954
    6055    // -updaterun
    6156    psMetadata *updaterunArgs = psMetadataAlloc();
    62     psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-diff_id", 0,
    63             "define diff ID (required)", 0);
    64     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,
    65             "set state (required)", NULL);
    66 #if 0
    67     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-workdir", 0,
    68             "define workdir (required)", NULL);
    69     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-registered",  0,
    70             "time detrend run was registered", now);
    71 #endif
     57    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-diff_id", 0,            "define diff ID (required)", 0);
     58    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,            "set state (required)", NULL);
    7259
    7360    // -addinputskyfile
    7461    psMetadata *addinputskyfileArgs = psMetadataAlloc();
    75     psMetadataAddS64(addinputskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,
    76             "define diff ID (required)", 0);
    77     psMetadataAddS64(addinputskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,
    78             "define warp ID", 0);
    79     psMetadataAddS64(addinputskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,
    80             "define stack ID", 0);
    81     psMetadataAddStr(addinputskyfileArgs, PS_LIST_TAIL, "-kind", 0,
    82             "define kind", NULL);
    83     psMetadataAddBool(addinputskyfileArgs, PS_LIST_TAIL, "-template",  0,
    84             "this sky cell file is the subtrahend", false);
     62    psMetadataAddS64(addinputskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,            "define diff ID (required)", 0);
     63    psMetadataAddS64(addinputskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,            "define stack ID", 0);
     64    psMetadataAddS64(addinputskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,            "define warp ID", 0);
     65    psMetadataAddStr(addinputskyfileArgs, PS_LIST_TAIL, "-kind", 0,            "define kind", NULL);
     66    psMetadataAddBool(addinputskyfileArgs, PS_LIST_TAIL, "-template",  0,            "this sky cell file is the subtrahend", false);
    8567
    8668    // -inputskyfile
    8769    psMetadata *inputskyfileArgs = psMetadataAlloc();
    88     psMetadataAddS64(inputskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,
    89             "search by diff ID", 0);
    90     psMetadataAddS64(inputskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,
    91             "search by warp ID", 0);
    92     psMetadataAddStr(inputskyfileArgs, PS_LIST_TAIL, "-skycell_id", 0,
    93             "search by skycell ID", NULL);
    94     psMetadataAddStr(inputskyfileArgs, PS_LIST_TAIL, "-tess_id", 0,
    95             "search by tess ID", NULL);
    96     psMetadataAddStr(inputskyfileArgs, PS_LIST_TAIL, "-kind", 0,
    97             "search by kind", NULL);
    98     psMetadataAddBool(inputskyfileArgs, PS_LIST_TAIL, "-template",  0,
    99             "search by subtrahend", false);
    100     psMetadataAddU64(inputskyfileArgs, PS_LIST_TAIL, "-limit",  0,
    101             "limit result set to N items", 0);
    102     psMetadataAddBool(inputskyfileArgs, PS_LIST_TAIL, "-simple",  0,
    103             "use the simple output format", false);
     70    psMetadataAddS64(inputskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,            "search by diff ID", 0);
     71    psMetadataAddS64(inputskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,            "search by warp ID", 0);
     72    psMetadataAddStr(inputskyfileArgs, PS_LIST_TAIL, "-skycell_id", 0,            "search by skycell ID", NULL);
     73    psMetadataAddStr(inputskyfileArgs, PS_LIST_TAIL, "-tess_id", 0,            "search by tess ID", NULL);
     74    psMetadataAddStr(inputskyfileArgs, PS_LIST_TAIL, "-kind", 0,            "search by kind", NULL);
     75    psMetadataAddBool(inputskyfileArgs, PS_LIST_TAIL, "-template",  0,            "search by subtrahend", false);
     76    psMetadataAddU64(inputskyfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     77    psMetadataAddBool(inputskyfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    10478
    10579    // -todiffskyfile
    10680    psMetadata *todiffskyfileArgs = psMetadataAlloc();
    107     psMetadataAddS64(todiffskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,
    108             "search by diff ID", 0);
    109     psMetadataAddU64(todiffskyfileArgs, PS_LIST_TAIL, "-limit",  0,
    110             "limit result set to N items", 0);
    111     psMetadataAddBool(todiffskyfileArgs, PS_LIST_TAIL, "-simple",  0,
    112             "use the simple output format", false);
     81    psMetadataAddS64(todiffskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,            "search by diff ID", 0);
     82    psMetadataAddU64(todiffskyfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     83    psMetadataAddBool(todiffskyfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    11384
    11485    // -adddiffskyfile
    11586    psMetadata *adddiffskyfileArgs = psMetadataAlloc();
    116     psMetadataAddS64(adddiffskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,
    117             "define warp ID (required)", 0);
    118     psMetadataAddStr(adddiffskyfileArgs, PS_LIST_TAIL, "-uri", 0,
    119             "define URI of file", 0);
    120     psMetadataAddStr(adddiffskyfileArgs, PS_LIST_TAIL, "-path_base", 0,
    121             "define base output location", 0);
    122     psMetadataAddF64(adddiffskyfileArgs, PS_LIST_TAIL, "-bg",  0,
    123             "define exposure background", NAN);
    124     psMetadataAddF64(adddiffskyfileArgs, PS_LIST_TAIL, "-bg_stdev",  0,
    125             "define exposure background mean stdev", NAN);
    126     psMetadataAddF32(adddiffskyfileArgs, PS_LIST_TAIL, "-dtime_diff",  0,
    127             "define elapsed processing time", NAN);
    128     psMetadataAddS32(adddiffskyfileArgs, PS_LIST_TAIL, "-stamps_num",  0,
    129             "define subtraction stamp number", 0);
    130     psMetadataAddF32(adddiffskyfileArgs, PS_LIST_TAIL, "-stamps_rms",  0,
    131             "define subtraction stamp rms", NAN);
    132     psMetadataAddS32(adddiffskyfileArgs, PS_LIST_TAIL, "-sources",  0,
    133             "define number of sources", 0);
    134     psMetadataAddStr(adddiffskyfileArgs, PS_LIST_TAIL, "-hostname", 0,
    135             "define hostname", 0);
    136     psMetadataAddF32(adddiffskyfileArgs, PS_LIST_TAIL, "-good_frac",  0,
    137             "define %% of good pixels", NAN);
    138     psMetadataAddS16(adddiffskyfileArgs, PS_LIST_TAIL, "-code",  0,
    139             "set fault code", 0);
     87    psMetadataAddS64(adddiffskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,            "define warp ID (required)", 0);
     88    psMetadataAddS16(adddiffskyfileArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
     89    psMetadataAddStr(adddiffskyfileArgs, PS_LIST_TAIL, "-uri", 0,            "define URI of file", 0);
     90    psMetadataAddStr(adddiffskyfileArgs, PS_LIST_TAIL, "-path_base", 0,            "define base output location", 0);
     91    psMetadataAddF64(adddiffskyfileArgs, PS_LIST_TAIL, "-bg",  0,            "define exposure background", NAN);
     92    psMetadataAddF64(adddiffskyfileArgs, PS_LIST_TAIL, "-bg_stdev",  0,            "define exposure background mean stdev", NAN);
     93    psMetadataAddF32(adddiffskyfileArgs, PS_LIST_TAIL, "-dtime_diff",  0,            "define elapsed processing time", NAN);
     94    psMetadataAddS32(adddiffskyfileArgs, PS_LIST_TAIL, "-stamps_num",  0,            "define subtraction stamp number", 0);
     95    psMetadataAddF32(adddiffskyfileArgs, PS_LIST_TAIL, "-stamps_rms",  0,            "define subtraction stamp rms", NAN);
     96    psMetadataAddS32(adddiffskyfileArgs, PS_LIST_TAIL, "-sources",  0,            "define number of sources", 0);
     97    psMetadataAddStr(adddiffskyfileArgs, PS_LIST_TAIL, "-hostname", 0,            "define hostname", 0);
     98    psMetadataAddF32(adddiffskyfileArgs, PS_LIST_TAIL, "-good_frac",  0,            "define %% of good pixels", NAN);
    14099
    141100    // -diffskyfile
    142101    psMetadata *diffskyfileArgs = psMetadataAlloc();
    143     psMetadataAddS64(diffskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,
    144             "search by warp ID", 0);
    145     psMetadataAddStr(diffskyfileArgs , PS_LIST_TAIL, "-skycell_id",  0,
    146             "define skycell ID", NULL);
    147     psMetadataAddStr(diffskyfileArgs, PS_LIST_TAIL, "-tess_id",  0,
    148             "define tessellation ID", NULL);
    149     psMetadataAddU64(diffskyfileArgs, PS_LIST_TAIL, "-limit",  0,
    150             "limit result set to N items", 0);
    151     psMetadataAddBool(diffskyfileArgs, PS_LIST_TAIL, "-simple",  0,
    152             "use the simple output format", false);
     102    psMetadataAddS64(diffskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,            "search by warp ID", 0);
     103    psMetadataAddStr(diffskyfileArgs , PS_LIST_TAIL, "-skycell_id",  0,            "define skycell ID", NULL);
     104    psMetadataAddStr(diffskyfileArgs, PS_LIST_TAIL, "-tess_id",  0,            "define tessellation ID", NULL);
     105    psMetadataAddU64(diffskyfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     106    psMetadataAddBool(diffskyfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    153107
    154108    // -revertdiffskyfile
    155109    psMetadata *revertdiffskyfileArgs = psMetadataAlloc();
    156     psMetadataAddS64(revertdiffskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,
    157             "define warp ID (required)", 0);
    158     psMetadataAddS16(revertdiffskyfileArgs, PS_LIST_TAIL, "-code",  0,
    159             "search by fault code", 0);
     110    psMetadataAddS64(revertdiffskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,            "define warp ID (required)", 0);
     111    psMetadataAddS16(revertdiffskyfileArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
    160112
    161113    // -definepoprun
    162114    psMetadata *definepoprunArgs = psMetadataAlloc();
    163     psMetadataAddStr(definepoprunArgs, PS_LIST_TAIL, "-workdir", 0,
    164             "define workdir (required)", NULL);
    165     psMetadataAddTime(definepoprunArgs, PS_LIST_TAIL, "-registered",  0,
    166             "time detrend run was registered", now);
    167     psMetadataAddStr(definepoprunArgs, PS_LIST_TAIL, "-skycell_id",  0,
    168             "define skycell ID (required)", NULL);
    169     psMetadataAddStr(definepoprunArgs, PS_LIST_TAIL, "-tess_id",  0,
    170             "define tessellation ID (required)", NULL);
    171     psMetadataAddBool(definepoprunArgs, PS_LIST_TAIL, "-simple",  0,
    172             "use the simple output format", false);
    173     psMetadataAddS64(definepoprunArgs, PS_LIST_TAIL, "-template_warp_id", 0,
    174             "define warp ID for template", 0);
    175     psMetadataAddS64(definepoprunArgs, PS_LIST_TAIL, "-template_stack_id", 0,
    176             "define stack ID for template", 0);
    177     psMetadataAddS64(definepoprunArgs, PS_LIST_TAIL, "-input_warp_id", 0,
    178             "define warp ID for input", 0);
    179     psMetadataAddS64(definepoprunArgs, PS_LIST_TAIL, "-input_stack_id", 0,
    180             "define stack ID for input", 0);
     115    psMetadataAddStr(definepoprunArgs, PS_LIST_TAIL, "-workdir", 0,            "define workdir (required)", NULL);
     116    psMetadataAddTime(definepoprunArgs, PS_LIST_TAIL, "-registered",  0,            "time detrend run was registered", now);
     117    psMetadataAddStr(definepoprunArgs, PS_LIST_TAIL, "-skycell_id",  0,            "define skycell ID (required)", NULL);
     118    psMetadataAddStr(definepoprunArgs, PS_LIST_TAIL, "-tess_id",  0,            "define tessellation ID (required)", NULL);
     119    psMetadataAddBool(definepoprunArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     120    psMetadataAddS64(definepoprunArgs, PS_LIST_TAIL, "-template_warp_id", 0,            "define warp ID for template", 0);
     121    psMetadataAddS64(definepoprunArgs, PS_LIST_TAIL, "-template_stack_id", 0,            "define stack ID for template", 0);
     122    psMetadataAddS64(definepoprunArgs, PS_LIST_TAIL, "-input_warp_id", 0,            "define warp ID for input", 0);
     123    psMetadataAddS64(definepoprunArgs, PS_LIST_TAIL, "-input_stack_id", 0,            "define stack ID for input", 0);
    181124
    182125    // -definebyquery
    183126    psMetadata *queueArgs = psMetadataAlloc();
    184     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-workdir", 0,
    185             "define workdir (required)", NULL);
    186     psMetadataAddTime(queueArgs, PS_LIST_TAIL, "-registered",  0,
    187             "time detrend run was registered", now);
    188     psMetadataAddBool(queueArgs, PS_LIST_TAIL, "-simple",  0,
    189             "use the simple output format", false);
     127    psMetadataAddS64(queueArgs, PS_LIST_TAIL, "-diff_id", 0,            "search by diff ID", 0);
     128    psMetadataAddS64(queueArgs, PS_LIST_TAIL, "-warp_id", 0,            "search by warp ID", 0);
     129    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-skycell_id", 0,            "search by skycell ID", NULL);
     130    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-tess_id", 0,            "search by tess ID", NULL);
     131    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-kind", 0,            "search by kind", NULL);
     132    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-workdir", 0,            "define workdir (required)", NULL);
     133    psMetadataAddTime(queueArgs, PS_LIST_TAIL, "-registered",  0,            "time detrend run was registered", now);
     134    psMetadataAddBool(queueArgs, PS_LIST_TAIL, "-template",  0,            "search by subtrahend", false);
     135    psMetadataAddBool(queueArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    190136
    191137    psFree(now);
    … …  
    216162    psFree(modes);
    217163
    218     // generate SQL where clause
    219     config->where = psMetadataAlloc();
    220 
    221     PXOPT_ADD_WHERE_S64(diff_id);
    222     PXOPT_ADD_WHERE_S64(warp_id);
    223     PXOPT_ADD_WHERE_STR(skycell_id);
    224     PXOPT_ADD_WHERE_STR(tess_id);
    225     PXOPT_ADD_WHERE_STR_ALIAS("-code", "fault");
    226 
    227     if (config->where->list->n < 1) {
    228         psFree(config->where);
    229         config->where = NULL;
    230     }
    231 
    232164    // define Database handle, if used
    233165    // do this last so we don't setup a connection before CLI options are

  • branches/eam_branch_20080706/ippTools/src/pxinjectConfig.c

    r18468 r18491  
    4545    // -newExp
    4646    psMetadata *newExpArgs = psMetadataAlloc();
    47     psMetadataAddStr(newExpArgs, PS_LIST_TAIL, "-tmp_exp_name",  0,
    48             "define the exp_name (required)", NULL);
    49     psMetadataAddStr(newExpArgs, PS_LIST_TAIL, "-tmp_inst",  0,
    50             "define the camera name (required)", NULL);
    51     psMetadataAddStr(newExpArgs, PS_LIST_TAIL, "-tmp_telescope",  0,
    52             "define the telescope name (required)", NULL);
    53     psMetadataAddStr(newExpArgs, PS_LIST_TAIL, "-workdir",  0,
    54             "define workdir (required)", 0);
    55     psMetadataAddStr(newExpArgs, PS_LIST_TAIL, "-reduction",  0,
    56             "define reduction class", NULL);
    57     psMetadataAddStr(newExpArgs, PS_LIST_TAIL, "-dvodb",  0,
    58             "define the dvodb for the next processing step", NULL);
    59     psMetadataAddStr(newExpArgs, PS_LIST_TAIL, "-tess_id",  0,
    60             "define the tess_id for the next processing step", NULL);
    61     psMetadataAddStr(newExpArgs, PS_LIST_TAIL, "-end_stage",  0,
    62             "define the end goal processing step", NULL);
    63     psMetadataAddStr(newExpArgs, PS_LIST_TAIL, "-label",  0,
    64             "define a label (carried to chip stage)", NULL);
    65     psMetadataAddBool(newExpArgs, PS_LIST_TAIL, "-simple",  0,
    66             "use the simple output format", false);
     47    psMetadataAddStr(newExpArgs, PS_LIST_TAIL, "-tmp_exp_name",  0,            "define the exp_name (required)", NULL);
     48    psMetadataAddStr(newExpArgs, PS_LIST_TAIL, "-tmp_inst",  0,            "define the camera name (required)", NULL);
     49    psMetadataAddStr(newExpArgs, PS_LIST_TAIL, "-tmp_telescope",  0,            "define the telescope name (required)", NULL);
     50    psMetadataAddStr(newExpArgs, PS_LIST_TAIL, "-workdir",  0,            "define workdir (required)", 0);
     51    psMetadataAddStr(newExpArgs, PS_LIST_TAIL, "-reduction",  0,            "define reduction class", NULL);
     52    psMetadataAddStr(newExpArgs, PS_LIST_TAIL, "-dvodb",  0,            "define the dvodb for the next processing step", NULL);
     53    psMetadataAddStr(newExpArgs, PS_LIST_TAIL, "-tess_id",  0,            "define the tess_id for the next processing step", NULL);
     54    psMetadataAddStr(newExpArgs, PS_LIST_TAIL, "-end_stage",  0,            "define the end goal processing step", NULL);
     55    psMetadataAddStr(newExpArgs, PS_LIST_TAIL, "-label",  0,            "define a label (carried to chip stage)", NULL);
     56    psMetadataAddBool(newExpArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    6757
    6858    // -newImfile
    6959    psMetadata *newImfileArgs = psMetadataAlloc();
    70     psMetadataAddS64(newImfileArgs, PS_LIST_TAIL, "-exp_id",  0,
    71             "define the exp_id (required)", 0);
    72     psMetadataAddStr(newImfileArgs, PS_LIST_TAIL, "-tmp_class_id",  0,
    73             "define the class ID (required)", NULL);
    74     psMetadataAddStr(newImfileArgs, PS_LIST_TAIL, "-uri",  0,
    75             "define the URI (required)", NULL);
     60    psMetadataAddS64(newImfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "define the exp_id (required)", 0);
     61    psMetadataAddStr(newImfileArgs, PS_LIST_TAIL, "-tmp_class_id",  0,            "define the class ID (required)", NULL);
     62    psMetadataAddStr(newImfileArgs, PS_LIST_TAIL, "-uri",  0,            "define the URI (required)", NULL);
    7663
    7764    // -updatenewExp
    7865    psMetadata *updatenewExpArgs = psMetadataAlloc();
    79     psMetadataAddS64(updatenewExpArgs, PS_LIST_TAIL, "-exp_id",  0,
    80             "define the exp_id (required)", 0);
    81     psMetadataAddStr(updatenewExpArgs, PS_LIST_TAIL, "-state", 0,
    82             "set state (required)", NULL);
    83 
     66    psMetadataAddS64(updatenewExpArgs, PS_LIST_TAIL, "-exp_id",  0,            "define the exp_id (required)", 0);
     67    psMetadataAddStr(updatenewExpArgs, PS_LIST_TAIL, "-state", 0,            "set state (required)", NULL);
    8468
    8569    psMetadata *argSets = psMetadataAlloc();
    … …  
    10185    psFree(modes);
    10286
    103     // generate SQL where clause
    104     config->where = psMetadataAlloc();
    105 
    106     // XXXX this funciton had a large number of bogus entries
    107     PXOPT_ADD_WHERE_S64(exp_id);
    108     PXOPT_ADD_WHERE_STR(class_id);
    109 
    110     if (config->where->list->n < 1) {
    111         psFree(config->where);
    112         config->where = NULL;
    113     }
    114 
    11587    // define Database handle, if used
    11688    // do this last so we don't setup a connection before CLI options are

  • branches/eam_branch_20080706/ippTools/src/pztool.c

    r18314 r18491  
    162162    PS_ASSERT_PTR_NON_NULL(config, false);
    163163
     164    psMetadata *where = psMetadataAlloc();
     165    PXOPT_COPY_STR(config->args, where,  "-exp_name",     "exp_name", "==");
     166    PXOPT_COPY_STR(config->args, where,  "-inst",         "camera", "==");
     167    PXOPT_COPY_STR(config->args, where,  "-telescope",    "telescope", "==");
     168    PXOPT_COPY_STR(config->args, where,  "-exp_type",     "exp_type", "==");
     169
    164170    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    165171
    166172    psString query = psStringCopy("SELECT * FROM summitExp");
    167173
    168     if (config->where) {
    169         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "summitExp");
     174    if (psListLength(where->list)) {
     175        psString whereClause = psDBGenerateWhereConditionSQL(where, "summitExp");
    170176        psStringAppend(&query, " AND %s", whereClause);
    171177        psFree(whereClause);
    172178    }
     179    psFree(where);
    173180
    174181    if (!p_psDBRunQuery(config->dbh, query)) {
    … …  
    206213    PS_ASSERT_PTR_NON_NULL(config, false);
    207214
     215    psMetadata *where = psMetadataAlloc();
     216    PXOPT_COPY_STR(config->args, where,  "-exp_name",     "exp_name", "==");
     217    PXOPT_COPY_STR(config->args, where,  "-inst",         "camera", "==");
     218    PXOPT_COPY_STR(config->args, where,  "-telescope",    "telescope", "==");
     219    PXOPT_COPY_STR(config->args, where,  "-exp_type",     "exp_type", "==");
     220
    208221    PXOPT_LOOKUP_BOOL(desc, config->args, "-desc", false);
    209222    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    210223    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    211224
     225    // XXX leave this query here ?
    212226    psString query = psStringCopy(
    213227            "SELECT"
    … …  
    223237        );
    224238
    225     if (config->where) {
    226         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "pzDownloadExp");
     239    if (psListLength(where->list)) {
     240        psString whereClause = psDBGenerateWhereConditionSQL(where, "pzDownloadExp");
    227241        psStringAppend(&query, " AND %s", whereClause);
    228242        psFree(whereClause);
    229243    }
     244    psFree(where);
    230245
    231246    psStringAppend(&query, " ORDER BY summitExp.dateobs");
    … …  
    274289{
    275290    PS_ASSERT_PTR_NON_NULL(config, false);
     291
     292    psMetadata *where = psMetadataAlloc();
     293    PXOPT_COPY_STR(config->args, where,  "-exp_name",     "exp_name", "==");
     294    PXOPT_COPY_STR(config->args, where,  "-inst",         "camera", "==");
     295    PXOPT_COPY_STR(config->args, where,  "-telescope",    "telescope", "==");
     296    PXOPT_COPY_STR(config->args, where,  "-exp_type",     "exp_type", "==");
    276297
    277298    PXOPT_LOOKUP_BOOL(desc, config->args, "-desc", false);
    … …  
    300321        psStringAppend(&query, " WHERE camera = \"%s\"", camera);
    301322
    302         if (config->where) {
    303             psString whereClause = psDBGenerateWhereConditionSQL(config->where, "pzDownloadImfile");
     323        if (psListLength(where->list)) {
     324            psString whereClause = psDBGenerateWhereConditionSQL(where, "pzDownloadImfile");
    304325            psStringAppend(&query, " AND %s", whereClause);
    305326            psFree(whereClause);
    … …  
    347368        psFree(result);
    348369    }
     370    psFree(where);
    349371
    350372    // stitch the arrays of imfiles together
    … …  
    378400    // default values
    379401    PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
     402
     403    // NOTE : the rest of the command-line args are parsed in copydoneCompleteExp
    380404
    381405    if (!pzDownloadImfileInsert(config->dbh,
    … …  
    447471    }
    448472
     473    // XXX this is a bit ugly : could just use the PXOPT_COPY_* methods
     474    // and not pass exp_name, camera, or telescope as additional args
    449475    psMetadata *where = psMetadataAlloc();
    450476    if (exp_name) {
    … …  
    472498    }
    473499
    474     if (config->where) {
     500    if (psListLength(where->list)) {
    475501        psString whereClause = psDBGenerateWhereSQL(where, NULL);
    476502        psStringAppend(&query, " %s", whereClause);
    … …  
    720746    PS_ASSERT_PTR_NON_NULL(config, false);
    721747
     748    psMetadata *where = psMetadataAlloc();
     749    PXOPT_COPY_STR(config->args, where,  "-exp_name", "exp_name", "==");
     750    PXOPT_COPY_STR(config->args, where, "-inst", "inst", "==");
     751    PXOPT_COPY_STR(config->args, where, "-telescope", "telescope", "==");
     752    PXOPT_COPY_STR(config->args, where,  "-class", "class", "==");
     753    PXOPT_COPY_STR(config->args, where,  "-class_id", "class_id", "==");
     754
    722755    PXOPT_LOOKUP_S16(code, config->args, "-code", true, false);
    723756
    724     if (!pxSetFaultCode(config->dbh, "pzDownloadImfile", config->where, code)) {
     757    if (!pxSetFaultCode(config->dbh, "pzDownloadImfile", where, code)) {
    725758        psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag");
    726         return false;
    727     }
     759        psFree (where);
     760        return false;
     761    }
     762    psFree(where);
    728763
    729764    return true;
    … …  
    734769{
    735770    PS_ASSERT_PTR_NON_NULL(config, false);
     771
     772    psMetadata *where = psMetadataAlloc();
     773    PXOPT_COPY_STR(config->args, where,  "-exp_name", "exp_name", "==");
     774    PXOPT_COPY_STR(config->args, where, "-inst", "inst", "==");
     775    PXOPT_COPY_STR(config->args, where, "-telescope", "telescope", "==");
     776    PXOPT_COPY_STR(config->args, where,  "-class", "class", "==");
     777    PXOPT_COPY_STR(config->args, where,  "-class_id", "class_id", "==");
    736778
    737779    psString query = pxDataGet("pztool_revertcopied.sql");
    … …  
    741783    }
    742784
    743     if (config->where) {
    744         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "pzDownloadImfile");
     785    if (psListLength(where->list)) {
     786        psString whereClause = psDBGenerateWhereConditionSQL(where, "pzDownloadImfile");
    745787        psStringAppend(&query, " AND %s", whereClause);
    746788        psFree(whereClause);
    747789    }
     790    psFree(where);
    748791
    749792    if (!p_psDBRunQuery(config->dbh, query)) {
    … …  
    803846{
    804847    PS_ASSERT_PTR_NON_NULL(config, false);
     848
     849    // NOTE : the command-line args are parsed in copydoneCompleteExp
    805850
    806851    // start a transaction so it's all rows or nothing

  • branches/eam_branch_20080706/ippTools/src/pztoolConfig.c

    r18468 r18491  
    4545    // -adddatastore
    4646    psMetadata *adddatastoreArgs = psMetadataAlloc();
    47     psMetadataAddStr(adddatastoreArgs, PS_LIST_TAIL, "-inst", 0,
    48             "define camera ID", NULL);
    49     psMetadataAddStr(adddatastoreArgs, PS_LIST_TAIL, "-telescope", 0,
    50             "define telescope ID", NULL);
    51     psMetadataAddStr(adddatastoreArgs, PS_LIST_TAIL, "-uri", 0,
    52             "define storage uri", NULL);
     47    psMetadataAddStr(adddatastoreArgs, PS_LIST_TAIL, "-inst", 0,            "define camera ID", NULL);
     48    psMetadataAddStr(adddatastoreArgs, PS_LIST_TAIL, "-telescope", 0,            "define telescope ID", NULL);
     49    psMetadataAddStr(adddatastoreArgs, PS_LIST_TAIL, "-uri", 0,            "define storage uri", NULL);
    5350   
    5451    // -datastore
    5552    psMetadata *datastoreArgs = psMetadataAlloc();
    56     psMetadataAddBool(datastoreArgs, PS_LIST_TAIL, "-simple", 0,
    57             "use the simple output format", false);
     53    psMetadataAddBool(datastoreArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
    5854
    5955    // -seen
    6056    psMetadata *seenArgs = psMetadataAlloc();
    61     psMetadataAddStr(seenArgs, PS_LIST_TAIL, "-exp_name", 0,
    62             "define exposure ID", NULL);
    63     psMetadataAddStr(seenArgs, PS_LIST_TAIL, "-inst", 0,
    64             "define camera ID", NULL);
    65     psMetadataAddStr(seenArgs, PS_LIST_TAIL, "-telescope", 0,
    66             "define telescope ID", NULL);
    67     psMetadataAddStr(seenArgs, PS_LIST_TAIL, "-exp_type", 0,
    68             "define exposure type", NULL);
    69     psMetadataAddBool(seenArgs, PS_LIST_TAIL, "-simple", 0,
    70             "use the simple output format", false);
     57    psMetadataAddStr(seenArgs, PS_LIST_TAIL, "-exp_name", 0,            "define exposure ID", NULL);
     58    psMetadataAddStr(seenArgs, PS_LIST_TAIL, "-inst", 0,            "define camera ID", NULL);
     59    psMetadataAddStr(seenArgs, PS_LIST_TAIL, "-telescope", 0,            "define telescope ID", NULL);
     60    psMetadataAddStr(seenArgs, PS_LIST_TAIL, "-exp_type", 0,            "define exposure type", NULL);
     61    psMetadataAddBool(seenArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
    7162   
    7263    // -pendingexp
    7364    psMetadata *pendingexpArgs = psMetadataAlloc();
    74     psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-exp_name", 0,
    75             "define exposure ID", NULL);
    76     psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-inst", 0,
    77             "define camera ID", NULL);
    78     psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-telescope", 0,
    79             "define telescope ID", NULL);
    80     psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-exp_type", 0,
    81             "define exposure type", NULL);
    82     psMetadataAddBool(pendingexpArgs, PS_LIST_TAIL, "-desc", 0,
    83             "sort ouput in descending format", false);
    84     psMetadataAddU64(pendingexpArgs, PS_LIST_TAIL, "-limit",  0,
    85             "limit result set to N items", 0);
    86     psMetadataAddBool(pendingexpArgs, PS_LIST_TAIL, "-simple", 0,
    87             "use the simple output format", false);
     65    psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-exp_name", 0,            "define exposure ID", NULL);
     66    psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-inst", 0,            "define camera ID", NULL);
     67    psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-telescope", 0,            "define telescope ID", NULL);
     68    psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-exp_type", 0,            "define exposure type", NULL);
     69    psMetadataAddBool(pendingexpArgs, PS_LIST_TAIL, "-desc", 0,            "sort ouput in descending format", false);
     70    psMetadataAddU64(pendingexpArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     71    psMetadataAddBool(pendingexpArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
    8872
    8973    // -pendingimfile
    9074    psMetadata *pendingimfileArgs = psMetadataAlloc();
    91     psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-exp_name", 0,
    92             "define exposure ID", NULL);
    93     psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-inst", 0,
    94             "define camera ID", NULL);
    95     psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-telescope", 0,
    96             "define telescope ID", NULL);
    97     psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-exp_type", 0,
    98             "define exposure type", NULL);
    99     psMetadataAddBool(pendingimfileArgs, PS_LIST_TAIL, "-desc", 0,
    100             "sort ouput in descending format", false);
    101     psMetadataAddU64(pendingimfileArgs, PS_LIST_TAIL, "-limit",  0,
    102             "limit result set to N items", 0);
    103     psMetadataAddBool(pendingimfileArgs, PS_LIST_TAIL, "-simple", 0,
    104             "use the simple output format", false);
     75    psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-exp_name", 0,            "define exposure ID", NULL);
     76    psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-inst", 0,            "define camera ID", NULL);
     77    psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-telescope", 0,            "define telescope ID", NULL);
     78    psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-exp_type", 0,            "define exposure type", NULL);
     79    psMetadataAddBool(pendingimfileArgs, PS_LIST_TAIL, "-desc", 0,            "sort ouput in descending format", false);
     80    psMetadataAddU64(pendingimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     81    psMetadataAddBool(pendingimfileArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
    10582
    10683    // -copydone
    10784    psMetadata *copydoneArgs = psMetadataAlloc();
    108     psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-exp_name", 0,
    109             "define exposure ID (required)", NULL);
    110     psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-inst", 0,
    111             "define camera ID (required)", NULL);
    112     psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-telescope", 0,
    113             "define telescope ID (required)", NULL);
    114     psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-class", 0,
    115             "define class", NULL);
    116     psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-class_id", 0,
    117             "define class_id", NULL);
    118     psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-uri", 0,
    119             "define storage uri", NULL);
    120     psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-workdir",  0,
    121         "define the \"default\" workdir for this exposure", NULL);
    122     psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-dvodb",  0,
    123         "define the dvodb for the next processing step", NULL);
    124     psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-tess_id",  0,
    125         "define the tess_id for the next processing step", NULL);
    126     psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-end_stage",  0,
    127         "define the end goal processing step", NULL);
    128     psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-label",  0,
    129         "define the label for the chip stage", NULL);
    130     psMetadataAddS16(copydoneArgs, PS_LIST_TAIL, "-code",  0,
    131             "set fault code", 0);
     85    psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-exp_name", 0,            "define exposure ID (required)", NULL);
     86    psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-inst", 0,            "define camera ID (required)", NULL);
     87    psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-telescope", 0,            "define telescope ID (required)", NULL);
     88    psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-class", 0,            "define class", NULL);
     89    psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-class_id", 0,            "define class_id", NULL);
     90    psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-uri", 0,            "define storage uri", NULL);
     91    psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-workdir",  0,        "define the \"default\" workdir for this exposure", NULL);
     92    psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-dvodb",  0,        "define the dvodb for the next processing step", NULL);
     93    psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-tess_id",  0,        "define the tess_id for the next processing step", NULL);
     94    psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-end_stage",  0,        "define the end goal processing step", NULL);
     95    psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-label",  0,        "define the label for the chip stage", NULL);
     96    psMetadataAddS16(copydoneArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
    13297
    13398    // -copied
    13499    psMetadata *copiedArgs = psMetadataAlloc();
    135     psMetadataAddStr(copiedArgs, PS_LIST_TAIL, "-exp_name", 0,
    136             "define exposure ID", NULL);
    137     psMetadataAddStr(copiedArgs, PS_LIST_TAIL, "-inst", 0,
    138             "define camera ID", NULL);
    139     psMetadataAddStr(copiedArgs, PS_LIST_TAIL, "-telescope", 0,
    140             "define telescope ID", NULL);
    141     psMetadataAddStr(copiedArgs, PS_LIST_TAIL, "-class", 0,
    142             "define class", NULL);
    143     psMetadataAddStr(copiedArgs, PS_LIST_TAIL, "-class_id", 0,
    144             "define class_id", NULL);
    145     psMetadataAddBool(copiedArgs, PS_LIST_TAIL, "-faulted",  0,
    146             "only return imfiles with a fault status set", false);
    147     psMetadataAddU64(copiedArgs, PS_LIST_TAIL, "-limit",  0,
    148             "limit result set to N items", 0);
    149     psMetadataAddBool(copiedArgs, PS_LIST_TAIL, "-simple",  0,
    150             "use the simple output format", false);
     100    psMetadataAddStr(copiedArgs, PS_LIST_TAIL, "-exp_name", 0,            "define exposure ID", NULL);
     101    psMetadataAddStr(copiedArgs, PS_LIST_TAIL, "-inst", 0,            "define camera ID", NULL);
     102    psMetadataAddStr(copiedArgs, PS_LIST_TAIL, "-telescope", 0,            "define telescope ID", NULL);
     103    psMetadataAddStr(copiedArgs, PS_LIST_TAIL, "-class", 0,            "define class", NULL);
     104    psMetadataAddStr(copiedArgs, PS_LIST_TAIL, "-class_id", 0,            "define class_id", NULL);
     105    psMetadataAddBool(copiedArgs, PS_LIST_TAIL, "-faulted",  0,            "only return imfiles with a fault status set", false);
     106    psMetadataAddU64(copiedArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     107    psMetadataAddBool(copiedArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    151108
    152109    // -updatecopied
    153110    psMetadata *updatecopiedArgs = psMetadataAlloc();
    154     psMetadataAddStr(updatecopiedArgs, PS_LIST_TAIL, "-exp_name", 0,
    155             "define exposure ID (required)", NULL);
    156     psMetadataAddStr(updatecopiedArgs, PS_LIST_TAIL, "-inst", 0,
    157             "define camera ID (required)", NULL);
    158     psMetadataAddStr(updatecopiedArgs, PS_LIST_TAIL, "-telescope", 0,
    159             "define telescope ID (required)", NULL);
    160     psMetadataAddStr(updatecopiedArgs, PS_LIST_TAIL, "-class", 0,
    161             "define class", NULL);
    162     psMetadataAddStr(updatecopiedArgs, PS_LIST_TAIL, "-class_id", 0,
    163             "define class_id", NULL);
    164     psMetadataAddS16(updatecopiedArgs, PS_LIST_TAIL, "-code",  0,
    165             "search by fault code", 0);
     111    psMetadataAddStr(updatecopiedArgs, PS_LIST_TAIL, "-exp_name", 0,            "define exposure ID (required)", NULL);
     112    psMetadataAddStr(updatecopiedArgs, PS_LIST_TAIL, "-inst", 0,            "define camera ID (required)", NULL);
     113    psMetadataAddStr(updatecopiedArgs, PS_LIST_TAIL, "-telescope", 0,            "define telescope ID (required)", NULL);
     114    psMetadataAddStr(updatecopiedArgs, PS_LIST_TAIL, "-class", 0,            "define class", NULL);
     115    psMetadataAddStr(updatecopiedArgs, PS_LIST_TAIL, "-class_id", 0,            "define class_id", NULL);
     116    psMetadataAddS16(updatecopiedArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
    166117
    167118    // -revertcopied
    168119    psMetadata *revertcopiedArgs = psMetadataAlloc();
    169     psMetadataAddStr(revertcopiedArgs, PS_LIST_TAIL, "-exp_name", 0,
    170             "define exposure ID (required)", NULL);
    171     psMetadataAddStr(revertcopiedArgs, PS_LIST_TAIL, "-inst", 0,
    172             "define camera ID (required)", NULL);
    173     psMetadataAddStr(revertcopiedArgs, PS_LIST_TAIL, "-telescope", 0,
    174             "define telescope ID (required)", NULL);
    175     psMetadataAddStr(revertcopiedArgs, PS_LIST_TAIL, "-class", 0,
    176             "define class", NULL);
    177     psMetadataAddStr(revertcopiedArgs, PS_LIST_TAIL, "-class_id", 0,
    178             "define class_id", NULL);
    179     psMetadataAddS16(revertcopiedArgs, PS_LIST_TAIL, "-code",  0,
    180             "search by fault code", 0);
     120    psMetadataAddStr(revertcopiedArgs, PS_LIST_TAIL, "-exp_name", 0,            "define exposure ID (required)", NULL);
     121    psMetadataAddStr(revertcopiedArgs, PS_LIST_TAIL, "-inst", 0,            "define camera ID (required)", NULL);
     122    psMetadataAddStr(revertcopiedArgs, PS_LIST_TAIL, "-telescope", 0,            "define telescope ID (required)", NULL);
     123    psMetadataAddStr(revertcopiedArgs, PS_LIST_TAIL, "-class", 0,            "define class", NULL);
     124    psMetadataAddStr(revertcopiedArgs, PS_LIST_TAIL, "-class_id", 0,            "define class_id", NULL);
     125    psMetadataAddS16(revertcopiedArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
    181126
    182127    // -clearcommonfaults
    … …  
    185130    // -advance
    186131    psMetadata *advanceArgs = psMetadataAlloc();
    187     psMetadataAddStr(advanceArgs, PS_LIST_TAIL, "-workdir",  0,
    188         "define the \"default\" workdir for this exposure", NULL);
    189     psMetadataAddStr(advanceArgs, PS_LIST_TAIL, "-dvodb",  0,
    190         "define the dvodb for the next processing step", NULL);
    191     psMetadataAddStr(advanceArgs, PS_LIST_TAIL, "-tess_id",  0,
    192         "define the tess_id for the next processing step", NULL);
    193     psMetadataAddStr(advanceArgs, PS_LIST_TAIL, "-end_stage",  0,
    194         "define the end goal processing step", NULL);
    195     psMetadataAddStr(advanceArgs, PS_LIST_TAIL, "-label",  0,
    196         "define the label for the chip stage", NULL);
     132    psMetadataAddStr(advanceArgs, PS_LIST_TAIL, "-workdir",  0,        "define the \"default\" workdir for this exposure", NULL);
     133    psMetadataAddStr(advanceArgs, PS_LIST_TAIL, "-dvodb",  0,        "define the dvodb for the next processing step", NULL);
     134    psMetadataAddStr(advanceArgs, PS_LIST_TAIL, "-tess_id",  0,        "define the tess_id for the next processing step", NULL);
     135    psMetadataAddStr(advanceArgs, PS_LIST_TAIL, "-end_stage",  0,        "define the end goal processing step", NULL);
     136    psMetadataAddStr(advanceArgs, PS_LIST_TAIL, "-label",  0,        "define the label for the chip stage", NULL);
    197137
    198138    psMetadata *argSets = psMetadataAlloc();
    … …  
    222162    psFree(modes);
    223163
    224     // generate SQL where clause
    225     config->where = psMetadataAlloc();
    226 
    227     PXOPT_ADD_WHERE_STR(exp_name);
    228     PXOPT_ADD_WHERE_STR(telescope);
    229     PXOPT_ADD_WHERE_STR_ALIAS("-inst", "camera");
    230     PXOPT_ADD_WHERE_STR(exp_type);
    231     PXOPT_ADD_WHERE_STR(class);
    232     PXOPT_ADD_WHERE_STR(class_id);
    233 
    234     if (config->where->list->n < 1) {
    235         psFree(config->where);
    236         config->where = NULL;
    237     }
    238 
    239164    // define Database handle, if used
    240165    // do this last so we don't setup a connection before CLI options are

  • branches/eam_branch_20080706/ippTools/src/regtool.c

    r18402 r18491  
    297297    PS_ASSERT_PTR_NON_NULL(config, false);
    298298
    299     PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    300     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    301     PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    302 
    303299    psMetadata *where = psMetadataAlloc();
    304300    PXOPT_COPY_S64(config->args, where,  "-exp_id", "exp_id", "==");
    … …  
    306302    PXOPT_COPY_STR(config->args, where,  "-class_id", "class_id", "==");
    307303
     304    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     305    PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
     306    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     307
    308308    psString query = pxDataGet("regtool_processedimfile.sql");
    309309    if (!query) {
    … …  
    313313    }
    314314
    315     if (where) {
     315    if (psListLength(where->list)) {
    316316        psString whereClause = psDBGenerateWhereConditionSQL(where, "rawImfile");
    317317        psStringAppend(&query, " AND %s", whereClause);
    … …  
    381381    PS_ASSERT_PTR_NON_NULL(config, false);
    382382
     383    psMetadata *where = psMetadataAlloc();
     384    PXOPT_COPY_S64(config->args, where,  "-exp_id",       "exp_id", "==");
     385    PXOPT_COPY_STR(config->args, where,  "-tmp_class_id", "tmp_class_id", "==");
     386    PXOPT_COPY_STR(config->args, where,  "-class_id",     "class_id", "==");
     387    PXOPT_COPY_S16(config->args, where,  "-code",         "fault", "==");
     388
    383389    psString query = pxDataGet("regtool_revertprocessedimfile.sql");
    384390    if (!query) {
    385391        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    386         return false;
    387     }
    388 
    389     if (config->where) {
    390         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "rawImfile");
     392        psFree(where);
     393        return false;
     394    }
     395
     396    if (psListLength(where->list)) {
     397        psString whereClause = psDBGenerateWhereConditionSQL(where, "rawImfile");
    391398        psStringAppend(&query, " AND %s", whereClause);
    392399        psFree(whereClause);
    393400    }
     401    psFree(where);
    394402
    395403    if (!p_psDBRunQuery(config->dbh, query)) {
    … …  
    413421    PS_ASSERT_PTR_NON_NULL(config, false);
    414422
     423    psMetadata *where = psMetadataAlloc();
     424    PXOPT_COPY_S64(config->args, where,  "-exp_id",       "exp_id", "==");
     425    PXOPT_COPY_STR(config->args, where,  "-class_id",     "class_id", "==");
     426
    415427    PXOPT_LOOKUP_S16(code, config->args, "-code", true, false);
    416428
    417     if (!pxSetFaultCode(config->dbh, "rawImfile", config->where, code)) {
     429    if (!pxSetFaultCode(config->dbh, "rawImfile", where, code)) {
    418430        psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag");
    419         return false;
    420     }
     431        psFree (where);
     432        return false;
     433    }
     434    psFree (where);
    421435
    422436    return true;
    … …  
    511525
    512526    // optional
     527    PXOPT_LOOKUP_TIME(dateobs, config->args, "-dateobs", false, false);
     528    PXOPT_LOOKUP_STR(exp_type, config->args, "-exp_type", false, false);
     529    PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", false, false);
    513530    PXOPT_LOOKUP_STR(dvodb, config->args, "-dvodb", false, false);
    514531    PXOPT_LOOKUP_STR(tess_id, config->args, "-tess_id", false, false);
    515532    PXOPT_LOOKUP_STR(end_stage, config->args, "-end_stage", false, false);
    516     PXOPT_LOOKUP_STR(exp_type, config->args, "-exp_type", false, false);
    517     PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", false, false);
    518533    PXOPT_LOOKUP_STR(reduction, config->args, "-reduction", false, false);
    519534    PXOPT_LOOKUP_STR(filter, config->args, "-filter", false, false);
    … …  
    561576    PXOPT_LOOKUP_STR(label,  config->args, "-label", false, false);
    562577    PXOPT_LOOKUP_STR(hostname, config->args, "-hostname", false, false);
    563     PXOPT_LOOKUP_TIME(dateobs, config->args, "-dateobs", false, false);
    564578
    565579    // default
    … …  
    789803    PS_ASSERT_PTR_NON_NULL(config, false);
    790804
    791     PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    792     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    793     PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    794 
    795805    psString query = pxDataGet("regtool_processedexp.sql");
    796806    if (!query) {
    … …  
    812822    PXOPT_COPY_STR(config->args, where,  "-reduction", "reduction", "==");
    813823    PXOPT_COPY_STR(config->args, where,  "-filter", "filter", "==");
    814     PXOPT_COPY_F64(config->args, where,  "-airmass_min", "airmass", ">=");
    815     PXOPT_COPY_F64(config->args, where,  "-airmass_max", "airmass", "<");
     824    PXOPT_COPY_F32(config->args, where,  "-airmass_min", "airmass", ">=");
     825    PXOPT_COPY_F32(config->args, where,  "-airmass_max", "airmass", "<");
    816826    PXOPT_COPY_F64(config->args, where,  "-ra_min", "ra", ">=");
    817827    PXOPT_COPY_F64(config->args, where,  "-ra_max", "ra", "<");
    … …  
    832842    PXOPT_COPY_F64(config->args, where,  "-az_min", "az", ">=");
    833843    PXOPT_COPY_F64(config->args, where,  "-az_max", "az", "<");
    834     PXOPT_COPY_F32(config->args, where,  "-ccd_temp_min", "ccd_temp", ">=");
    835     PXOPT_COPY_F32(config->args, where,  "-ccd_temp_max", "ccd_temp", "<");
     844    PXOPT_COPY_F64(config->args, where,  "-ccd_temp_min", "ccd_temp", ">=");
     845    PXOPT_COPY_F64(config->args, where,  "-ccd_temp_max", "ccd_temp", "<");
    836846    PXOPT_COPY_F64(config->args, where,  "-posang_min", "posang", ">=");
    837847    PXOPT_COPY_F64(config->args, where,  "-posang_max", "posang", "<");
    … …  
    839849    PXOPT_COPY_F32(config->args, where,  "-solang_min", "solang", ">=");
    840850    PXOPT_COPY_F32(config->args, where,  "-solang_max", "solang", "<");
     851
     852    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     853    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     854    PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    841855
    842856    if (psListLength(where->list)) {
    … …  
    906920    PS_ASSERT_PTR_NON_NULL(config, false);
    907921
     922    psMetadata *where = psMetadataAlloc();
     923    PXOPT_COPY_S64(config->args, where,  "-exp_id",       "exp_id", "==");
     924    PXOPT_COPY_S16(config->args, where,  "-code",         "fault", "==");
     925
    908926    psString query = pxDataGet("regtool_revertprocessedexp.sql");
    909927    if (!query) {
    910928        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    911         return false;
    912     }
    913 
    914     if (config->where) {
    915         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "rawExp");
     929        psFree(where);
     930        return false;
     931    }
     932
     933    if (psListLength(where->list)) {
     934        psString whereClause = psDBGenerateWhereConditionSQL(where, "rawExp");
    916935        psStringAppend(&query, " AND %s", whereClause);
     936        psFree(where);
    917937        psFree(whereClause);
    918938    }
     939    psFree(where);
    919940
    920941    if (!p_psDBRunQuery(config->dbh, query)) {
    … …  
    938959    PS_ASSERT_PTR_NON_NULL(config, false);
    939960
     961    psMetadata *where = psMetadataAlloc();
     962    PXOPT_COPY_S64(config->args, where,  "-exp_id",       "exp_id", "==");
     963
    940964    PXOPT_LOOKUP_S16(code, config->args, "-code", true, false);
    941965
    942     if (!pxSetFaultCode(config->dbh, "rawExp", config->where, code)) {
     966    if (!pxSetFaultCode(config->dbh, "rawExp", where, code)) {
    943967        psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag");
    944         return false;
    945     }
     968        psFree(where);
     969        return false;
     970    }
     971    psFree(where);
    946972
    947973    return true;

  • branches/eam_branch_20080706/ippTools/src/regtoolConfig.c

    r18468 r18491  
    5050    // -pendingimfile
    5151    psMetadata *pendingimfileArgs = psMetadataAlloc();
    52 // support for this options is unimplemented
    53 #if 0
    54     ADD_OPT(Str,  pendingimfileArgs, "-exp_id",    "search by exposure ID", NULL);
    55     ADD_OPT(Str,  pendingimfileArgs, "-class",     "search by class",       NULL);
    56     ADD_OPT(Str,  pendingimfileArgs, "-class_id",  "search by class ID",    NULL);
    57 #endif
    5852    ADD_OPT(U64,  pendingimfileArgs, "-limit",     "limit result set to N items",  0);
    5953    ADD_OPT(Bool, pendingimfileArgs, "-simple",    "use the simple output format", false);
    … …  
    6862    ADD_OPT(Str,  addprocessedimfileArgs, "-class_id",       "define class ID (required)",         NULL);
    6963    ADD_OPT(Str,  addprocessedimfileArgs, "-uri",            "define URI (required)",             NULL);
     64
    7065    ADD_OPT(Str,  addprocessedimfileArgs, "-exp_type",       "define exposure type",             NULL);
    7166    ADD_OPT(Str,  addprocessedimfileArgs, "-filelevel",      "define filelevel",             NULL);
    7267    ADD_OPT(Str,  addprocessedimfileArgs, "-filter",         "define filter ",                 NULL);
    7368    ADD_OPT(Str,  addprocessedimfileArgs, "-comment",        "define comment ",             NULL);
     69
    7470    ADD_OPT(F32,  addprocessedimfileArgs, "-airmass",        "define airmass",                 NAN);
    7571    ADD_OPT(F64,  addprocessedimfileArgs, "-ra",             "define RA",                 NAN);
    … …  
    9490    ADD_OPT(F32,  addprocessedimfileArgs, "-m2_tip",         "define M2 TIP position",                NAN);
    9591    ADD_OPT(F32,  addprocessedimfileArgs, "-m2_tilt",        "define M2 TILT position",         NAN);
     92
    9693    ADD_OPT(F32,  addprocessedimfileArgs, "-env_temperature","define Environmental Temperature",     NAN);
    9794    ADD_OPT(F32,  addprocessedimfileArgs, "-env_humidity",   "define Environmental Humidity",         NAN);
    … …  
    139136    // -pendingexp
    140137    psMetadata *pendingexpArgs = psMetadataAlloc();
    141 // support for these options in unimplemented
    142 #if 0
    143     psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-exp_id",   0,        "search by exposure ID", NULL);
    144     psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-inst",     0,        "search by camera", NULL);
    145     psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-telescope",0,        "search by telescope", NULL);
    146     psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-exp_type", 0,        "search by exposure type", NULL);
    147 #endif
    148138    psMetadataAddU64(pendingexpArgs, PS_LIST_TAIL, "-limit",    0,        "limit result set to N items", 0);
    149139    psMetadataAddBool(pendingexpArgs, PS_LIST_TAIL, "-simple",  0,        "use the simple output format", false);
    … …  
    156146    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-telescope",        0,        "define the telescope name (required)", NULL);
    157147    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-exp_tag",          0,        "define the external exposure tag name (required)", NULL);
     148    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-filelevel",        0,        "define the data partitioning level of this file (required)", NULL);
     149
    158150    psMetadataAddTime(addprocessedexpArgs, PS_LIST_TAIL, "-dateobs",         0,        "define observation time", NULL);
    159151    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-exp_type",         0,        "define exposure type", NULL);
    160     psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-filelevel",        0,        "define the data partitioning level of this file", NULL);
    161152    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-workdir",          0,        "define the \"default\" workdir for this exposure", NULL);
    162153    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-dvodb",            0,        "define the dvodb for the next processing step", NULL);
    … …  
    208199    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-hostname",         0,        "define host name", NULL);
    209200    psMetadataAddS16(addprocessedexpArgs, PS_LIST_TAIL, "-code",             0,        "set fault code", 0);
    210     /*
    211     psMetadataAddStr(updateArgs, PS_LIST_TAIL, "-recip",  0,        "define URL", NULL);
    212     psMetadataAddStr(updateArgs, PS_LIST_TAIL, "-mosiac",  0,        "define URL", NULL);
    213     */
    214201
    215202    // -processedexp
    … …  
    297284    psFree(modes);
    298285
    299     // generate SQL where clause
    300     config->where = psMetadataAlloc();
    301 
    302     PXOPT_ADD_WHERE_S64(exp_id);
    303     PXOPT_ADD_WHERE_STR(exp_name);
    304     PXOPT_ADD_WHERE_STR_ALIAS("-inst", "camera");
    305     PXOPT_ADD_WHERE_STR(telescope);
    306     PXOPT_ADD_WHERE_STR(exp_type);
    307     PXOPT_ADD_WHERE_STR(class);
    308     PXOPT_ADD_WHERE_STR(class_id);
    309     PXOPT_ADD_WHERE_STR(tmp_class_id);
    310     PXOPT_ADD_WHERE_STR(filter);
    311     PXOPT_ADD_WHERE_S16_ALIAS("-code", "fault");
    312 
    313     if (config->where->list->n < 1) {
    314         psFree(config->where);
    315         config->where = NULL;
    316     }
    317 
    318286    // define Database handle, if used
    319287    config->dbh = psMemIncrRefCounter(pmConfigDB(config->modules));

  • branches/eam_branch_20080706/ippTools/src/stacktoolConfig.c

    r18468 r18491  
    4747    // -definebyquery
    4848    psMetadata *definebyqueryArgs = psMetadataAlloc();
    49     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-workdir", 0,
    50             "define workdir (required)", NULL);
    51     psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-registered",  0,
    52             "time detrend run was registered", now);
    53     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_skycell_id",  0,
    54             "search for skycell_id", NULL);
    55     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_good_frac_min",  0,
    56             "define min good_frac", 0.0);
    57     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_exp_type",  0,
    58             "search for exp_type", "object");
    59     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_inst",  0,
    60             "search for camera", NULL);
    61     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_telescope",  0,
    62             "search for telescope", NULL);
    63     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_filter",  0,
    64             "search for filter", NULL);
    65     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_uri",  0,
    66             "search for uri", NULL);
    67     psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-select_dateobs_begin", 0,
    68             "search for exposures by time (>=)", NULL);
    69     psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-select_dateobs_end", 0,
    70             "search for exposures by time (<)", NULL);
    71     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_airmass_min",  0,
    72             "define min airmass", NAN);
    73     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_airmass_max",  0,
    74             "define max airmass", NAN);
    75     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_sat_pixel_frac_max",  0,
    76             "define max fraction of saturated pixels", NAN);
    77     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_exp_time_min",  0,
    78             "define min exposure time", NAN);
    79     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_exp_time_max",  0,
    80             "define max exposure time", NAN);
    81     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_ccd_temp_min",  0,
    82             "define min ccd tempature", NAN);
    83     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_ccd_temp_max",  0,
    84             "define max ccd tempature", NAN);
    85     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_posang_min",  0,
    86             "define min rotator position angle", NAN);
    87     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_posang_max",  0,
    88             "define max rotator position angle", NAN);
    89     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_solang_min",  0,
    90             "define min solar angle", NAN);
    91     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_solang_max",  0,
    92             "define max solar angle", NAN);
    93     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-random_subset",  0,
    94             "use a random subset of elements", false);
    95     psMetadataAddS32(definebyqueryArgs, PS_LIST_TAIL, "-random_limit",  0,
    96             "use this number of random elements", 20);
    97 
    98     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-all",  0,
    99             "allow everything to be queued without search terms", false);
    100     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-simple",  0,
    101             "use the simple output format", false);
     49    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-workdir", 0,            "define workdir (required)", NULL);
     50    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-registered",  0,            "time detrend run was registered", now);
     51    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_skycell_id",  0,            "search for skycell_id", NULL);
     52    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_good_frac_min",  0,            "define min good_frac", 0.0);
     53    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_exp_type",  0,            "search for exp_type", "object");
     54    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_inst",  0,            "search for camera", NULL);
     55    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_telescope",  0,            "search for telescope", NULL);
     56    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_filter",  0,            "search for filter", NULL);
     57    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_uri",  0,            "search for uri", NULL);
     58    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-select_dateobs_begin", 0,            "search for exposures by time (>=)", NULL);
     59    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-select_dateobs_end", 0,            "search for exposures by time (<)", NULL);
     60    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_airmass_min",  0,            "define min airmass", NAN);
     61    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_airmass_max",  0,            "define max airmass", NAN);
     62    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_sat_pixel_frac_max",  0,            "define max fraction of saturated pixels", NAN);
     63    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_exp_time_min",  0,            "define min exposure time", NAN);
     64    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_exp_time_max",  0,            "define max exposure time", NAN);
     65    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_ccd_temp_min",  0,            "define min ccd tempature", NAN);
     66    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_ccd_temp_max",  0,            "define max ccd tempature", NAN);
     67    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_posang_min",  0,            "define min rotator position angle", NAN);
     68    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_posang_max",  0,            "define max rotator position angle", NAN);
     69    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_solang_min",  0,            "define min solar angle", NAN);
     70    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_solang_max",  0,            "define max solar angle", NAN);
     71    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-random_subset",  0,            "use a random subset of elements", false);
     72    psMetadataAddS32(definebyqueryArgs, PS_LIST_TAIL, "-random_limit",  0,            "use this number of random elements", 20);
     73    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-all",  0,            "allow everything to be queued without search terms", false);
     74    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    10275
    10376    // -definerun
    10477    psMetadata *definerunArgs = psMetadataAlloc();
    105     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-workdir", 0,
    106             "define workdir (required)", NULL);
    107     psMetadataAddTime(definerunArgs, PS_LIST_TAIL, "-registered",  0,
    108             "time detrend run was registered", now);
    109     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-skycell_id",  0,
    110             "define skycell ID (required)", NULL);
    111     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-tess_id",  0,
    112             "define tessellation ID (required)", NULL);
    113     psMetadataAddS64(definerunArgs, PS_LIST_TAIL, "-warp_id",
    114              PS_META_DUPLICATE_OK,
    115              "include this warp ID (multiple OK, required)", 0);
    116 
    117     psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-simple",  0,
    118             "use the simple output format", false);
     78    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-workdir", 0,            "define workdir (required)", NULL);
     79    psMetadataAddTime(definerunArgs, PS_LIST_TAIL, "-registered",  0,            "time detrend run was registered", now);
     80    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-skycell_id",  0,            "define skycell ID (required)", NULL);
     81    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-tess_id",  0,            "define tessellation ID (required)", NULL);
     82    psMetadataAddS64(definerunArgs, PS_LIST_TAIL, "-warp_id",             PS_META_DUPLICATE_OK,             "include this warp ID (multiple OK, required)", 0);
     83    psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    11984
    12085    // -updaterun
    12186    psMetadata *updaterunArgs = psMetadataAlloc();
    122     psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-stack_id", 0,
    123             "define stack ID (required)", 0);
    124     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,
    125             "set state (required)", NULL);
    126 #if 0
    127     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-workdir", 0,
    128             "define workdir (required)", NULL);
    129     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-registered",  0,
    130             "time detrend run was registered", now);
    131 #endif
     87    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-stack_id", 0,            "define stack ID (required)", 0);
     88    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,            "set state (required)", NULL);
    13289
    13390    // -addinputskyfile
    13491    psMetadata *addinputskyfileArgs = psMetadataAlloc();
    135     psMetadataAddS64(addinputskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,
    136             "define stack ID (required)", 0);
    137     psMetadataAddS64(addinputskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,
    138             "define warp ID (required)", 0);
     92    psMetadataAddS64(addinputskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,            "define stack ID (required)", 0);
     93    psMetadataAddS64(addinputskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,            "define warp ID (required)", 0);
    13994
    14095    // -inputskyfile
    14196    psMetadata *inputskyfileArgs = psMetadataAlloc();
    142     psMetadataAddS64(inputskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,
    143             "search by stack ID", 0);
    144     psMetadataAddS64(inputskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,
    145             "search by warp ID", 0);
    146     psMetadataAddU64(inputskyfileArgs, PS_LIST_TAIL, "-limit",  0,
    147             "limit result set to N items", 0);
    148     psMetadataAddBool(inputskyfileArgs, PS_LIST_TAIL, "-simple",  0,
    149             "use the simple output format", false);
     97    psMetadataAddS64(inputskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,            "search by stack ID", 0);
     98    psMetadataAddS64(inputskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,            "search by warp ID", 0);
     99    psMetadataAddU64(inputskyfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     100    psMetadataAddBool(inputskyfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    150101
    151102    // -tosum
    152103    psMetadata *tosumArgs = psMetadataAlloc();
    153     psMetadataAddS64(tosumArgs, PS_LIST_TAIL, "-stack_id", 0,
    154             "search by stack ID", 0);
    155     psMetadataAddS64(tosumArgs, PS_LIST_TAIL, "-warp_id", 0,
    156             "search by warp ID", 0);
    157     psMetadataAddU64(tosumArgs, PS_LIST_TAIL, "-limit",  0,
    158             "limit result set to N items", 0);
    159     psMetadataAddBool(tosumArgs, PS_LIST_TAIL, "-simple",  0,
    160             "use the simple output format", false);
     104    psMetadataAddS64(tosumArgs, PS_LIST_TAIL, "-stack_id", 0,            "search by stack ID", 0);
     105    psMetadataAddS64(tosumArgs, PS_LIST_TAIL, "-warp_id", 0,            "search by warp ID", 0);
     106    psMetadataAddU64(tosumArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     107    psMetadataAddBool(tosumArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    161108
    162109    // -addsumskyfile
    163110    psMetadata *addsumskyfileArgs = psMetadataAlloc();
    164     psMetadataAddS64(addsumskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,
    165             "define stack ID (required)", 0);
    166     psMetadataAddStr(addsumskyfileArgs, PS_LIST_TAIL, "-uri", 0,
    167             "define URI of file", 0);
    168     psMetadataAddStr(addsumskyfileArgs, PS_LIST_TAIL, "-path_base", 0,
    169             "define base output location", 0);
    170     psMetadataAddF64(addsumskyfileArgs, PS_LIST_TAIL, "-bg",  0,
    171             "define exposue background", NAN);
    172     psMetadataAddF64(addsumskyfileArgs, PS_LIST_TAIL, "-bg_stdev",  0,
    173             "define exposue background mean stdev", NAN);
    174     psMetadataAddF32(addsumskyfileArgs, PS_LIST_TAIL, "-dtime_stack",  0,
    175             "define elapsed processing time", NAN);
    176     psMetadataAddStr(addsumskyfileArgs, PS_LIST_TAIL, "-hostname", 0,
    177             "define hostname", 0);
    178     psMetadataAddF32(addsumskyfileArgs, PS_LIST_TAIL, "-good_frac",  0,
    179             "define %% of good pixels", NAN);
    180     psMetadataAddS16(addsumskyfileArgs, PS_LIST_TAIL, "-code",  0,
    181             "set fault code", 0);
     111    psMetadataAddS64(addsumskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,            "define stack ID (required)", 0);
     112    psMetadataAddStr(addsumskyfileArgs, PS_LIST_TAIL, "-uri", 0,            "define URI of file", 0);
     113    psMetadataAddStr(addsumskyfileArgs, PS_LIST_TAIL, "-path_base", 0,            "define base output location", 0);
     114    psMetadataAddF64(addsumskyfileArgs, PS_LIST_TAIL, "-bg",  0,            "define exposue background", NAN);
     115    psMetadataAddF64(addsumskyfileArgs, PS_LIST_TAIL, "-bg_stdev",  0,            "define exposue background mean stdev", NAN);
     116    psMetadataAddF32(addsumskyfileArgs, PS_LIST_TAIL, "-dtime_stack",  0,            "define elapsed processing time", NAN);
     117    psMetadataAddStr(addsumskyfileArgs, PS_LIST_TAIL, "-hostname", 0,            "define hostname", 0);
     118    psMetadataAddF32(addsumskyfileArgs, PS_LIST_TAIL, "-good_frac",  0,            "define %% of good pixels", NAN);
     119    psMetadataAddS16(addsumskyfileArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
    182120
    183121    // -sumskyfile
    184122    psMetadata *sumskyfileArgs= psMetadataAlloc();
    185     psMetadataAddS64(sumskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,
    186             "search by stack ID", 0);
    187     psMetadataAddS64(sumskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,
    188             "search by warp ID", 0);
    189     psMetadataAddU64(sumskyfileArgs, PS_LIST_TAIL, "-limit",  0,
    190             "limit result set to N items", 0);
    191     psMetadataAddBool(sumskyfileArgs, PS_LIST_TAIL, "-simple",  0,
    192             "use the simple output format", false);
     123    psMetadataAddS64(sumskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,            "search by stack ID", 0);
     124    psMetadataAddS64(sumskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,            "search by warp ID", 0);
     125    psMetadataAddU64(sumskyfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     126    psMetadataAddBool(sumskyfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    193127
    194128    // -revertsumskyfile
    195129    psMetadata *revertsumskyfileArgs= psMetadataAlloc();
    196     psMetadataAddS64(revertsumskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,
    197             "search by stack ID (required)", 0);
    198     psMetadataAddS16(revertsumskyfileArgs, PS_LIST_TAIL, "-code",  0,
    199             "search by fault code", 0);
     130    psMetadataAddS64(revertsumskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,            "search by stack ID (required)", 0);
     131    psMetadataAddS16(revertsumskyfileArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
    200132
    201133    psFree(now);
    … …  
    204136    psMetadata *modes   = psMetadataAlloc();
    205137
    206     PXOPT_ADD_MODE("-definebyquery", "Define a new stackRun by searching for warp IDs",
    207         STACKTOOL_MODE_DEFINEBYQUERY,  definebyqueryArgs);
     138    PXOPT_ADD_MODE("-definebyquery", "Define a new stackRun by searching for warp IDs", STACKTOOL_MODE_DEFINEBYQUERY,  definebyqueryArgs);
    208139    PXOPT_ADD_MODE("-definerun",       "", STACKTOOL_MODE_DEFINERUN,      definerunArgs);
    209140    PXOPT_ADD_MODE("-updaterun",       "", STACKTOOL_MODE_UPDATERUN,      updaterunArgs);

  • branches/eam_branch_20080706/ippTools/src/warptool.c

    r18336 r18491  
    109109{
    110110    PS_ASSERT_PTR_NON_NULL(config, false);
    111 
    112     // required options
    113     PXOPT_LOOKUP_S64(fake_id, config->args, "-fake_id", true, false);
    114     PXOPT_LOOKUP_STR(mode, config->args, "-mode", true, false);
    115     // check mode
    116     if (mode && !isValidMode(config, mode)) {
    117         psError(PS_ERR_UNKNOWN, false, "invalud mode");
    118         return false;
    119     }
    120     PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false);
    121 
    122     // optional
     111   
     112    PXOPT_LOOKUP_S64(fake_id, config->args, "-fake_id", true, false); // required
     113    PXOPT_LOOKUP_STR(mode, config->args, "-mode", true, false); // required
     114    PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false); // required
    123115    PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
    124116    PXOPT_LOOKUP_STR(dvodb, config->args, "-dvodb", false, false);
    125117    PXOPT_LOOKUP_STR(tess_id, config->args, "-tess_id", false, false);
    126118    PXOPT_LOOKUP_STR(end_stage, config->args, "-end_stage", false, false);
    127 
    128     // default
    129119    PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
    130120    PXOPT_LOOKUP_BOOL(magiced, config->args, "-magiced", false);
    131121    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     122
     123    // check mode
     124    if (mode && !isValidMode(config, mode)) {
     125        psError(PS_ERR_UNKNOWN, false, "invalid mode");
     126        return false;
     127    }
    132128
    133129    warpRunRow *warpRun = warpRunRowAlloc(
    … …  
    190186    PXOPT_COPY_STR(config->args, where, "-reduction", "reduction", "==");
    191187    PXOPT_COPY_STR(config->args, where, "-filter", "filter", "==");
    192 
    193     PXOPT_COPY_F64(config->args, where, "-airmass_min", "airmass", ">=");
    194     PXOPT_COPY_F64(config->args, where, "-airmass_max", "airmass", "<");
     188    PXOPT_COPY_F32(config->args, where, "-airmass_min", "airmass", ">=");
     189    PXOPT_COPY_F32(config->args, where, "-airmass_max", "airmass", "<");
    195190    PXOPT_COPY_F64(config->args, where, "-ra_min", "ra", ">=");
    196191    PXOPT_COPY_F64(config->args, where, "-ra_max", "ra", "<");
    … …  
    211206    PXOPT_COPY_F64(config->args, where, "-az_min", "az", ">=");
    212207    PXOPT_COPY_F64(config->args, where, "-az_max", "az", "<");
    213     PXOPT_COPY_F32(config->args, where, "-ccd_temp_min", "ccd_temp", ">=");
    214     PXOPT_COPY_F32(config->args, where, "-ccd_temp_max", "ccd_temp", "<");
     208    PXOPT_COPY_F64(config->args, where, "-ccd_temp_min", "ccd_temp", ">=");
     209    PXOPT_COPY_F64(config->args, where, "-ccd_temp_max", "ccd_temp", "<");
    215210    PXOPT_COPY_F64(config->args, where, "-posang_min", "posang", ">=");
    216211    PXOPT_COPY_F64(config->args, where, "-posang_max", "posang", "<");
    … …  
    262257    PS_ASSERT_PTR_NON_NULL(config, false);
    263258
     259    psMetadata *where = psMetadataAlloc();
     260    PXOPT_COPY_S64(config->args, where, "-warp_id", "warp_id", "==");
     261    PXOPT_COPY_S64(config->args, where, "-fake_id", "fake_id", "==");
     262
    264263    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    265264    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    … …  
    272271    }
    273272
    274     if (config->where) {
    275         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "warpRun");
     273    if (psListLength(where->list)) {
     274        psString whereClause = psDBGenerateWhereConditionSQL(where, "warpRun");
    276275        psStringAppend(&query, " AND %s", whereClause);
    277276        psFree(whereClause);
    278277    }
     278    psFree(where);
    279279
    280280    // treat limit == 0 as "no limit"
    … …  
    331331    PS_ASSERT_PTR_NON_NULL(config, false);
    332332
     333    psMetadata *where = psMetadataAlloc();
     334    PXOPT_COPY_S64(config->args, where, "-warp_id", "warp_id", "==");
     335    PXOPT_COPY_S64(config->args, where, "-fake_id", "fake_id", "==");
     336
    333337    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    334338    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    … …  
    341345    }
    342346
    343     if (config->where) {
    344         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "warpRun");
     347    if (psListLength(where->list)) {
     348        psString whereClause = psDBGenerateWhereConditionSQL(where, "warpRun");
    345349        psStringAppend(&query, " AND %s", whereClause);
    346350        psFree(whereClause);
    347351    }
     352    psFree(where);
    348353
    349354    // treat limit == 0 as "no limit"
    … …  
    400405    PS_ASSERT_PTR_NON_NULL(config, false);
    401406
     407    psMetadata *where = psMetadataAlloc();
     408    PXOPT_COPY_S64(config->args, where, "-warp_id", "warp_id", "==");
     409
    402410    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    403411    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    … …  
    410418    }
    411419
    412     if (config->where) {
    413         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "warpRun");
     420    if (psListLength(where->list)) {
     421        psString whereClause = psDBGenerateWhereConditionSQL(where, "warpRun");
    414422        psStringAppend(&query, " AND %s", whereClause);
    415423        psFree(whereClause);
    416424    }
     425    psFree(where);
    417426
    418427    // treat limit == 0 as "no limit"
    … …  
    571580    PS_ASSERT_PTR_NON_NULL(config, false);
    572581
     582    psMetadata *where = psMetadataAlloc();
     583    PXOPT_COPY_S64(config->args, where, "-warp_id", "warp_id", "==");
     584    PXOPT_COPY_STR(config->args, where, "-skycell_id", "skycell_id", "==");
     585    PXOPT_COPY_STR(config->args, where, "-tess_id", "tess_id", "==");
     586
    573587    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    574588    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    … …  
    581595    }
    582596
    583     if (config->where) {
    584         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "warpSkyCellMap");
     597    if (psListLength(where->list)) {
     598        psString whereClause = psDBGenerateWhereConditionSQL(where, "warpSkyCellMap");
    585599        psStringAppend(&query, " AND %s", whereClause);
    586600        psFree(whereClause);
    587601    }
     602    psFree(where);
    588603
    589604    // treat limit == 0 as "no limit"
    … …  
    635650}
    636651
    637 
    638652static bool towarpedMode(pxConfig *config)
    639653{
    640654    PS_ASSERT_PTR_NON_NULL(config, false);
     655
     656    psMetadata *where = psMetadataAlloc();
     657    PXOPT_COPY_S64(config->args, where, "-warp_id", "warp_id", "==");
    641658
    642659    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    … …  
    650667    }
    651668
    652     if (config->where) {
    653         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "warpSkyCellMap");
     669    if (psListLength(where->list)) {
     670        psString whereClause = psDBGenerateWhereConditionSQL(where, "warpSkyCellMap");
    654671        psStringAppend(&query, " AND %s", whereClause);
    655672        psFree(whereClause);
    656673    }
     674    psFree(where);
    657675
    658676    // treat limit == 0 as "no limit"
    … …  
    891909    PS_ASSERT_PTR_NON_NULL(config, false);
    892910
     911    psMetadata *where = psMetadataAlloc();
     912    PXOPT_COPY_S64(config->args, where, "-warp_id",    "warp_id", "==");
     913    PXOPT_COPY_STR(config->args, where, "-skycell_id", "skycell_id", "==");
     914    PXOPT_COPY_STR(config->args, where, "-tess_id",    "tess_id", "==");
     915    PXOPT_COPY_S64(config->args, where, "-exp_id",     "exp_id", "==");
     916    PXOPT_COPY_S64(config->args, where, "-fake_id",    "fake_id", "==");
     917
    893918    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    894919    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    … …  
    901926    }
    902927
    903     if (config->where) {
    904         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "warpSkyfile");
     928    if (psListLength(where->list)) {
     929        psString whereClause = psDBGenerateWhereConditionSQL(where, "warpSkyfile");
    905930        psStringAppend(&query, " AND %s", whereClause);
    906931        psFree(whereClause);
    907932    }
     933    psFree(where);
    908934
    909935    // treat limit == 0 as "no limit"
    … …  
    962988    psMetadata *where = psMetadataAlloc();
    963989    PXOPT_COPY_S64(config->args, where, "-warp_id", "warp_id", "==");
     990    PXOPT_COPY_STR(config->args, where, "-skycell_id", "skycell_id", "==");
     991    PXOPT_COPY_STR(config->args, where, "-tess_id", "tess_id", "==");
    964992    PXOPT_COPY_S64(config->args, where, "-fake_id", "fake_id", "==");
    965993    PXOPT_COPY_S64(config->args, where, "-chip_id", "chip_id", "==");
    966994    PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
    967     PXOPT_COPY_STR(config->args, where, "-skycell_id", "skycell_id", "==");
    968     PXOPT_COPY_STR(config->args, where, "-tess_id", "tess_id", "==");
    969995
    970996    // XXX These may need to be updated with the table name?
    … …  
    9801006    PXOPT_COPY_STR(config->args, where, "-filter", "filter", "==");
    9811007
    982     PXOPT_COPY_F64(config->args, where, "-airmass_min", "airmass", ">=");
    983     PXOPT_COPY_F64(config->args, where, "-airmass_max", "airmass", "<");
     1008    PXOPT_COPY_F32(config->args, where, "-airmass_min", "airmass", ">=");
     1009    PXOPT_COPY_F32(config->args, where, "-airmass_max", "airmass", "<");
    9841010    PXOPT_COPY_F64(config->args, where, "-ra_min", "ra", ">=");
    9851011    PXOPT_COPY_F64(config->args, where, "-ra_max", "ra", "<");
    … …  
    10001026    PXOPT_COPY_F64(config->args, where, "-az_min", "az", ">=");
    10011027    PXOPT_COPY_F64(config->args, where, "-az_max", "az", "<");
    1002     PXOPT_COPY_F32(config->args, where, "-ccd_temp_min", "ccd_temp", ">=");
    1003     PXOPT_COPY_F32(config->args, where, "-ccd_temp_max", "ccd_temp", "<");
     1028    PXOPT_COPY_F64(config->args, where, "-ccd_temp_min", "ccd_temp", ">=");
     1029    PXOPT_COPY_F64(config->args, where, "-ccd_temp_max", "ccd_temp", "<");
    10041030    PXOPT_COPY_F64(config->args, where, "-posang_min", "posang", ">=");
    10051031    PXOPT_COPY_F64(config->args, where, "-posang_max", "posang", "<");
    … …  
    10071033    PXOPT_COPY_F32(config->args, where, "-solang_min", "solang", ">=");
    10081034    PXOPT_COPY_F32(config->args, where, "-solang_max", "solang", "<");
    1009 //    PXOPT_COPY_S16(config->args, where, "-code", "fault", "==");
     1035    PXOPT_COPY_S16(config->args, where, "-code", "fault", "==");
    10101036
    10111037    if (!psListLength(where->list)

  • branches/eam_branch_20080706/ippTools/src/warptoolConfig.c

    r18468 r18491  
    4949    // -definerun
    5050    psMetadata *definerunArgs = psMetadataAlloc();
    51     psMetadataAddS64(definerunArgs, PS_LIST_TAIL, "-fake_id", 0,
    52             "define camtool ID (required)", 0);
    53     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-mode", 0,
    54             "define mode (required)", NULL);
    55     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-workdir", 0,
    56             "define workdir (required)", NULL);
    57     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-label", 0,
    58             "define label", NULL);
    59     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-dvodb", 0,
    60             "define dvodb", NULL);
    61     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-tess_id", 0,
    62             "define tess_id", NULL);
    63     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-end_stage", 0,
    64             "define end stage", NULL);
    65     psMetadataAddTime(definerunArgs, PS_LIST_TAIL, "-registered",  0,
    66             "time detrend run was registered", now);
    67     psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-magiced",  0,
    68             "has this exposure been magiced", false);
    69     psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-simple",  0,
    70             "use the simple output format", false);
     51    psMetadataAddS64(definerunArgs, PS_LIST_TAIL, "-fake_id", 0,            "define camtool ID (required)", 0);
     52    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-mode", 0,            "define mode (required)", NULL);
     53    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-workdir", 0,            "define workdir (required)", NULL);
     54    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-label", 0,            "define label", NULL);
     55    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-dvodb", 0,            "define dvodb", NULL);
     56    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-tess_id", 0,            "define tess_id", NULL);
     57    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-end_stage", 0,            "define end stage", NULL);
     58    psMetadataAddTime(definerunArgs, PS_LIST_TAIL, "-registered",  0,            "time detrend run was registered", now);
     59    psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-magiced",  0,            "has this exposure been magiced", false);
     60    psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    7161
    7262    // -updaterun
     63    // XXX need to allow multiple fake_ids
     64    // XXX need to allow multiple fake_ids
     65    // XXX need to allow multiple chip_ids
     66    // XXX need to allow multiple exp_ids
    7367    psMetadata *updaterunArgs = psMetadataAlloc();
    74     // XXX need to allow multiple fake_ids
    75     psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-warp_id", 0,
    76             "search by warptool ID", 0);
    77     // XXX need to allow multiple fake_ids
    78     psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-fake_id",  0,
    79             "search by fake_id", 0);
    80     // XXX need to allow multiple chip_ids
    81     psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-chip_id",  0,
    82             "search by chip_id", 0);
    83     // XXX need to allow multiple exp_ids
    84     psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-exp_id",  0,
    85             "search by exp_id", 0);
    86     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_name",  0,
    87             "search by exp_name", NULL);
    88     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-inst",  0,
    89             "search for camera", NULL);
    90     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-telescope",  0,
    91             "search for telescope", NULL);
    92     psMetadataAddTime(updaterunArgs, PS_LIST_TAIL, "-dateobs_begin", 0,
    93             "search for exposures by time (>=)", NULL);
    94     psMetadataAddTime(updaterunArgs, PS_LIST_TAIL, "-dateobs_end", 0,
    95             "search for exposures by time (<)", NULL);
    96     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_tag",  0,
    97             "search by exp_tag", NULL);
    98     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_type",  0,
    99             "search by exp_type", NULL);
    100     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-filelevel",  0,
    101             "search by filelevel", NULL);
    102     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-reduction",  0,
    103             "search by reduction class", NULL);
    104     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-filter",  0,
    105             "search for filter", NULL);
    106     psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-airmass_min",  0,
    107             "define min airmass", NAN);
    108     psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-airmass_max",  0,
    109             "define max airmass", NAN);
    110     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-ra_min",  0,
    111             "define min", NAN);
    112     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-ra_max",  0,
    113             "define max", NAN);
    114     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-decl_min",  0,
    115             "define min", NAN);
    116     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-decl_max",  0,
    117             "define max", NAN);
    118     psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-exp_time_min",  0,
    119             "define min", NAN);
    120     psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-exp_time_max",  0,
    121             "define max", NAN);
    122     psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-sat_pixel_frac_min",  0,
    123             "define max fraction of saturated pixels", NAN);
    124     psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-sat_pixel_frac_max",  0,
    125             "define min fraction of saturated pixels", NAN);
    126     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_min",  0,
    127             "define max", NAN);
    128     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_max",  0,
    129             "define max", NAN);
    130     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_stdev_min",  0,
    131             "define max", NAN);
    132     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_stdev_max",  0,
    133             "define max", NAN);
    134     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_mean_stdev_min",  0,
    135             "define max", NAN);
    136     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_mean_stdev_max",  0,
    137             "define max", NAN);
    138     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-alt_min",  0,
    139             "define min", NAN);
    140     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-alt_max",  0,
    141             "define max", NAN);
    142     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-az_min",  0,
    143             "define min", NAN);
    144     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-az_max",  0,
    145             "define max", NAN);
    146     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-ccd_temp_min",  0,
    147             "define min ccd tempature", NAN);
    148     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-ccd_temp_max",  0,
    149             "define max ccd tempature", NAN);
    150     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-posang_min",  0,
    151             "define min rotator position angle", NAN);
    152     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-posang_max",  0,
    153             "define max rotator position angle", NAN);
    154     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-object",  0,
    155             "search by exposure object", NULL);
    156     psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-solang_min",  0,
    157             "define min solar angle", NAN);
    158     psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-solang_max",  0,
    159             "define max solar angle", NAN);
    160 
    161     psMetadataAddBool(updaterunArgs, PS_LIST_TAIL, "-all",  0,
    162             "allow everything to be queued without search terms", false);
    163     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,
    164             "set state", NULL);
    165     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label", 0,
    166             "set label", NULL);
     68    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-warp_id", 0,            "search by warptool ID", 0);
     69    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-fake_id",  0,            "search by fake_id", 0);
     70    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-chip_id",  0,            "search by chip_id", 0);
     71    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exp_id", 0);
     72    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_name",  0,            "search by exp_name", NULL);
     73    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-inst",  0,            "search for camera", NULL);
     74    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-telescope",  0,            "search for telescope", NULL);
     75    psMetadataAddTime(updaterunArgs, PS_LIST_TAIL, "-dateobs_begin", 0,            "search for exposures by time (>=)", NULL);
     76    psMetadataAddTime(updaterunArgs, PS_LIST_TAIL, "-dateobs_end", 0,            "search for exposures by time (<)", NULL);
     77    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_tag",  0,            "search by exp_tag", NULL);
     78    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_type",  0,            "search by exp_type", NULL);
     79    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-filelevel",  0,            "search by filelevel", NULL);
     80    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-reduction",  0,            "search by reduction class", NULL);
     81    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-filter",  0,            "search for filter", NULL);
     82    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-airmass_min",  0,            "define min airmass", NAN);
     83    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-airmass_max",  0,            "define max airmass", NAN);
     84    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-ra_min",  0,            "define min", NAN);
     85    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-ra_max",  0,            "define max", NAN);
     86    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-decl_min",  0,            "define min", NAN);
     87    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-decl_max",  0,            "define max", NAN);
     88    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-exp_time_min",  0,            "define min", NAN);
     89    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-exp_time_max",  0,            "define max", NAN);
     90    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-sat_pixel_frac_min",  0,            "define max fraction of saturated pixels", NAN);
     91    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-sat_pixel_frac_max",  0,            "define min fraction of saturated pixels", NAN);
     92    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_min",  0,            "define max", NAN);
     93    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_max",  0,            "define max", NAN);
     94    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_stdev_min",  0,            "define max", NAN);
     95    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_stdev_max",  0,            "define max", NAN);
     96    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_mean_stdev_min",  0,            "define max", NAN);
     97    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_mean_stdev_max",  0,            "define max", NAN);
     98    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-alt_min",  0,            "define min", NAN);
     99    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-alt_max",  0,            "define max", NAN);
     100    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-az_min",  0,            "define min", NAN);
     101    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-az_max",  0,            "define max", NAN);
     102    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-ccd_temp_min",  0,            "define min ccd tempature", NAN);
     103    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-ccd_temp_max",  0,            "define max ccd tempature", NAN);
     104    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-posang_min",  0,            "define min rotator position angle", NAN);
     105    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-posang_max",  0,            "define max rotator position angle", NAN);
     106    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-object",  0,            "search by exposure object", NULL);
     107    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-solang_min",  0,            "define min solar angle", NAN);
     108    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-solang_max",  0,            "define max solar angle", NAN);
     109
     110    psMetadataAddBool(updaterunArgs, PS_LIST_TAIL, "-all",  0,            "allow everything to be queued without search terms", false);
     111    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,            "set state", NULL);
     112    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label", 0,            "set label", NULL);
     113
    167114#if 0
    168     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-workdir", 0,
    169             "define workdir (required)", NULL);
    170     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-registered",  0,
    171             "time detrend run was registered", now);
     115    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-workdir", 0,            "define workdir (required)", NULL);
     116    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-registered",  0,            "time detrend run was registered", now);
    172117#endif
    173118
    174119    // -exp
    175120    psMetadata *expArgs = psMetadataAlloc();
    176     psMetadataAddS64(expArgs, PS_LIST_TAIL, "-warp_id", 0,
    177             "search by warptool ID", 0);
    178     psMetadataAddS64(expArgs, PS_LIST_TAIL, "-fake_id", 0,
    179             "search by camtool ID", 0);
    180     psMetadataAddU64(expArgs, PS_LIST_TAIL, "-limit",  0,
    181             "limit result set to N items", 0);
    182     psMetadataAddBool(expArgs, PS_LIST_TAIL, "-simple",  0,
    183             "use the simple output format", false);
     121    psMetadataAddS64(expArgs, PS_LIST_TAIL, "-warp_id", 0,            "search by warptool ID", 0);
     122    psMetadataAddS64(expArgs, PS_LIST_TAIL, "-fake_id", 0,            "search by camtool ID", 0);
     123    psMetadataAddU64(expArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     124    psMetadataAddBool(expArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    184125
    185126    // -imfile
    186127    psMetadata *imfileArgs = psMetadataAlloc();
    187     psMetadataAddS64(imfileArgs, PS_LIST_TAIL, "-warp_id", 0,
    188             "search by warptool ID", 0);
    189     psMetadataAddS64(imfileArgs, PS_LIST_TAIL, "-fake_id", 0,
    190             "search by camtool ID", 0);
    191     psMetadataAddU64(imfileArgs, PS_LIST_TAIL, "-limit",  0,
    192             "limit result set to N items", 0);
    193     psMetadataAddBool(imfileArgs, PS_LIST_TAIL, "-simple",  0,
    194             "use the simple output format", false);
     128    psMetadataAddS64(imfileArgs, PS_LIST_TAIL, "-warp_id", 0,            "search by warptool ID", 0);
     129    psMetadataAddS64(imfileArgs, PS_LIST_TAIL, "-fake_id", 0,            "search by camtool ID", 0);
     130    psMetadataAddU64(imfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     131    psMetadataAddBool(imfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    195132
    196133    // -tooverlap
    197134    psMetadata *tooverlapArgs = psMetadataAlloc();
    198     psMetadataAddS64(tooverlapArgs, PS_LIST_TAIL, "-warp_id", 0,
    199             "search by warp ID", 0);
    200     psMetadataAddU64(tooverlapArgs, PS_LIST_TAIL, "-limit",  0,
    201             "limit result set to N items", 0);
    202     psMetadataAddBool(tooverlapArgs, PS_LIST_TAIL, "-simple",  0,
    203             "use the simple output format", false);
     135    psMetadataAddS64(tooverlapArgs, PS_LIST_TAIL, "-warp_id", 0,            "search by warp ID", 0);
     136    psMetadataAddU64(tooverlapArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     137    psMetadataAddBool(tooverlapArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    204138
    205139    // -addoverlap
    206140    psMetadata *addoverlapArgs = psMetadataAlloc();
    207     psMetadataAddStr(addoverlapArgs, PS_LIST_TAIL, "-mapfile", 0,
    208             "path to skycell <-> imfile mapping file", NULL);
    209     psMetadataAddS64(addoverlapArgs, PS_LIST_TAIL, "-warp_id",  0,
    210             "set warp ID", 0);
    211     psMetadataAddS16(addoverlapArgs, PS_LIST_TAIL, "-code",  0,
    212             "set fault code", 0);
     141    psMetadataAddStr(addoverlapArgs, PS_LIST_TAIL, "-mapfile", 0,            "path to skycell <-> imfile mapping file", NULL);
     142    psMetadataAddS64(addoverlapArgs, PS_LIST_TAIL, "-warp_id",  0,            "set warp ID", 0);
     143    psMetadataAddS16(addoverlapArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
    213144
    214145    // -scmap
    215146    psMetadata *scmapArgs = psMetadataAlloc();
    216     psMetadataAddS64(scmapArgs, PS_LIST_TAIL, "-warp_id", 0,
    217             "search by warptool ID", 0);
    218     psMetadataAddStr(scmapArgs, PS_LIST_TAIL, "-skycell_id", 0,
    219             "search by skycell ID", NULL);
    220     psMetadataAddStr(scmapArgs, PS_LIST_TAIL, "-tess_id", 0,
    221             "search by tess ID", NULL);
    222     psMetadataAddU64(scmapArgs, PS_LIST_TAIL, "-limit",  0,
    223             "limit result set to N items", 0);
    224     psMetadataAddBool(scmapArgs, PS_LIST_TAIL, "-simple",  0,
    225             "use the simple output format", false);
     147    psMetadataAddS64(scmapArgs, PS_LIST_TAIL, "-warp_id", 0,            "search by warptool ID", 0);
     148    psMetadataAddStr(scmapArgs, PS_LIST_TAIL, "-skycell_id", 0,            "search by skycell ID", NULL);
     149    psMetadataAddStr(scmapArgs, PS_LIST_TAIL, "-tess_id", 0,            "search by tess ID", NULL);
     150    psMetadataAddU64(scmapArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     151    psMetadataAddBool(scmapArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    226152
    227153    // -towarped
    228154    psMetadata *towarpedArgs = psMetadataAlloc();
    229     psMetadataAddS64(towarpedArgs, PS_LIST_TAIL, "-warp_id", 0,
    230             "search by warptool ID", 0);
    231     psMetadataAddU64(towarpedArgs, PS_LIST_TAIL, "-limit",  0,
    232             "limit result set to N items", 0);
    233     psMetadataAddBool(towarpedArgs, PS_LIST_TAIL, "-simple",  0,
    234             "use the simple output format", false);
     155    psMetadataAddS64(towarpedArgs, PS_LIST_TAIL, "-warp_id", 0,            "search by warptool ID", 0);
     156    psMetadataAddU64(towarpedArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     157    psMetadataAddBool(towarpedArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    235158
    236159    // -addwarped
    237160    psMetadata *addwarpedArgs = psMetadataAlloc();
    238     psMetadataAddS64(addwarpedArgs, PS_LIST_TAIL, "-warp_id", 0,
    239             "define warptool ID (required)", 0);
    240     psMetadataAddStr(addwarpedArgs, PS_LIST_TAIL, "-skycell_id",  0,
    241             "define skycell ID (required)", NULL);
    242     psMetadataAddStr(addwarpedArgs, PS_LIST_TAIL, "-tess_id",  0,
    243             "define tessellation ID (required)", NULL);
    244     psMetadataAddStr(addwarpedArgs, PS_LIST_TAIL, "-uri", 0,
    245             "define URI of file", 0);
    246     psMetadataAddStr(addwarpedArgs, PS_LIST_TAIL, "-path_base", 0,
    247             "define base output location", 0);
    248     psMetadataAddF64(addwarpedArgs, PS_LIST_TAIL, "-bg",  0,
    249             "define exposure background", NAN);
    250     psMetadataAddF64(addwarpedArgs, PS_LIST_TAIL, "-bg_stdev",  0,
    251             "define exposure background stdev", NAN);
    252     psMetadataAddF32(addwarpedArgs, PS_LIST_TAIL, "-dtime_warp",  0,
    253             "define elapsed processing time", NAN);
    254     psMetadataAddS32(addwarpedArgs, PS_LIST_TAIL, "-xmin",  0,
    255             "define minimum x value", INT_MAX);
    256     psMetadataAddS32(addwarpedArgs, PS_LIST_TAIL, "-xmax",  0,
    257             "define maximum x value", -INT_MAX);
    258     psMetadataAddS32(addwarpedArgs, PS_LIST_TAIL, "-ymin",  0,
    259             "define minimum y value", INT_MAX);
    260     psMetadataAddS32(addwarpedArgs, PS_LIST_TAIL, "-ymax",  0,
    261             "define maximum y value", -INT_MAX);
    262     psMetadataAddStr(addwarpedArgs, PS_LIST_TAIL, "-hostname", 0,
    263             "define hostname", 0);
    264     psMetadataAddF32(addwarpedArgs, PS_LIST_TAIL, "-good_frac",  0,
    265             "define %% of good pixels", NAN);
    266     psMetadataAddBool(addwarpedArgs, PS_LIST_TAIL, "-ignore",  0,
    267             "define if this skycell should be ignored", false);
    268     psMetadataAddS16(addwarpedArgs, PS_LIST_TAIL, "-code",  0,
    269             "set fault code", 0);
     161    psMetadataAddS64(addwarpedArgs, PS_LIST_TAIL, "-warp_id", 0,            "define warptool ID (required)", 0);
     162    psMetadataAddStr(addwarpedArgs, PS_LIST_TAIL, "-skycell_id",  0,            "define skycell ID (required)", NULL);
     163    psMetadataAddStr(addwarpedArgs, PS_LIST_TAIL, "-tess_id",  0,            "define tessellation ID (required)", NULL);
     164    psMetadataAddStr(addwarpedArgs, PS_LIST_TAIL, "-uri", 0,            "define URI of file", 0);
     165    psMetadataAddStr(addwarpedArgs, PS_LIST_TAIL, "-path_base", 0,            "define base output location", 0);
     166    psMetadataAddF64(addwarpedArgs, PS_LIST_TAIL, "-bg",  0,            "define exposure background", NAN);
     167    psMetadataAddF64(addwarpedArgs, PS_LIST_TAIL, "-bg_stdev",  0,            "define exposure background stdev", NAN);
     168    psMetadataAddF32(addwarpedArgs, PS_LIST_TAIL, "-dtime_warp",  0,            "define elapsed processing time", NAN);
     169    psMetadataAddS32(addwarpedArgs, PS_LIST_TAIL, "-xmin",  0,            "define minimum x value", INT_MAX);
     170    psMetadataAddS32(addwarpedArgs, PS_LIST_TAIL, "-xmax",  0,            "define maximum x value", -INT_MAX);
     171    psMetadataAddS32(addwarpedArgs, PS_LIST_TAIL, "-ymin",  0,            "define minimum y value", INT_MAX);
     172    psMetadataAddS32(addwarpedArgs, PS_LIST_TAIL, "-ymax",  0,            "define maximum y value", -INT_MAX);
     173    psMetadataAddStr(addwarpedArgs, PS_LIST_TAIL, "-hostname", 0,            "define hostname", 0);
     174    psMetadataAddF32(addwarpedArgs, PS_LIST_TAIL, "-good_frac",  0,            "define %% of good pixels", NAN);
     175    psMetadataAddBool(addwarpedArgs, PS_LIST_TAIL, "-ignore",  0,            "define if this skycell should be ignored", false);
     176    psMetadataAddS16(addwarpedArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
    270177
    271178    // -warped
    272179    psMetadata *warpedArgs = psMetadataAlloc();
    273     psMetadataAddS64(warpedArgs, PS_LIST_TAIL, "-warp_id", 0,
    274             "search by warptool ID", 0);
    275     psMetadataAddStr(warpedArgs, PS_LIST_TAIL, "-skycell_id",  0,
    276             "define skycell ID", NULL);
    277     psMetadataAddStr(warpedArgs, PS_LIST_TAIL, "-tess_id",  0,
    278             "define tessellation ID", NULL);
    279     psMetadataAddS64(warpedArgs, PS_LIST_TAIL, "-exp_id", 0,
    280             "define exposure tag", 0);
    281     psMetadataAddS64(warpedArgs, PS_LIST_TAIL, "-fake_id", 0,
    282             "define phase 3 version of exposure tag", 0);
    283     psMetadataAddU64(warpedArgs, PS_LIST_TAIL, "-limit",  0,
    284             "limit result set to N items", 0);
    285     psMetadataAddBool(warpedArgs, PS_LIST_TAIL, "-simple",  0,
    286             "use the simple output format", false);
     180    psMetadataAddS64(warpedArgs, PS_LIST_TAIL, "-warp_id", 0,            "search by warptool ID", 0);
     181    psMetadataAddStr(warpedArgs, PS_LIST_TAIL, "-skycell_id",  0,            "define skycell ID", NULL);
     182    psMetadataAddStr(warpedArgs, PS_LIST_TAIL, "-tess_id",  0,            "define tessellation ID", NULL);
     183    psMetadataAddS64(warpedArgs, PS_LIST_TAIL, "-exp_id", 0,            "define exposure tag", 0);
     184    psMetadataAddS64(warpedArgs, PS_LIST_TAIL, "-fake_id", 0,            "define phase 3 version of exposure tag", 0);
     185    psMetadataAddU64(warpedArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     186    psMetadataAddBool(warpedArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    287187
    288188    // -revertwarped
     189    // XXX need to allow multiple fake_ids
     190    // XXX need to allow multiple fake_ids
     191    // XXX need to allow multiple chip_ids
     192    // XXX need to allow multiple exp_ids
    289193    psMetadata *revertwarpedArgs = psMetadataAlloc();
    290     // XXX need to allow multiple fake_ids
    291     psMetadataAddS64(revertwarpedArgs, PS_LIST_TAIL, "-warp_id", 0,
    292             "search by warptool ID", 0);
    293     psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-skycell_id",  0,
    294             "search by skycell ID", NULL);
    295     psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-tess_id",  0,
    296             "searcy by tessellation ID", NULL);
    297     // XXX need to allow multiple fake_ids
    298     psMetadataAddS64(revertwarpedArgs, PS_LIST_TAIL, "-fake_id",  0,
    299             "search by fake_id", 0);
    300     // XXX need to allow multiple chip_ids
    301     psMetadataAddS64(revertwarpedArgs, PS_LIST_TAIL, "-chip_id",  0,
    302             "search by chip_id", 0);
    303     // XXX need to allow multiple exp_ids
    304     psMetadataAddS64(revertwarpedArgs, PS_LIST_TAIL, "-exp_id",  0,
    305             "search by exp_id", 0);
    306     psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-exp_name",  0,
    307             "search by exp_name", NULL);
    308     psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-inst",  0,
    309             "search for camera", NULL);
    310     psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-telescope",  0,
    311             "search for telescope", NULL);
    312     psMetadataAddTime(revertwarpedArgs, PS_LIST_TAIL, "-dateobs_begin", 0,
    313             "search for exposures by time (>=)", NULL);
    314     psMetadataAddTime(revertwarpedArgs, PS_LIST_TAIL, "-dateobs_end", 0,
    315             "search for exposures by time (<)", NULL);
    316     psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-exp_tag",  0,
    317             "search by exp_tag", NULL);
    318     psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-exp_type",  0,
    319             "search by exp_type", NULL);
    320     psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-filelevel",  0,
    321             "search by filelevel", NULL);
    322     psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-reduction",  0,
    323             "search by reduction class", NULL);
    324     psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-filter",  0,
    325             "search for filter", NULL);
    326     psMetadataAddF32(revertwarpedArgs, PS_LIST_TAIL, "-airmass_min",  0,
    327             "define min airmass", NAN);
    328     psMetadataAddF32(revertwarpedArgs, PS_LIST_TAIL, "-airmass_max",  0,
    329             "define max airmass", NAN);
    330     psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-ra_min",  0,
    331             "define min", NAN);
    332     psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-ra_max",  0,
    333             "define max", NAN);
    334     psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-decl_min",  0,
    335             "define min", NAN);
    336     psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-decl_max",  0,
    337             "define max", NAN);
    338     psMetadataAddF32(revertwarpedArgs, PS_LIST_TAIL, "-exp_time_min",  0,
    339             "define min", NAN);
    340     psMetadataAddF32(revertwarpedArgs, PS_LIST_TAIL, "-exp_time_max",  0,
    341             "define max", NAN);
    342     psMetadataAddF32(revertwarpedArgs, PS_LIST_TAIL, "-sat_pixel_frac_min",  0,
    343             "define max fraction of saturated pixels", NAN);
    344     psMetadataAddF32(revertwarpedArgs, PS_LIST_TAIL, "-sat_pixel_frac_max",  0,
    345             "define min fraction of saturated pixels", NAN);
    346     psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-bg_min",  0,
    347             "define max", NAN);
    348     psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-bg_max",  0,
    349             "define max", NAN);
    350     psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-bg_stdev_min",  0,
    351             "define max", NAN);
    352     psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-bg_stdev_max",  0,
    353             "define max", NAN);
    354     psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-bg_mean_stdev_min",  0,
    355             "define max", NAN);
    356     psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-bg_mean_stdev_max",  0,
    357             "define max", NAN);
    358     psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-alt_min",  0,
    359             "define min", NAN);
    360     psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-alt_max",  0,
    361             "define max", NAN);
    362     psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-az_min",  0,
    363             "define min", NAN);
    364     psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-az_max",  0,
    365             "define max", NAN);
    366     psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-ccd_temp_min",  0,
    367             "define min ccd tempature", NAN);
    368     psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-ccd_temp_max",  0,
    369             "define max ccd tempature", NAN);
    370     psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-posang_min",  0,
    371             "define min rotator position angle", NAN);
    372     psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-posang_max",  0,
    373             "define max rotator position angle", NAN);
    374     psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-object",  0,
    375             "search by exposure object", NULL);
    376     psMetadataAddF32(revertwarpedArgs, PS_LIST_TAIL, "-solang_min",  0,
    377             "define min solar angle", NAN);
    378     psMetadataAddF32(revertwarpedArgs, PS_LIST_TAIL, "-solang_max",  0,
    379             "define max solar angle", NAN);
    380 
    381     psMetadataAddS16(revertwarpedArgs, PS_LIST_TAIL, "-code",  0,
    382             "search by fault code", 0);
    383     psMetadataAddBool(revertwarpedArgs, PS_LIST_TAIL, "-all",  0,
    384             "allow everything to be queued without search terms", false);
     194    psMetadataAddS64(revertwarpedArgs, PS_LIST_TAIL, "-warp_id", 0,            "search by warptool ID", 0);
     195    psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-skycell_id",  0,            "search by skycell ID", NULL);
     196    psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-tess_id",  0,            "searcy by tessellation ID", NULL);
     197    psMetadataAddS64(revertwarpedArgs, PS_LIST_TAIL, "-fake_id",  0,            "search by fake_id", 0);
     198    psMetadataAddS64(revertwarpedArgs, PS_LIST_TAIL, "-chip_id",  0,            "search by chip_id", 0);
     199    psMetadataAddS64(revertwarpedArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exp_id", 0);
     200    psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-exp_name",  0,            "search by exp_name", NULL);
     201    psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-inst",  0,            "search for camera", NULL);
     202    psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-telescope",  0,            "search for telescope", NULL);
     203    psMetadataAddTime(revertwarpedArgs, PS_LIST_TAIL, "-dateobs_begin", 0,            "search for exposures by time (>=)", NULL);
     204    psMetadataAddTime(revertwarpedArgs, PS_LIST_TAIL, "-dateobs_end", 0,            "search for exposures by time (<)", NULL);
     205    psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-exp_tag",  0,            "search by exp_tag", NULL);
     206    psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-exp_type",  0,            "search by exp_type", NULL);
     207    psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-filelevel",  0,            "search by filelevel", NULL);
     208    psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-reduction",  0,            "search by reduction class", NULL);
     209    psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-filter",  0,            "search for filter", NULL);
     210    psMetadataAddF32(revertwarpedArgs, PS_LIST_TAIL, "-airmass_min",  0,            "define min airmass", NAN);
     211    psMetadataAddF32(revertwarpedArgs, PS_LIST_TAIL, "-airmass_max",  0,            "define max airmass", NAN);
     212    psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-ra_min",  0,            "define min", NAN);
     213    psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-ra_max",  0,            "define max", NAN);
     214    psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-decl_min",  0,            "define min", NAN);
     215    psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-decl_max",  0,            "define max", NAN);
     216    psMetadataAddF32(revertwarpedArgs, PS_LIST_TAIL, "-exp_time_min",  0,            "define min", NAN);
     217    psMetadataAddF32(revertwarpedArgs, PS_LIST_TAIL, "-exp_time_max",  0,            "define max", NAN);
     218    psMetadataAddF32(revertwarpedArgs, PS_LIST_TAIL, "-sat_pixel_frac_min",  0,            "define max fraction of saturated pixels", NAN);
     219    psMetadataAddF32(revertwarpedArgs, PS_LIST_TAIL, "-sat_pixel_frac_max",  0,            "define min fraction of saturated pixels", NAN);
     220    psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-bg_min",  0,            "define max", NAN);
     221    psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-bg_max",  0,            "define max", NAN);
     222    psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-bg_stdev_min",  0,            "define max", NAN);
     223    psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-bg_stdev_max",  0,            "define max", NAN);
     224    psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-bg_mean_stdev_min",  0,            "define max", NAN);
     225    psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-bg_mean_stdev_max",  0,            "define max", NAN);
     226    psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-alt_min",  0,            "define min", NAN);
     227    psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-alt_max",  0,            "define max", NAN);
     228    psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-az_min",  0,            "define min", NAN);
     229    psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-az_max",  0,            "define max", NAN);
     230    psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-ccd_temp_min",  0,            "define min ccd tempature", NAN);
     231    psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-ccd_temp_max",  0,            "define max ccd tempature", NAN);
     232    psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-posang_min",  0,            "define min rotator position angle", NAN);
     233    psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-posang_max",  0,            "define max rotator position angle", NAN);
     234    psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-object",  0,            "search by exposure object", NULL);
     235    psMetadataAddF32(revertwarpedArgs, PS_LIST_TAIL, "-solang_min",  0,            "define min solar angle", NAN);
     236    psMetadataAddF32(revertwarpedArgs, PS_LIST_TAIL, "-solang_max",  0,            "define max solar angle", NAN);
     237
     238    psMetadataAddS16(revertwarpedArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
     239    psMetadataAddBool(revertwarpedArgs, PS_LIST_TAIL, "-all",  0,            "allow everything to be queued without search terms", false);
    385240
    386241    // -block
    387242    psMetadata *blockArgs = psMetadataAlloc();
    388     psMetadataAddStr(blockArgs, PS_LIST_TAIL, "-label",  0,
    389             "name of a label to mask out (required)", NULL);
     243    psMetadataAddStr(blockArgs, PS_LIST_TAIL, "-label",  0,            "name of a label to mask out (required)", NULL);
    390244
    391245    // -masked
    392246    psMetadata *maskedArgs = psMetadataAlloc();
    393     psMetadataAddBool(maskedArgs, PS_LIST_TAIL, "-simple",  0,
    394             "use the simple output format", false);
     247    psMetadataAddBool(maskedArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    395248
    396249    // -unblock
    397250    psMetadata *unblockArgs = psMetadataAlloc();
    398     psMetadataAddStr(unblockArgs, PS_LIST_TAIL, "-label",  0,
    399             "name of a label to unmask (required)", NULL);
     251    psMetadataAddStr(unblockArgs, PS_LIST_TAIL, "-label",  0,            "name of a label to unmask (required)", NULL);
    400252
    401253    psFree(now);
    … …  
    429281    psFree(modes);
    430282
    431     // generate SQL where clause
    432     config->where = psMetadataAlloc();
    433 
    434     PXOPT_ADD_WHERE_S64(warp_id);
    435     PXOPT_ADD_WHERE_STR(skycell_id);
    436     PXOPT_ADD_WHERE_STR(tess_id);
    437     PXOPT_ADD_WHERE_STR(exp_id);
    438     PXOPT_ADD_WHERE_S16_ALIAS("-code", "fault");
    439 
    440     if (config->where->list->n < 1) {
    441         psFree(config->where);
    442         config->where = NULL;
    443     }
    444 
    445283    // define Database handle, if used
    446284    // do this last so we don't setup a connection before CLI options are
Note: See TracChangeset for help on using the changeset viewer.