IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 18468


Ignore:
Timestamp:
Jul 11, 2008, 8:30:31 AM (18 years ago)
Author:
eugene
Message:

make argument handling consistent across all tools

Location:
branches/eam_branch_20080706/ippTools
Files:
9 added
22 edited

Legend:

Unmodified
Added
Removed

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

    r18172 r18468  
    106106    psFree(modes);
    107107
    108     // setup search criterion
    109 #define addWhereStr(name) \
    110 { \
    111     psString str = NULL; \
    112     bool status = false; \
    113     if ((str = psMetadataLookupStr(&status, config->args, "-" #name))) { \
    114         if (!psMetadataAddStr(config->where, PS_LIST_TAIL, #name, 0, "==", str)) {\
    115             psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
    116             psFree(config); \
    117             return NULL; \
    118         } \
    119     } \
    120 }
    121 
    122108    // generate SQL where clause
    123109    config->where = psMetadataAlloc();
    124110
    125     addWhereStr(det_id);
    126     {
    127         // XXX this is broke because you can't specify -iteration 0
    128         psMetadataItem *item = psMetadataLookup(config->args, "-iteration");
    129         if (item && psStrcasestr(item->comment, "found")) {
    130             if (!psMetadataAddS32(config->where, PS_LIST_TAIL, "iteration", 0, "==", item->data.S32)) {
    131                 psError(PS_ERR_UNKNOWN, false, "failed to add item iteration");
    132                 psFree(config);
    133                 return NULL;
    134             }
    135         }
    136     }
    137 
    138     addWhereStr(det_id);
    139 
    140     // convert '-code' to 'fault'
    141     {
    142         psS16 fault = 0;
    143         bool status = false;
    144         if ((fault = psMetadataLookupS16(&status, config->args, "-code"))) {
    145             if (!psMetadataAddS16(config->where, PS_LIST_TAIL, "fault", 0, "==", fault)) {
    146                 psError(PS_ERR_UNKNOWN, false, "failed to add item fault");
    147                 psFree(config);
    148                 return NULL;
    149             }
    150         }
    151     }
     111    PXOPT_ADD_WHERE_STR(det_id);
     112    PXOPT_ADD_WHERE_S32(iteration);
     113    PXOPT_ADD_WHERE_S16_ALIAS("-code", "fault");
    152114
    153115    if (config->where->list->n < 1) {

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

    r18467 r18468  
    110110    PXOPT_COPY_STR(config->args, where, "-reduction", "reduction", "==");
    111111    PXOPT_COPY_STR(config->args, where, "-filter", "filter", "==");
    112 
    113112    PXOPT_COPY_F64(config->args, where, "-airmass_min", "airmass", ">=");
    114113    PXOPT_COPY_F64(config->args, where, "-airmass_max", "airmass", "<");
    … …  
    162161    }
    163162
     163    // use psDBGenerateWhereSQL because the SQL yields an intermediate table
    164164    if (where && psListLength(where->list)) {
    165165        psString whereClause = psDBGenerateWhereSQL(where, NULL);
    … …  
    263263    PXOPT_COPY_STR(config->args, where, "-reduction", "reduction", "==");
    264264    PXOPT_COPY_STR(config->args, where, "-filter", "filter", "==");
    265 
    266265    PXOPT_COPY_F64(config->args, where, "-airmass_min", "airmass", ">=");
    267266    PXOPT_COPY_F64(config->args, where, "-airmass_max", "airmass", "<");
    … …  
    334333    PS_ASSERT_PTR_NON_NULL(config, false);
    335334
     335    psMetadata *where = psMetadataAlloc();
     336    PXOPT_COPY_S64(config->args, where, "-cam_id", "cam_id", "==");
     337    PXOPT_COPY_S64(config->args, where, "-chip_id", "chip_id", "==");
     338
    336339    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    337340    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    … …  
    343346    }
    344347
    345     if (config->where) {
    346         psString whereClause = psDBGenerateWhereSQL(config->where, NULL);
    347         psStringAppend(&query, " %s", whereClause);
     348    // use psDBGenerateWhereSQL because the SQL yields an intermediate table
     349    if (psListLength(where->list)) {
     350        psString whereClause = psDBGenerateWhereSQL(where, NULL);
     351        psStringAppend(&query, "%s", whereClause);
    348352        psFree(whereClause);
    349353    }
     354    psFree(where);
    350355
    351356    // treat limit == 0 as "no limit"
    … …  
    390395    PS_ASSERT_PTR_NON_NULL(config, false);
    391396
     397    psMetadata *where = psMetadataAlloc();
     398    PXOPT_COPY_S64(config->args, where, "-cam_id",   "cam_id",   "==");
     399    PXOPT_COPY_S64(config->args, where, "-chip_id",  "chip_id",  "==");
     400    PXOPT_COPY_STR(config->args, where, "-class",    "class",    "==");
     401    PXOPT_COPY_STR(config->args, where, "-class_id", "class_id", "==");
     402
    392403    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    393404
    … …  
    398409    }
    399410
    400     if (config->where) {
    401         psString whereClause = psDBGenerateWhereSQL(config->where, NULL);
    402         psStringAppend(&query, " %s", whereClause);
     411    // use psDBGenerateWhereSQL because the SQL yields an intermediate table
     412    if (psListLength(where->list)) {
     413        psString whereClause = psDBGenerateWhereSQL(where, NULL);
     414        psStringAppend(&query, "%s", whereClause);
    403415        psFree(whereClause);
    404416    }
     417    psFree(where);
    405418
    406419    if (!p_psDBRunQuery(config->dbh, query)) {
    … …  
    463476    PXOPT_LOOKUP_F32(dtime_astrom, config->args, "-dtime_astrom", false, false);
    464477    PXOPT_LOOKUP_STR(hostname, config->args,       "-hostname", false, false);
    465     PXOPT_LOOKUP_F32(n_stars, config->args, "-n_stars", false, false);
    466     PXOPT_LOOKUP_F32(n_extended, config->args, "-n_extended", false, false);
    467     if (n_extended < 0) {
    468         psError(PS_ERR_UNKNOWN, true, "-n_extended is required");
    469         return false;
    470     }
    471     PXOPT_LOOKUP_F32(n_cr, config->args, "-n_cr", false, false);
    472     if (n_cr < 0) {
    473         psError(PS_ERR_UNKNOWN, true, "-n_cr is required");
    474         return false;
    475     }
    476     PXOPT_LOOKUP_F32(n_astrom, config->args, "-n_astrom", false, false);
    477     if (n_astrom < 0) {
    478         psError(PS_ERR_UNKNOWN, true, "-n_astrom is required");
    479         return false;
    480     }
    481 
     478    PXOPT_LOOKUP_S32(n_stars, config->args,        "-n_stars", false, false);
     479    PXOPT_LOOKUP_S32(n_extended, config->args,     "-n_extended", false, false);
     480    PXOPT_LOOKUP_S32(n_cr, config->args,           "-n_cr", false, false);
     481    PXOPT_LOOKUP_S32(n_astrom, config->args,       "-n_astrom", false, false);
    482482    PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", false, false);
    483 
    484     // default
    485483    PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
     484
     485    // generate restrictions
     486    psMetadata *where = psMetadataAlloc();
     487    PXOPT_COPY_S64(config->args, where, "-cam_id",   "cam_id",   "==");
    486488
    487489    psString query = pxDataGet("camtool_find_pendingexp.sql");
    … …  
    491493    }
    492494
    493     {
    494         // build a query to search by cam_id
    495         psMetadata *where = psMetadataAlloc();
    496         if (cam_id) {
    497             if (!psMetadataAddS64(where, PS_LIST_TAIL, "cam_id", 0, "==", cam_id)) {
    498                 psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id");
    499                 psFree(where);
    500                 psFree(query);
    501                 return false;
    502             }
    503         }
    504 
     495    // use psDBGenerateWhereSQL because the SQL yields an intermediate table
     496    if (psListLength(where->list)) {
    505497        psString whereClaus = psDBGenerateWhereSQL(where, NULL);
    506         psFree(where);
    507         if (whereClaus) {
    508             psStringAppend(&query, " %s", whereClaus);
    509             psFree(whereClaus);
    510         }
    511 
    512     }
     498        psStringAppend(&query, "%s", whereClaus);
     499        psFree(whereClaus);
     500    }
     501    psFree(where);
    513502
    514503    if (!p_psDBRunQuery(config->dbh, query)) {
    … …  
    640629    PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    641630
     631    // generate restrictions
     632    psMetadata *where = psMetadataAlloc();
     633    PXOPT_COPY_S64(config->args, where, "-cam_id",   "cam_id",   "==");
     634    PXOPT_COPY_S64(config->args, where, "-chip_id",  "chip_id",   "==");
     635
    642636    psString query = pxDataGet("camtool_find_processedexp.sql");
    643637    if (!query) {
    … …  
    646640    }
    647641
    648     if (config->where) {
    649         psString whereClause = psDBGenerateWhereConditionSQL(config->where, NULL);
     642    // use psDBGenerateWhereConditionalSQL with AND ... because the SQL ends in a WHERE
     643    if (psListLength(where->list)) {
     644        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    650645        psStringAppend(&query, " AND %s", whereClause);
    651646        psFree(whereClause);
    652647    }
     648    psFree(where);
    653649
    654650    if (faulted) {
    … …  
    716712    PXOPT_COPY_STR(config->args, where, "-reduction", "reduction", "==");
    717713    PXOPT_COPY_STR(config->args, where, "-filter", "filter", "==");
    718 
    719     PXOPT_COPY_F64(config->args, where, "-airmass_min", "airmass", ">=");
    720     PXOPT_COPY_F64(config->args, where, "-airmass_max", "airmass", "<");
     714    PXOPT_COPY_F32(config->args, where, "-airmass_min", "airmass", ">=");
     715    PXOPT_COPY_F32(config->args, where, "-airmass_max", "airmass", "<");
    721716    PXOPT_COPY_F64(config->args, where, "-ra_min", "ra", ">=");
    722717    PXOPT_COPY_F64(config->args, where, "-ra_max", "ra", "<");
    … …  
    745740    PXOPT_COPY_F32(config->args, where, "-solang_max", "solang", "<");
    746741
    747     if (!psListLength(where->list)
    748         && !psMetadataLookupBool(NULL, config->args, "-all")) {
     742    if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
    749743        psFree(where);
    750744        psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
    … …  
    758752    }
    759753
    760 {
    761     psString query = pxDataGet("camtool_reset_faulted_runs.sql");
    762     if (!query) {
    763         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    764         psFree(where);
    765         return false;
    766     }
    767 
    768     if (where && psListLength(where->list)) {
    769         psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    770         psStringAppend(&query, " AND %s", whereClause);
    771         psFree(whereClause);
    772     }
    773 
    774     if (!p_psDBRunQuery(config->dbh, query)) {
    775         // rollback
    776         if (!psDBRollback(config->dbh)) {
    777             psError(PS_ERR_UNKNOWN, false, "database error");
    778         }
    779         psError(PS_ERR_UNKNOWN, false, "database error");
    780         psFree(query);
    781         psFree(where);
    782         return false;
    783     }
    784     psFree(query);
    785 }
    786 
    787 {
    788     psString query = pxDataGet("camtool_revertprocessedexp.sql");
    789     if (!query) {
    790         // rollback
    791         if (!psDBRollback(config->dbh)) {
    792             psError(PS_ERR_UNKNOWN, false, "database error");
    793         }
    794         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    795         psFree(where);
    796         return false;
    797     }
    798 
    799     if (where && psListLength(where->list)) {
    800         psString whereClause = psDBGenerateWhereConditionSQL(config->where, NULL);
    801         psStringAppend(&query, " AND %s", whereClause);
    802         psFree(whereClause);
    803     }
    804 
    805     if (!p_psDBRunQuery(config->dbh, query)) {
    806         // rollback
    807         if (!psDBRollback(config->dbh)) {
    808             psError(PS_ERR_UNKNOWN, false, "database error");
    809         }
    810         psError(PS_ERR_UNKNOWN, false, "database error");
    811         psFree(query);
    812         psFree(where);
    813         return false;
    814     }
    815     psFree(query);
    816 }
     754    {
     755        psString query = pxDataGet("camtool_reset_faulted_runs.sql");
     756        if (!query) {
     757            psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     758            psFree(where);
     759            return false;
     760        }
     761
     762        // use psDBGenerateWhereConditionalSQL with AND ... because the SQL ends in a WHERE
     763        if (where && psListLength(where->list)) {
     764            psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     765            psStringAppend(&query, " AND %s", whereClause);
     766            psFree(whereClause);
     767        }
     768
     769        if (!p_psDBRunQuery(config->dbh, query)) {
     770            // rollback
     771            if (!psDBRollback(config->dbh)) {
     772                psError(PS_ERR_UNKNOWN, false, "database error");
     773            }
     774            psError(PS_ERR_UNKNOWN, false, "database error");
     775            psFree(query);
     776            psFree(where);
     777            return false;
     778        }
     779        psFree(query);
     780    }
     781
     782    {
     783        psString query = pxDataGet("camtool_revertprocessedexp.sql");
     784        if (!query) {
     785            // rollback
     786            if (!psDBRollback(config->dbh)) {
     787                psError(PS_ERR_UNKNOWN, false, "database error");
     788            }
     789            psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     790            psFree(where);
     791            return false;
     792        }
     793
     794        // use psDBGenerateWhereConditionalSQL with AND ... because the SQL ends in a WHERE
     795        if (where && psListLength(where->list)) {
     796            psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     797            psStringAppend(&query, " AND %s", whereClause);
     798            psFree(whereClause);
     799        }
     800
     801        if (!p_psDBRunQuery(config->dbh, query)) {
     802            // rollback
     803            if (!psDBRollback(config->dbh)) {
     804                psError(PS_ERR_UNKNOWN, false, "database error");
     805            }
     806            psError(PS_ERR_UNKNOWN, false, "database error");
     807            psFree(query);
     808            psFree(where);
     809            return false;
     810        }
     811        psFree(query);
     812    }
    817813    psFree(where);
    818814
    … …  
    832828    PXOPT_LOOKUP_S16(code, config->args, "-code", true, false);
    833829
    834     if (!pxSetFaultCode(config->dbh, "camProcessedExp", config->where, code)) {
     830    psMetadata *where = psMetadataAlloc();
     831    PXOPT_COPY_S64(config->args, where, "-cam_id",   "cam_id",   "==");
     832    PXOPT_COPY_S64(config->args, where, "-chip_id",  "chip_id",  "==");
     833    PXOPT_COPY_STR(config->args, where, "-class",    "class",    "==");
     834    PXOPT_COPY_STR(config->args, where, "-class_id", "class_id", "==");
     835
     836    if (!pxSetFaultCode(config->dbh, "camProcessedExp", where, code)) {
    835837        psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag");
    836         return false;
    837     }
     838        psFree (where);
     839        return false;
     840    }
     841    psFree (where);
    838842
    839843    return true;

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

    r18467 r18468  
    4747
    4848    // -definebyquery
     49    // XXX need to allow multiple chip_ids
     50    // XXX need to allow multiple exp_ids
    4951    psMetadata *definebydefinebyqueryArgs = psMetadataAlloc();
     52    psMetadataAddS64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-chip_id",            0, "search by chip_id", 0);
     53    psMetadataAddS64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-exp_id",             0, "search by exp_id", 0);
     54    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-exp_name",           0, "search by exp_name", NULL);
     55    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-inst",               0, "search for camera", NULL);
     56    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-telescope",          0, "search for telescope", NULL);
     57    psMetadataAddTime(definebydefinebyqueryArgs, PS_LIST_TAIL, "-dateobs_begin",     0, "search for exposures by time (>=)", NULL);
     58    psMetadataAddTime(definebydefinebyqueryArgs, PS_LIST_TAIL, "-dateobs_end",       0, "search for exposures by time (<)", NULL);
     59    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-exp_tag",            0, "search by exp_tag", NULL);
     60    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-exp_type",           0, "search by exp_type", NULL);
     61    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-filelevel",          0, "search by filelevel", NULL);
     62    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-reduction",          0, "search by reduction class", NULL);
     63    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-filter",             0, "search for filter", NULL);
     64    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-airmass_min",        0, "define min airmass", NAN);
     65    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-airmass_max",        0, "define max airmass", NAN);
     66    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-ra_min",             0, "define min", NAN);
     67    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-ra_max",             0, "define max", NAN);
     68    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-decl_min",           0, "define min", NAN);
     69    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-decl_max",           0, "define max", NAN);
     70    psMetadataAddF32(definebydefinebyqueryArgs, PS_LIST_TAIL, "-exp_time_min",       0, "define min", NAN);
     71    psMetadataAddF32(definebydefinebyqueryArgs, PS_LIST_TAIL, "-exp_time_max",       0, "define max", NAN);
     72    psMetadataAddF32(definebydefinebyqueryArgs, PS_LIST_TAIL, "-sat_pixel_frac_min", 0, "define max fraction of saturated pixels", NAN);
     73    psMetadataAddF32(definebydefinebyqueryArgs, PS_LIST_TAIL, "-sat_pixel_frac_max", 0, "define min fraction of saturated pixels", NAN);
     74    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-bg_min",             0, "define max", NAN);
     75    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-bg_max",             0, "define max", NAN);
     76    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-bg_stdev_min",       0, "define max", NAN);
     77    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-bg_stdev_max",       0, "define max", NAN);
     78    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-bg_mean_stdev_min",  0, "define max", NAN);
     79    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-bg_mean_stdev_max",  0, "define max", NAN);
     80    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-alt_min",            0, "define min", NAN);
     81    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-alt_max",            0, "define max", NAN);
     82    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-az_min",             0, "define min", NAN);
     83    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-az_max",             0, "define max", NAN);
     84    psMetadataAddF32(definebydefinebyqueryArgs, PS_LIST_TAIL, "-ccd_temp_min",       0, "define min ccd tempature", NAN);
     85    psMetadataAddF32(definebydefinebyqueryArgs, PS_LIST_TAIL, "-ccd_temp_max",       0, "define max ccd tempature", NAN);
     86    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-posang_min",         0, "define min rotator position angle", NAN);
     87    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-posang_max",         0, "define max rotator position angle", NAN);
     88    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-object",             0, "search by exposure object", NULL);
     89    psMetadataAddF32(definebydefinebyqueryArgs, PS_LIST_TAIL, "-solang_min",         0, "define min solar angle", NAN);
     90    psMetadataAddF32(definebydefinebyqueryArgs, PS_LIST_TAIL, "-solang_max",         0, "define max solar angle", NAN);
     91
     92    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-set_workdir",        0, "define workdir", NULL);
     93    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-set_label",          0, "define label", NULL);
     94    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-set_reduction",      0, "define reduction class", NULL);
     95    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-set_expgroup",       0, "define exposure group", NULL);
     96    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-set_dvodb",          0, "define DVO db", NULL);
     97    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-set_tess_id",        0, "define tess ID", NULL);
     98    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-set_end_stage",      0, "define end stage", NULL);
     99    psMetadataAddBool(definebydefinebyqueryArgs, PS_LIST_TAIL, "-all",               0, "allow everything to be queued without search terms", false);
     100
     101    // -updaterun
     102    // XXX need to allow multiple cam_ids
    50103    // XXX need to allow multiple chip_ids
    51     psMetadataAddS64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-chip_id",  0,
    52             "search by chip_id", 0);
    53104    // XXX need to allow multiple exp_ids
    54     psMetadataAddS64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-exp_id",  0,
    55             "search by exp_id", 0);
    56     psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-exp_name",  0,
    57             "search by exp_name", NULL);
    58     psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-inst",  0,
    59             "search for camera", NULL);
    60     psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-telescope",  0,
    61             "search for telescope", NULL);
    62     psMetadataAddTime(definebydefinebyqueryArgs, PS_LIST_TAIL, "-dateobs_begin", 0,
    63             "search for exposures by time (>=)", NULL);
    64     psMetadataAddTime(definebydefinebyqueryArgs, PS_LIST_TAIL, "-dateobs_end", 0,
    65             "search for exposures by time (<)", NULL);
    66     psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-exp_tag",  0,
    67             "search by exp_tag", NULL);
    68     psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-exp_type",  0,
    69             "search by exp_type", NULL);
    70     psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-filelevel",  0,
    71             "search by filelevel", NULL);
    72     psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-reduction",  0,
    73             "search by reduction class", NULL);
    74     psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-filter",  0,
    75             "search for filter", NULL);
    76     psMetadataAddF32(definebydefinebyqueryArgs, PS_LIST_TAIL, "-airmass_min",  0,
    77             "define min airmass", NAN);
    78     psMetadataAddF32(definebydefinebyqueryArgs, PS_LIST_TAIL, "-airmass_max",  0,
    79             "define max airmass", NAN);
    80     psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-ra_min",  0,
    81             "define min", NAN);
    82     psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-ra_max",  0,
    83             "define max", NAN);
    84     psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-decl_min",  0,
    85             "define min", NAN);
    86     psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-decl_max",  0,
    87             "define max", NAN);
    88     psMetadataAddF32(definebydefinebyqueryArgs, PS_LIST_TAIL, "-exp_time_min",  0,
    89             "define min", NAN);
    90     psMetadataAddF32(definebydefinebyqueryArgs, PS_LIST_TAIL, "-exp_time_max",  0,
    91             "define max", NAN);
    92     psMetadataAddF32(definebydefinebyqueryArgs, PS_LIST_TAIL, "-sat_pixel_frac_min",  0,
    93             "define max fraction of saturated pixels", NAN);
    94     psMetadataAddF32(definebydefinebyqueryArgs, PS_LIST_TAIL, "-sat_pixel_frac_max",  0,
    95             "define min fraction of saturated pixels", NAN);
    96     psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-bg_min",  0,
    97             "define max", NAN);
    98     psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-bg_max",  0,
    99             "define max", NAN);
    100     psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-bg_stdev_min",  0,
    101             "define max", NAN);
    102     psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-bg_stdev_max",  0,
    103             "define max", NAN);
    104     psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-bg_mean_stdev_min",  0,
    105             "define max", NAN);
    106     psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-bg_mean_stdev_max",  0,
    107             "define max", NAN);
    108     psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-alt_min",  0,
    109             "define min", NAN);
    110     psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-alt_max",  0,
    111             "define max", NAN);
    112     psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-az_min",  0,
    113             "define min", NAN);
    114     psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-az_max",  0,
    115             "define max", NAN);
    116     psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-ccd_temp_min",  0,
    117             "define min ccd tempature", NAN);
    118     psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-ccd_temp_max",  0,
    119             "define max ccd tempature", NAN);
    120     psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-posang_min",  0,
    121             "define min rotator position angle", NAN);
    122     psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-posang_max",  0,
    123             "define max rotator position angle", NAN);
    124     psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-object",  0,
    125             "search by exposure object", NULL);
    126     psMetadataAddF32(definebydefinebyqueryArgs, PS_LIST_TAIL, "-solang_min",  0,
    127             "define min solar angle", NAN);
    128     psMetadataAddF32(definebydefinebyqueryArgs, PS_LIST_TAIL, "-solang_max",  0,
    129             "define max solar angle", NAN);
    130     psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-set_workdir",  0,
    131             "define workdir", NULL);
    132     psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-set_label",  0,
    133             "define label", NULL);
    134     psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-set_reduction",  0,
    135             "define reduction class", NULL);
    136     psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-set_expgroup",  0,
    137             "define exposure group", NULL);
    138     psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-set_dvodb",  0,
    139             "define DVO db", NULL);
    140     psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-set_tess_id",  0,
    141             "define tess ID", NULL);
    142     psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-set_end_stage",  0,
    143             "define end stage", NULL);
    144     psMetadataAddBool(definebydefinebyqueryArgs, PS_LIST_TAIL, "-all",  0,
    145             "allow everything to be queued without search terms", false);
    146 
    147     // -updaterun
    148105    psMetadata *updaterunArgs = psMetadataAlloc();
    149     // XXX need to allow multiple cam_ids
    150     psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-cam_id",  0,
    151             "search by cam_id", 0);
    152     // XXX need to allow multiple chip_ids
    153     psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-chip_id",  0,
    154             "search by chip_id", 0);
    155     // XXX need to allow multiple exp_ids
    156     psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-exp_id",  0,
    157             "search by exp_id", 0);
    158     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_name",  0,
    159             "search by exp_name", NULL);
    160     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-inst",  0,
    161             "search for camera", NULL);
    162     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-telescope",  0,
    163             "search for telescope", NULL);
    164     psMetadataAddTime(updaterunArgs, PS_LIST_TAIL, "-dateobs_begin", 0,
    165             "search for exposures by time (>=)", NULL);
    166     psMetadataAddTime(updaterunArgs, PS_LIST_TAIL, "-dateobs_end", 0,
    167             "search for exposures by time (<)", NULL);
    168     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_tag",  0,
    169             "search by exp_tag", NULL);
    170     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_type",  0,
    171             "search by exp_type", NULL);
    172     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-filelevel",  0,
    173             "search by filelevel", NULL);
    174     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-reduction",  0,
    175             "search by reduction class", NULL);
    176     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-filter",  0,
    177             "search for filter", NULL);
    178     psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-airmass_min",  0,
    179             "define min airmass", NAN);
    180     psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-airmass_max",  0,
    181             "define max airmass", NAN);
    182     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-ra_min",  0,
    183             "define min", NAN);
    184     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-ra_max",  0,
    185             "define max", NAN);
    186     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-decl_min",  0,
    187             "define min", NAN);
    188     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-decl_max",  0,
    189             "define max", NAN);
    190     psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-exp_time_min",  0,
    191             "define min", NAN);
    192     psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-exp_time_max",  0,
    193             "define max", NAN);
    194     psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-sat_pixel_frac_min",  0,
    195             "define max fraction of saturated pixels", NAN);
    196     psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-sat_pixel_frac_max",  0,
    197             "define min fraction of saturated pixels", NAN);
    198     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_min",  0,
    199             "define max", NAN);
    200     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_max",  0,
    201             "define max", NAN);
    202     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_stdev_min",  0,
    203             "define max", NAN);
    204     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_stdev_max",  0,
    205             "define max", NAN);
    206     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_mean_stdev_min",  0,
    207             "define max", NAN);
    208     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_mean_stdev_max",  0,
    209             "define max", NAN);
    210     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-alt_min",  0,
    211             "define min", NAN);
    212     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-alt_max",  0,
    213             "define max", NAN);
    214     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-az_min",  0,
    215             "define min", NAN);
    216     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-az_max",  0,
    217             "define max", NAN);
    218     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-ccd_temp_min",  0,
    219             "define min ccd tempature", NAN);
    220     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-ccd_temp_max",  0,
    221             "define max ccd tempature", NAN);
    222     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-posang_min",  0,
    223             "define min rotator position angle", NAN);
    224     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-posang_max",  0,
    225             "define max rotator position angle", NAN);
    226     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-object",  0,
    227             "search by exposure object", NULL);
    228     psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-solang_min",  0,
    229             "define min solar angle", NAN);
    230     psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-solang_max",  0,
    231             "define max solar angle", NAN);
    232 
    233     psMetadataAddBool(updaterunArgs, PS_LIST_TAIL, "-all",  0,
    234             "allow everything to be queued without search terms", false);
    235     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,
    236             "set state", NULL);
    237     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label", 0,
    238             "set label", NULL);
    239 
     106    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-cam_id",             0, "search by cam_id", 0);
     107    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-chip_id",            0, "search by chip_id", 0);
     108    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-exp_id",             0, "search by exp_id", 0);
     109    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_name",           0, "search by exp_name", NULL);
     110    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-inst",               0, "search for camera", NULL);
     111    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-telescope",          0, "search for telescope", NULL);
     112    psMetadataAddTime(updaterunArgs, PS_LIST_TAIL, "-dateobs_begin",     0, "search for exposures by time (>=)", NULL);
     113    psMetadataAddTime(updaterunArgs, PS_LIST_TAIL, "-dateobs_end",       0, "search for exposures by time (<)", NULL);
     114    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_tag",            0, "search by exp_tag", NULL);
     115    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_type",           0, "search by exp_type", NULL);
     116    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-filelevel",          0, "search by filelevel", NULL);
     117    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-reduction",          0, "search by reduction class", NULL);
     118    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-filter",             0, "search for filter", NULL);
     119    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-airmass_min",        0, "define min airmass", NAN);
     120    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-airmass_max",        0, "define max airmass", NAN);
     121    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-ra_min",             0, "define min", NAN);
     122    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-ra_max",             0, "define max", NAN);
     123    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-decl_min",           0, "define min", NAN);
     124    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-decl_max",           0, "define max", NAN);
     125    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-exp_time_min",       0, "define min", NAN);
     126    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-exp_time_max",       0, "define max", NAN);
     127    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-sat_pixel_frac_min", 0, "define max fraction of saturated pixels", NAN);
     128    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-sat_pixel_frac_max", 0, "define min fraction of saturated pixels", NAN);
     129    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_min",             0, "define max", NAN);
     130    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_max",             0, "define max", NAN);
     131    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_stdev_min",       0, "define max", NAN);
     132    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_stdev_max",       0, "define max", NAN);
     133    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_mean_stdev_min",  0, "define max", NAN);
     134    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_mean_stdev_max",  0, "define max", NAN);
     135    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-alt_min",            0, "define min", NAN);
     136    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-alt_max",            0, "define max", NAN);
     137    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-az_min",             0, "define min", NAN);
     138    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-az_max",             0, "define max", NAN);
     139    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-ccd_temp_min",       0, "define min ccd tempature", NAN);
     140    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-ccd_temp_max",       0, "define max ccd tempature", NAN);
     141    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-posang_min",         0, "define min rotator position angle", NAN);
     142    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-posang_max",         0, "define max rotator position angle", NAN);
     143    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-object",             0, "search by exposure object", NULL);
     144    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-solang_min",         0, "define min solar angle", NAN);
     145    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-solang_max",         0, "define max solar angle", NAN);
     146
     147    psMetadataAddBool(updaterunArgs, PS_LIST_TAIL, "-all",               0, "allow everything to be queued without search terms", false);
     148    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state",              0, "set state", NULL);
     149    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label",              0, "set label", NULL);
    240150
    241151    // -pendingexp
    242152    psMetadata *pendingexpArgs = psMetadataAlloc();
    243     psMetadataAddS64(pendingexpArgs, PS_LIST_TAIL, "-cam_id", 0,
    244             "search by camtool ID", 0);
    245     psMetadataAddS64(pendingexpArgs, PS_LIST_TAIL, "-chip_id", 0,
    246             "search by chiptool ID", 0);
    247     psMetadataAddU64(pendingexpArgs, PS_LIST_TAIL, "-limit",  0,
    248             "limit result set to N items", 0);
    249     psMetadataAddBool(pendingexpArgs, PS_LIST_TAIL, "-simple", 0,
    250             "use the simple output format", false);
    251 
     153    psMetadataAddS64(pendingexpArgs, PS_LIST_TAIL, "-cam_id",            0, "search by camtool ID", 0);
     154    psMetadataAddS64(pendingexpArgs, PS_LIST_TAIL, "-chip_id",           0, "search by chiptool ID", 0);
     155    psMetadataAddU64(pendingexpArgs, PS_LIST_TAIL, "-limit",             0, "limit result set to N items", 0);
     156    psMetadataAddBool(pendingexpArgs, PS_LIST_TAIL, "-simple",           0, "use the simple output format", false);
    252157
    253158    // -pendingimfile
    254159    psMetadata *pendingimfileArgs = psMetadataAlloc();
    255     psMetadataAddS64(pendingimfileArgs, PS_LIST_TAIL, "-cam_id", 0,
    256             "search by camtool ID", 0);
    257     psMetadataAddS64(pendingimfileArgs, PS_LIST_TAIL, "-chip_id", 0,
    258             "search by chiptool ID", 0);
    259     psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-class", 0,
    260             "search by class", NULL);
    261     psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-class_id", 0,
    262             "search by class ID", NULL);
    263     psMetadataAddBool(pendingimfileArgs, PS_LIST_TAIL, "-simple", 0,
    264             "use the simple output format", false);
    265 
     160    psMetadataAddS64(pendingimfileArgs, PS_LIST_TAIL, "-cam_id", 0,            "search by camtool ID", 0);
     161    psMetadataAddS64(pendingimfileArgs, PS_LIST_TAIL, "-chip_id", 0,            "search by chiptool ID", 0);
     162    psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-class", 0,            "search by class", NULL);
     163    psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-class_id", 0,            "search by class ID", NULL);
     164    psMetadataAddBool(pendingimfileArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
    266165
    267166    // -addprocessedexp
    268167    psMetadata *addprocessedexpArgs = psMetadataAlloc();
    269     psMetadataAddS64(addprocessedexpArgs, PS_LIST_TAIL, "-cam_id", 0,
    270             "define camtool ID (required)", 0);
    271     psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-uri", 0,
    272             "define URI (required)", NULL);
    273     psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-bg", 0,
    274             "define exposure background", NAN);
    275     psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-bg_stdev", 0,
    276             "define exposure background stdev", NAN);
    277     psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-bg_mean_stdev", 0,
    278             "define exposure background mean stdev", NAN);
    279     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-bias",  0,
    280             "define bias", NAN);
    281     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-bias_stdev",  0,
    282             "define bias stdev", NAN);
    283     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-fringe_0",  0,
    284             "define fringe term 0", NAN);
    285     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-fringe_1",  0,
    286             "define fringe term 1", NAN);
    287     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-fringe_2",  0,
    288             "define fringe term 2", NAN);
    289     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-sigma_ra", 0,
    290             "define exposure E ra", NAN);
    291     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-sigma_dec", 0,
    292             "define exposure E dec", NAN);
    293     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-ap_resid",  0,
    294             "define aperture residual", NAN);
    295     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-ap_resid_stdev",  0,
    296             "define aperture residual stdev", NAN);
    297     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-zp_mean", 0,
    298             "define zero point mean", NAN);
    299     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-zp_stdev", 0,
    300             "define zero point stdev", NAN);
    301     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-fwhm_major", 0,
    302             "define FWHM (major axis; arcsec)", NAN);
    303     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-fwhm_minor", 0,
    304             "define FWHM (minor axis; arcsec)", NAN);
    305     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-dtime_detrend", 0,
    306             "define elapsed detrend processing time (seconds)", NAN);
    307     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-dtime_photom", 0,
    308             "define elapsed photometry processing time (seconds)", NAN);
    309     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-dtime_astrom", 0,
    310             "define elapsed astrometry processing time (seconds)", NAN);
    311     psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-hostname", 0,
    312             "define hostname", NULL);
    313     psMetadataAddS32(addprocessedexpArgs, PS_LIST_TAIL, "-n_stars", 0,
    314             "define number of stars", 0);
    315     psMetadataAddS32(addprocessedexpArgs, PS_LIST_TAIL, "-n_extended", 0,
    316             "define number of extended objects", 0);
    317     psMetadataAddS32(addprocessedexpArgs, PS_LIST_TAIL, "-n_cr", 0,
    318             "define number of cosmic rays", 0);
    319     psMetadataAddS32(addprocessedexpArgs, PS_LIST_TAIL, "-n_astrom", 0,
    320             "define number of astrometry reference objects", 0);
    321     psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-path_base", 0,
    322             "define base output location", NULL);
    323     psMetadataAddS16(addprocessedexpArgs, PS_LIST_TAIL, "-code",  0,
    324             "set fault code", 0);
    325     psMetadataAddBool(addprocessedexpArgs, PS_LIST_TAIL, "-faulted",  0,
    326             "only return imfiles with a fault status set", false);
     168    psMetadataAddS64(addprocessedexpArgs, PS_LIST_TAIL, "-cam_id", 0,            "define camtool ID (required)", 0);
     169    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-uri", 0,            "define URI (required)", NULL);
     170    psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-bg", 0,            "define exposure background", NAN);
     171    psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-bg_stdev", 0,            "define exposure background stdev", NAN);
     172    psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-bg_mean_stdev", 0,            "define exposure background mean stdev", NAN);
     173    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-bias",  0,            "define bias", NAN);
     174    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-bias_stdev",  0,            "define bias stdev", NAN);
     175    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-fringe_0",  0,            "define fringe term 0", NAN);
     176    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-fringe_1",  0,            "define fringe term 1", NAN);
     177    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-fringe_2",  0,            "define fringe term 2", NAN);
     178    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-sigma_ra", 0,            "define exposure E ra", NAN);
     179    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-sigma_dec", 0,            "define exposure E dec", NAN);
     180    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-ap_resid",  0,            "define aperture residual", NAN);
     181    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-ap_resid_stdev",  0,            "define aperture residual stdev", NAN);
     182    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-zp_mean", 0,            "define zero point mean", NAN);
     183    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-zp_stdev", 0,            "define zero point stdev", NAN);
     184    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-fwhm_major", 0,            "define FWHM (major axis; arcsec)", NAN);
     185    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-fwhm_minor", 0,            "define FWHM (minor axis; arcsec)", NAN);
     186    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-dtime_detrend", 0,            "define elapsed detrend processing time (seconds)", NAN);
     187    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-dtime_photom", 0,            "define elapsed photometry processing time (seconds)", NAN);
     188    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-dtime_astrom", 0,            "define elapsed astrometry processing time (seconds)", NAN);
     189    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-hostname", 0,            "define hostname", NULL);
     190    psMetadataAddS32(addprocessedexpArgs, PS_LIST_TAIL, "-n_stars", 0,            "define number of stars", 0);
     191    psMetadataAddS32(addprocessedexpArgs, PS_LIST_TAIL, "-n_extended", 0,            "define number of extended objects", 0);
     192    psMetadataAddS32(addprocessedexpArgs, PS_LIST_TAIL, "-n_cr", 0,            "define number of cosmic rays", 0);
     193    psMetadataAddS32(addprocessedexpArgs, PS_LIST_TAIL, "-n_astrom", 0,            "define number of astrometry reference objects", 0);
     194    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-path_base", 0,            "define base output location", NULL);
     195    psMetadataAddS16(addprocessedexpArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
     196    psMetadataAddBool(addprocessedexpArgs, PS_LIST_TAIL, "-faulted",  0,            "only return imfiles with a fault status set", false);
    327197
    328198    // -processedexp
    329199    psMetadata *processedexpArgs = psMetadataAlloc();
    330     psMetadataAddS64(processedexpArgs, PS_LIST_TAIL, "-cam_id", 0,
    331             "search by camtool ID", 0);
    332     psMetadataAddS64(processedexpArgs, PS_LIST_TAIL, "-chip_id", 0,
    333             "search by chiptool ID", 0);
    334     psMetadataAddU64(processedexpArgs, PS_LIST_TAIL, "-limit",  0,
    335             "limit result set to N items", 0);
    336     psMetadataAddBool(processedexpArgs, PS_LIST_TAIL, "-simple", 0,
    337             "use the simple output format", false);
    338     psMetadataAddBool(processedexpArgs, PS_LIST_TAIL, "-faulted",  0,
    339             "only return imfiles with a fault status set", false);
     200    psMetadataAddS64(processedexpArgs, PS_LIST_TAIL, "-cam_id", 0,            "search by camtool ID", 0);
     201    psMetadataAddS64(processedexpArgs, PS_LIST_TAIL, "-chip_id", 0,            "search by chiptool ID", 0);
     202    psMetadataAddU64(processedexpArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     203    psMetadataAddBool(processedexpArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
     204    psMetadataAddBool(processedexpArgs, PS_LIST_TAIL, "-faulted",  0,            "only return imfiles with a fault status set", false);
    340205
    341206    // -revertprocessedexp
     207    // XXX need to allow multiple cam_ids
     208    // XXX need to allow multiple chip_ids
     209    // XXX need to allow multiple exp_ids
    342210    psMetadata *revertprocessedexpArgs = psMetadataAlloc();
    343     // XXX need to allow multiple cam_ids
    344     psMetadataAddS64(revertprocessedexpArgs, PS_LIST_TAIL, "-cam_id",  0,
    345             "search by cam_id", 0);
    346     // XXX need to allow multiple chip_ids
    347     psMetadataAddS64(revertprocessedexpArgs, PS_LIST_TAIL, "-chip_id",  0,
    348             "search by chip_id", 0);
    349     // XXX need to allow multiple exp_ids
    350     psMetadataAddS64(revertprocessedexpArgs, PS_LIST_TAIL, "-exp_id",  0,
    351             "search by exp_id", 0);
    352     psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-exp_name",  0,
    353             "search by exp_name", NULL);
    354     psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-inst",  0,
    355             "search for camera", NULL);
    356     psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-telescope",  0,
    357             "search for telescope", NULL);
    358     psMetadataAddTime(revertprocessedexpArgs, PS_LIST_TAIL, "-dateobs_begin", 0,
    359             "search for exposures by time (>=)", NULL);
    360     psMetadataAddTime(revertprocessedexpArgs, PS_LIST_TAIL, "-dateobs_end", 0,
    361             "search for exposures by time (<)", NULL);
    362     psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-exp_tag",  0,
    363             "search by exp_tag", NULL);
    364     psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-exp_type",  0,
    365             "search by exp_type", NULL);
    366     psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-filelevel",  0,
    367             "search by filelevel", NULL);
    368     psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-reduction",  0,
    369             "search by reduction class", NULL);
    370     psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-filter",  0,
    371             "search for filter", NULL);
    372     psMetadataAddF32(revertprocessedexpArgs, PS_LIST_TAIL, "-airmass_min",  0,
    373             "define min airmass", NAN);
    374     psMetadataAddF32(revertprocessedexpArgs, PS_LIST_TAIL, "-airmass_max",  0,
    375             "define max airmass", NAN);
    376     psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-ra_min",  0,
    377             "define min", NAN);
    378     psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-ra_max",  0,
    379             "define max", NAN);
    380     psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-decl_min",  0,
    381             "define min", NAN);
    382     psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-decl_max",  0,
    383             "define max", NAN);
    384     psMetadataAddF32(revertprocessedexpArgs, PS_LIST_TAIL, "-exp_time_min",  0,
    385             "define min", NAN);
    386     psMetadataAddF32(revertprocessedexpArgs, PS_LIST_TAIL, "-exp_time_max",  0,
    387             "define max", NAN);
    388     psMetadataAddF32(revertprocessedexpArgs, PS_LIST_TAIL, "-sat_pixel_frac_min",  0,
    389             "define max fraction of saturated pixels", NAN);
    390     psMetadataAddF32(revertprocessedexpArgs, PS_LIST_TAIL, "-sat_pixel_frac_max",  0,
    391             "define min fraction of saturated pixels", NAN);
    392     psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-bg_min",  0,
    393             "define max", NAN);
    394     psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-bg_max",  0,
    395             "define max", NAN);
    396     psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-bg_stdev_min",  0,
    397             "define max", NAN);
    398     psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-bg_stdev_max",  0,
    399             "define max", NAN);
    400     psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-bg_mean_stdev_min",  0,
    401             "define max", NAN);
    402     psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-bg_mean_stdev_max",  0,
    403             "define max", NAN);
    404     psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-alt_min",  0,
    405             "define min", NAN);
    406     psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-alt_max",  0,
    407             "define max", NAN);
    408     psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-az_min",  0,
    409             "define min", NAN);
    410     psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-az_max",  0,
    411             "define max", NAN);
    412     psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-ccd_temp_min",  0,
    413             "define min ccd tempature", NAN);
    414     psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-ccd_temp_max",  0,
    415             "define max ccd tempature", NAN);
    416     psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-posang_min",  0,
    417             "define min rotator position angle", NAN);
    418     psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-posang_max",  0,
    419             "define max rotator position angle", NAN);
    420     psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-object",  0,
    421             "search by exposure object", NULL);
    422     psMetadataAddF32(revertprocessedexpArgs, PS_LIST_TAIL, "-solang_min",  0,
    423             "define min solar angle", NAN);
    424     psMetadataAddF32(revertprocessedexpArgs, PS_LIST_TAIL, "-solang_max",  0,
    425             "define max solar angle", NAN);
    426 
    427     psMetadataAddBool(revertprocessedexpArgs, PS_LIST_TAIL, "-all",  0,
    428             "allow everything to be queued without search terms", false);
    429     psMetadataAddS16(revertprocessedexpArgs, PS_LIST_TAIL, "-code",  0,
    430             "search by fault code", 0);
     211    psMetadataAddS64(revertprocessedexpArgs, PS_LIST_TAIL, "-cam_id",  0,            "search by cam_id", 0);
     212    psMetadataAddS64(revertprocessedexpArgs, PS_LIST_TAIL, "-chip_id",  0,            "search by chip_id", 0);
     213    psMetadataAddS64(revertprocessedexpArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exp_id", 0);
     214    psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-exp_name",  0,            "search by exp_name", NULL);
     215    psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-inst",  0,            "search for camera", NULL);
     216    psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-telescope",  0,            "search for telescope", NULL);
     217    psMetadataAddTime(revertprocessedexpArgs, PS_LIST_TAIL, "-dateobs_begin", 0,            "search for exposures by time (>=)", NULL);
     218    psMetadataAddTime(revertprocessedexpArgs, PS_LIST_TAIL, "-dateobs_end", 0,            "search for exposures by time (<)", NULL);
     219    psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-exp_tag",  0,            "search by exp_tag", NULL);
     220    psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-exp_type",  0,            "search by exp_type", NULL);
     221    psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-filelevel",  0,            "search by filelevel", NULL);
     222    psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-reduction",  0,            "search by reduction class", NULL);
     223    psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-filter",  0,            "search for filter", NULL);
     224    psMetadataAddF32(revertprocessedexpArgs, PS_LIST_TAIL, "-airmass_min",  0,            "define min airmass", NAN);
     225    psMetadataAddF32(revertprocessedexpArgs, PS_LIST_TAIL, "-airmass_max",  0,            "define max airmass", NAN);
     226    psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-ra_min",  0,            "define min", NAN);
     227    psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-ra_max",  0,            "define max", NAN);
     228    psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-decl_min",  0,            "define min", NAN);
     229    psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-decl_max",  0,            "define max", NAN);
     230    psMetadataAddF32(revertprocessedexpArgs, PS_LIST_TAIL, "-exp_time_min",  0,            "define min", NAN);
     231    psMetadataAddF32(revertprocessedexpArgs, PS_LIST_TAIL, "-exp_time_max",  0,            "define max", NAN);
     232    psMetadataAddF32(revertprocessedexpArgs, PS_LIST_TAIL, "-sat_pixel_frac_min",  0,            "define max fraction of saturated pixels", NAN);
     233    psMetadataAddF32(revertprocessedexpArgs, PS_LIST_TAIL, "-sat_pixel_frac_max",  0,            "define min fraction of saturated pixels", NAN);
     234    psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-bg_min",  0,            "define max", NAN);
     235    psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-bg_max",  0,            "define max", NAN);
     236    psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-bg_stdev_min",  0,            "define max", NAN);
     237    psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-bg_stdev_max",  0,            "define max", NAN);
     238    psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-bg_mean_stdev_min",  0,            "define max", NAN);
     239    psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-bg_mean_stdev_max",  0,            "define max", NAN);
     240    psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-alt_min",  0,            "define min", NAN);
     241    psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-alt_max",  0,            "define max", NAN);
     242    psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-az_min",  0,            "define min", NAN);
     243    psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-az_max",  0,            "define max", NAN);
     244    psMetadataAddF32(revertprocessedexpArgs, PS_LIST_TAIL, "-ccd_temp_min",  0,            "define min ccd tempature", NAN);
     245    psMetadataAddF32(revertprocessedexpArgs, PS_LIST_TAIL, "-ccd_temp_max",  0,            "define max ccd tempature", NAN);
     246    psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-posang_min",  0,            "define min rotator position angle", NAN);
     247    psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-posang_max",  0,            "define max rotator position angle", NAN);
     248    psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-object",  0,            "search by exposure object", NULL);
     249    psMetadataAddF32(revertprocessedexpArgs, PS_LIST_TAIL, "-solang_min",  0,            "define min solar angle", NAN);
     250    psMetadataAddF32(revertprocessedexpArgs, PS_LIST_TAIL, "-solang_max",  0,            "define max solar angle", NAN);
     251
     252    psMetadataAddBool(revertprocessedexpArgs, PS_LIST_TAIL, "-all",  0,            "allow everything to be queued without search terms", false);
     253    psMetadataAddS16(revertprocessedexpArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
    431254
    432255
    433256    // -updateprocessedexp
    434257    psMetadata *updateprocessedexpArgs = psMetadataAlloc();
    435     psMetadataAddS64(updateprocessedexpArgs, PS_LIST_TAIL, "-cam_id", 0,
    436             "search by camtool ID", 0);
    437     psMetadataAddS64(updateprocessedexpArgs, PS_LIST_TAIL, "-chip_id",  0,
    438             "search by chiptool ID", 0);
    439     psMetadataAddStr(updateprocessedexpArgs, PS_LIST_TAIL, "-class",  0,
    440             "search by class", NULL);
    441     psMetadataAddStr(updateprocessedexpArgs, PS_LIST_TAIL, "-class_id",  0,
    442             "search by class ID", NULL);
    443     psMetadataAddS16(updateprocessedexpArgs, PS_LIST_TAIL, "-code",  0,
    444             "set fault code (required)", INT16_MAX);
     258    psMetadataAddS64(updateprocessedexpArgs, PS_LIST_TAIL, "-cam_id", 0,            "search by camtool ID", 0);
     259    psMetadataAddS64(updateprocessedexpArgs, PS_LIST_TAIL, "-chip_id",  0,            "search by chiptool ID", 0);
     260    psMetadataAddStr(updateprocessedexpArgs, PS_LIST_TAIL, "-class",  0,            "search by class", NULL);
     261    psMetadataAddStr(updateprocessedexpArgs, PS_LIST_TAIL, "-class_id",  0,            "search by class ID", NULL);
     262    psMetadataAddS16(updateprocessedexpArgs, PS_LIST_TAIL, "-code",  0,            "set fault code (required)", INT16_MAX);
    445263
    446264    // -block
    447265    psMetadata *blockArgs = psMetadataAlloc();
    448     psMetadataAddStr(blockArgs, PS_LIST_TAIL, "-label",  0,
    449             "name of a label to mask out (required)", NULL);
     266    psMetadataAddStr(blockArgs, PS_LIST_TAIL, "-label",  0,            "name of a label to mask out (required)", NULL);
    450267
    451268    // -masked
    452269    psMetadata *maskedArgs = psMetadataAlloc();
    453     psMetadataAddBool(maskedArgs, PS_LIST_TAIL, "-simple",  0,
    454             "use the simple output format", false);
     270    psMetadataAddBool(maskedArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    455271
    456272    // -unblock
    457273    psMetadata *unblockArgs = psMetadataAlloc();
    458     psMetadataAddStr(unblockArgs, PS_LIST_TAIL, "-label",  0,
    459             "name of a label to unmask (required)", NULL);
     274    psMetadataAddStr(unblockArgs, PS_LIST_TAIL, "-label",  0,            "name of a label to unmask (required)", NULL);
    460275
    461276    psMetadata *argSets = psMetadataAlloc();
    … …  
    485300    psFree(modes);
    486301
    487     // setup search criterion
    488 #define addWhereStr(name) \
    489 { \
    490     psString str = NULL; \
    491     bool status = false; \
    492     if ((str = psMetadataLookupStr(&status, config->args, "-" #name))) { \
    493         if (!psMetadataAddStr(config->where, PS_LIST_TAIL, #name, 0, "==", str)) {\
    494             psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
    495             psFree(config); \
    496             return NULL; \
    497         } \
    498     } \
    499 }
    500 
    501302    // generate SQL where clause
    502     config->where = psMetadataAlloc();
    503 
    504 {
    505     psS64 cam_id = -1;
    506     bool status = false;
    507     if ((cam_id = psMetadataLookupS64(&status, config->args, "-cam_id"))) {
    508         if (!psMetadataAddS64(config->where, PS_LIST_TAIL, "cam_id", 0, "==", cam_id)) {
    509             psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id");
    510             psFree(config);
    511             return NULL;
    512         }
    513     }
    514 }
    515 
    516 {
    517     psString str = NULL;
    518     bool status = false;
    519     if ((str = psMetadataLookupStr(&status, config->args, "-chip_id"))) {
    520         if (!psMetadataAddS64(config->where, PS_LIST_TAIL, "chip_id", 0, "==", (psS64)atoll(str))) {
    521             psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id");
    522             psFree(config);
    523             return NULL;
    524         }
    525     }
    526 }
    527 
    528     // convert '-inst' to 'camera'
    529     {
    530         psString str = NULL;
    531         bool status = false;
    532         if ((str = psMetadataLookupStr(&status, config->args, "-inst"))) {
    533             if (!psMetadataAddStr(config->where, PS_LIST_TAIL, "camera", 0, "==", str)) {
    534                 psError(PS_ERR_UNKNOWN, false, "failed to add item camera");
    535                 psFree(config);
    536                 return NULL;
    537             }
    538         }
    539     }
    540     addWhereStr(telescope);
    541     addWhereStr(exp_type);
    542     {
    543         int imfiles = 0;
    544         bool status = false;
    545         if ((imfiles = psMetadataLookupS32(&status, config->args, "-imfiles"))) {
    546             if (!psMetadataAddS32(config->where, PS_LIST_TAIL, "imfiles", 0, "==", imfiles)) {
    547                 psError(PS_ERR_UNKNOWN, false, "failed to add item imfiles");
    548                 psFree(config);
    549                 return NULL;
    550             }
    551         }
    552     }
    553     addWhereStr(class_id);
    554     addWhereStr(filter);
    555 
    556     // convert '-code' to 'fault'
    557     {
    558         psS16 fault = 0;
    559         bool status = false;
    560         if ((fault = psMetadataLookupS16(&status, config->args, "-code"))) {
    561             if (!psMetadataAddS16(config->where, PS_LIST_TAIL, "fault", 0, "==", fault)) {
    562                 psError(PS_ERR_UNKNOWN, false, "failed to add item fault");
    563                 psFree(config);
    564                 return NULL;
    565             }
    566         }
    567     }
    568 
    569     if (psListLength(config->where->list) < 1) {
    570         psFree(config->where);
    571         config->where = NULL;
    572     }
     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 }
    573317
    574318

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

    r18366 r18468  
    304304    psMetadata *modes = psMetadataAlloc();
    305305
    306     PXOPT_ADD_MODE("-definebyquery",        "create runs from raw exposures",
    307         CHIPTOOL_MODE_DEFINEBYQUERY,        definebyqueryArgs);
    308     PXOPT_ADD_MODE("-updaterun",            "change chip run properties",
    309         CHIPTOOL_MODE_UPDATERUN,            updaterunArgs);
    310     PXOPT_ADD_MODE("-pendingimfile",        "show pending imfiles",
    311         CHIPTOOL_MODE_PENDINGIMFILE,        pendingimfileArgs);
    312     PXOPT_ADD_MODE("-addprocessedimfile",   "add a processed imfile",
    313         CHIPTOOL_MODE_ADDPROCESSEDIMFILE,   addprocessedimfileArgs);
    314     PXOPT_ADD_MODE("-processedimfile",      "show processed imfiles",
    315         CHIPTOOL_MODE_PROCESSEDIMFILE,      processedimfileArgs);
    316     PXOPT_ADD_MODE("-updateprocessedimfile","change procesed imfile properties",
    317         CHIPTOOL_MODE_UPDATEPROCESSEDIMFILE,updateprocessedimfileArgs);
    318     PXOPT_ADD_MODE("-revertprocessedimfile","undo a processed imfile",
    319         CHIPTOOL_MODE_REVERTPROCESSEDIMFILE,revertprocessedimfileArgs);
    320     PXOPT_ADD_MODE("-block",                "set a label block",
    321         CHIPTOOL_MODE_BLOCK,                blockArgs);
    322     PXOPT_ADD_MODE("-masked",               "show blocked labels",
    323         CHIPTOOL_MODE_MASKED,               maskedArgs);
    324     PXOPT_ADD_MODE("-unmasked",             "",
    325         CHIPTOOL_MODE_UNMASKED,             unmaskedArgs);
    326     PXOPT_ADD_MODE("-unblock",              "remove a label block",
    327         CHIPTOOL_MODE_UNBLOCK,              unblockArgs);
    328     PXOPT_ADD_MODE("-pendingcleanuprun",    "show runs that need to be cleaned up",
    329         CHIPTOOL_MODE_PENDINGCLEANUPRUN,    pendingcleanuprunArgs);
    330     PXOPT_ADD_MODE("-pendingcleanupimfile", "show runs that need to be cleaned up",
    331         CHIPTOOL_MODE_PENDINGCLEANUPIMFILE, pendingcleanupimfileArgs);
    332     PXOPT_ADD_MODE("-donecleanup",          "show runs that have been cleaned",
    333         CHIPTOOL_MODE_DONECLEANUP,          donecleanupArgs);
    334     PXOPT_ADD_MODE("-run",                  "show runs",
    335         CHIPTOOL_MODE_RUN,                  runArgs);
     306    PXOPT_ADD_MODE("-definebyquery",        "create runs from raw exposures",       CHIPTOOL_MODE_DEFINEBYQUERY,        definebyqueryArgs);
     307    PXOPT_ADD_MODE("-updaterun",            "change chip run properties",           CHIPTOOL_MODE_UPDATERUN,            updaterunArgs);
     308    PXOPT_ADD_MODE("-pendingimfile",        "show pending imfiles",                 CHIPTOOL_MODE_PENDINGIMFILE,        pendingimfileArgs);
     309    PXOPT_ADD_MODE("-addprocessedimfile",   "add a processed imfile",               CHIPTOOL_MODE_ADDPROCESSEDIMFILE,   addprocessedimfileArgs);
     310    PXOPT_ADD_MODE("-processedimfile",      "show processed imfiles",               CHIPTOOL_MODE_PROCESSEDIMFILE,      processedimfileArgs);
     311    PXOPT_ADD_MODE("-updateprocessedimfile","change procesed imfile properties",    CHIPTOOL_MODE_UPDATEPROCESSEDIMFILE,updateprocessedimfileArgs);
     312    PXOPT_ADD_MODE("-revertprocessedimfile","undo a processed imfile",              CHIPTOOL_MODE_REVERTPROCESSEDIMFILE,revertprocessedimfileArgs);
     313    PXOPT_ADD_MODE("-block",                "set a label block",                    CHIPTOOL_MODE_BLOCK,                blockArgs);
     314    PXOPT_ADD_MODE("-masked",               "show blocked labels",                  CHIPTOOL_MODE_MASKED,               maskedArgs);
     315    PXOPT_ADD_MODE("-unmasked",             "",                                     CHIPTOOL_MODE_UNMASKED,             unmaskedArgs);
     316    PXOPT_ADD_MODE("-unblock",              "remove a label block",                 CHIPTOOL_MODE_UNBLOCK,              unblockArgs);
     317    PXOPT_ADD_MODE("-pendingcleanuprun",    "show runs that need to be cleaned up", CHIPTOOL_MODE_PENDINGCLEANUPRUN,    pendingcleanuprunArgs);
     318    PXOPT_ADD_MODE("-pendingcleanupimfile", "show runs that need to be cleaned up", CHIPTOOL_MODE_PENDINGCLEANUPIMFILE, pendingcleanupimfileArgs);
     319    PXOPT_ADD_MODE("-donecleanup",          "show runs that have been cleaned",     CHIPTOOL_MODE_DONECLEANUP,          donecleanupArgs);
     320    PXOPT_ADD_MODE("-run",                  "show runs",                            CHIPTOOL_MODE_RUN,                  runArgs);
    336321
    337322    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {

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

    r16170 r18468  
    8181
    8282    psMetadata *where = psMetadataAlloc();
     83
     84    PXOPT_COPY_STR(config->args, where, "-inst",      "camera", "==");
     85    PXOPT_COPY_STR(config->args, where, "-telescope", "telescope", "==");
     86    PXOPT_COPY_STR(config->args, where, "-det_type",  "det_type", "==");
     87    PXOPT_COPY_STR(config->args, where, "-type",      "det_type", "==");
     88    PXOPT_COPY_STR(config->args, where, "-filter",    "filter", "==");
    8389
    8490    // airmass_min  < airmass  < airmass_max
    … …  
    111117    }
    112118
    113     if (config->where) {
    114         psString whereClause = psDBGenerateWhereConditionSQL(config->where, NULL);
    115         psStringAppend(&query, " AND %s", whereClause);
    116         psFree(whereClause);
    117     }
    118 
    119     {
     119    // use psDBGenerateWhereConditionalSQL with AND ... because the SQL ends in a WHERE
     120    if (where && psListLength(where->list)) {
    120121        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    121         psFree(where);
    122         if (whereClause) {
    123             psStringAppend(&query, " AND %s", whereClause);
    124             psFree(whereClause);
    125         }
    126     }
     122        psStringAppend(&query, " AND %s", whereClause);
     123        psFree(whereClause);
     124    }
     125    psFree(where);
    127126
    128127    // we choose the single detrend image which matches all criteria and has
    … …  
    171170    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    172171
     172    psMetadata *where = psMetadataAlloc();
     173    PXOPT_COPY_STR(config->args, where, "-det_id",    "det_id", "==");
     174    PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
     175    PXOPT_COPY_STR(config->args, where, "-class_id",  "class_id", "==");
     176
    173177    psString query = pxDataGet("detselect_select.sql");
    174178    if (!query) {
    … …  
    177181    }
    178182
    179 
    180     if (config->where) {
    181         psString whereClause = psDBGenerateWhereConditionSQL(config->where, NULL);
     183    // use psDBGenerateWhereConditionalSQL with AND ... because the SQL ends in a WHERE
     184    if (where && psListLength(where->list)) {
     185        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    182186        psStringAppend(&query, " AND %s", whereClause);
    183187        psFree(whereClause);
    184188    }
     189    psFree(where);
    185190
    186191    if (!p_psDBRunQuery(config->dbh, query)) {

  • branches/eam_branch_20080706/ippTools/src/detselect.h

    r18322 r18468  
    3131pxConfig *detselectConfig(pxConfig *config, int argc, char **argv);
    3232
    33 #define addWhereStr(name) \
    34 { \
    35     psString str = NULL; \
    36     bool status = false; \
    37     if ((str = psMetadataLookupStr(&status, config->args, "-" #name))) { \
    38         if (!psMetadataAddStr(config->where, PS_LIST_TAIL, #name, 0, "==", str)) {\
    39             psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
    40             psFree(config); \
    41             return NULL; \
    42         } \
    43     } \
    44 }
    45 
    46 #define addWhereStrAlias(name,realname) \
    47 { \
    48     psString str = NULL; \
    49     bool status = false; \
    50     if ((str = psMetadataLookupStr(&status, config->args, "-" #name))) { \
    51         if (!psMetadataAddStr(config->where, PS_LIST_TAIL, #realname, 0, "==", str)) {\
    52             psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
    53             psFree(config); \
    54             return NULL; \
    55         } \
    56     } \
    57 }
    58 
    59 #define addWhereS32(name) \
    60 { \
    61     psS32 s32 = 0; \
    62     bool status = false; \
    63     if ((s32= psMetadataLookupS32(&status, config->args, "-" #name))) { \
    64         if (!psMetadataAddS32(config->where, PS_LIST_TAIL, #name, 0, "==", s32)) { \
    65             psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
    66             psFree(config); \
    67             return NULL; \
    68         } \
    69     } \
    70 }
    71 
    72 #define addWhereF32(name) \
    73 { \
    74     psF32 var = 0; \
    75     bool status = false; \
    76     if ((var = psMetadataLookupF32(&status, config->args, "-" #name))) { \
    77         if (!isnan(var)) { \
    78             if (!psMetadataAddF32(config->where, PS_LIST_TAIL, #name, 0, "==", var)) { \
    79                 psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
    80                 psFree(config); \
    81                 return NULL; \
    82             } \
    83         } \
    84     } \
    85 }
    86 
    87 #define addWhereF64(name) \
    88 { \
    89     psF64 var = 0; \
    90     bool status = false; \
    91     if ((var = psMetadataLookupF64(&status, config->args, "-" #name))) { \
    92         if (!isnan(var))  { \
    93             if (!psMetadataAddF64(config->where, PS_LIST_TAIL, #name, 0, "==", var)) { \
    94                 psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
    95                 psFree(config); \
    96                 return NULL; \
    97             } \
    98         } \
    99     } \
    100 }
    101 
    102 #define addWhereTimeStr(name) \
    103 { \
    104     psString str = NULL; \
    105     bool status = false; \
    106     if ((str = psMetadataLookupStr(&status, config->args, "-" #name))) { \
    107         psTime *time = psTimeFromISO(str, PS_TIME_UTC); \
    108         if (!time) { \
    109             psError(PS_ERR_UNKNOWN, false, "failed to convert " #name " into a psTime object"); \
    110             psFree(config); \
    111             return NULL; \
    112         } \
    113         psMetadataItem *item = psMetadataLookup(config->args, "-" #name); \
    114         if (item) { \
    115             str = item->comment; \
    116         } else { \
    117             str = NULL; \
    118         } \
    119         if (!psMetadataAddTime(config->where, PS_LIST_TAIL, #name, 0, str, time)) {\
    120             psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
    121             psFree(config); \
    122             return NULL; \
    123         } \
    124         psFree(time); \
    125     } \
    126 }
    127 
    12833#endif // DETSELECT_H

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

    r18322 r18468  
    4646    // -search
    4747    psMetadata *searchArgs = psMetadataAlloc();
    48     psMetadataAddStr(searchArgs, PS_LIST_TAIL, "-inst", 0,
    49                      "search by camera", NULL);
    50     psMetadataAddStr(searchArgs, PS_LIST_TAIL, "-telescope", 0,
    51                      "search by telescope", NULL);
    52     psMetadataAddStr(searchArgs, PS_LIST_TAIL, "-det_type", 0,
    53                      "search by detrend type", NULL);
    54     psMetadataAddStr(searchArgs, PS_LIST_TAIL, "-type", 0,
    55                      "search by detrend type (alias for -det_type)", NULL);
    56     psMetadataAddStr(searchArgs, PS_LIST_TAIL, "-filter", 0,
    57                      "search by filter", NULL);
    58     psMetadataAddF32(searchArgs, PS_LIST_TAIL, "-airmass", 0,
    59                      "define airmass", NAN);
    60     psMetadataAddF32(searchArgs, PS_LIST_TAIL, "-exp_time", 0,
    61                      "search by exposure time", NAN);
    62     psMetadataAddF32(searchArgs, PS_LIST_TAIL, "-ccd_temp", 0,
    63                      "search by ccd tempature", NAN);
    64     psMetadataAddF64(searchArgs, PS_LIST_TAIL, "-posang", 0,
    65                      "search by rotator position angle", NAN);
    66     psMetadataAddTime(searchArgs, PS_LIST_TAIL, "-time", 0,
    67                       "define time for desired detrend data", NULL);
    68     psMetadataAddBool(searchArgs, PS_LIST_TAIL, "-simple",  0,
    69                       "use the simple output format", false);
    70     psMetadataAddBool(searchArgs, PS_LIST_TAIL, "-unlimit",  0,
    71                       "list all possible detruns, not just the best match", false);
     48    psMetadataAddStr(searchArgs, PS_LIST_TAIL, "-inst", 0,                     "search by camera", NULL);
     49    psMetadataAddStr(searchArgs, PS_LIST_TAIL, "-telescope", 0,                     "search by telescope", NULL);
     50    psMetadataAddStr(searchArgs, PS_LIST_TAIL, "-det_type", 0,                     "search by detrend type", NULL);
     51    psMetadataAddStr(searchArgs, PS_LIST_TAIL, "-type", 0,                     "search by detrend type (alias for -det_type)", NULL);
     52    psMetadataAddStr(searchArgs, PS_LIST_TAIL, "-filter", 0,                     "search by filter", NULL);
     53    psMetadataAddF32(searchArgs, PS_LIST_TAIL, "-airmass", 0,                     "define airmass", NAN);
     54    psMetadataAddF32(searchArgs, PS_LIST_TAIL, "-exp_time", 0,                     "search by exposure time", NAN);
     55    psMetadataAddF32(searchArgs, PS_LIST_TAIL, "-ccd_temp", 0,                     "search by ccd tempature", NAN);
     56    psMetadataAddF64(searchArgs, PS_LIST_TAIL, "-posang", 0,                     "search by rotator position angle", NAN);
     57    psMetadataAddTime(searchArgs, PS_LIST_TAIL, "-time", 0,                      "define time for desired detrend data", NULL);
     58    psMetadataAddBool(searchArgs, PS_LIST_TAIL, "-simple",  0,                      "use the simple output format", false);
     59    psMetadataAddBool(searchArgs, PS_LIST_TAIL, "-unlimit",  0,                      "list all possible detruns, not just the best match", false);
    7260 
    7361    // -select
    7462    psMetadata *selectArgs = psMetadataAlloc();
    75     psMetadataAddStr(selectArgs, PS_LIST_TAIL, "-det_id", 0,
    76                      "search by detrend ID", NULL);
    77     psMetadataAddS32(selectArgs, PS_LIST_TAIL, "-iteration", 0,
    78                      "search by iteration number", 0);
    79     psMetadataAddStr(selectArgs, PS_LIST_TAIL, "-class_id", 0,
    80                      "search by class ID", NULL);
    81     psMetadataAddBool(selectArgs, PS_LIST_TAIL, "-simple",  0,
    82                       "use the simple output format", false);
     63    psMetadataAddStr(selectArgs, PS_LIST_TAIL, "-det_id", 0,                     "search by detrend ID", NULL);
     64    psMetadataAddS32(selectArgs, PS_LIST_TAIL, "-iteration", 0,                     "search by iteration number", 0);
     65    psMetadataAddStr(selectArgs, PS_LIST_TAIL, "-class_id", 0,                     "search by class ID", NULL);
     66    psMetadataAddBool(selectArgs, PS_LIST_TAIL, "-simple",  0,                      "use the simple output format", false);
    8367   
    8468    psMetadata *argSets = psMetadataAlloc();
    … …  
    10185    // setup search criterion
    10286    // generate SQL where clause
    103     config->where = psMetadataAlloc();
     87    // config->where = psMetadataAlloc();
    10488
    105     addWhereStr(det_id);
    106     addWhereS32(iteration);
    107     addWhereStr(exp_id);
    108     addWhereStrAlias(inst,camera);
     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);
    109101
    110     addWhereStr(telescope);
    111     addWhereStr(det_type);
    112     addWhereStrAlias(type,det_type);
     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);
    113107
    114     addWhereStr(exp_type);
    115     addWhereS32(imfiles);
    116     addWhereStr(class);
    117     addWhereStr(class_id);
    118     addWhereStr(filter);
    119 
    120     //    addWhereF32(exp_time);
    121     //    addWhereF64(ccd_temp);
    122     //    addWhereF32(airmass);
    123     //    addWhereTimeStr(use_begin);
    124     //    addWhereTimeStr(use_end);
    125 
    126     if (config->where->list->n < 1) {
    127         psFree(config->where);
    128         config->where = NULL;
    129     }
     108    // if (config->where->list->n < 1) {
     109    //     psFree(config->where);
     110    //     config->where = NULL;
     111    // }
    130112
    131113

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

    r18336 r18468  
    214214    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    215215
    216     psString query = psStringCopy(
    217         "SELECT"
    218         "   rawExp.*"
    219         " FROM rawExp"
    220         " LEFT JOIN detInputExp"
    221         "   ON rawExp.exp_id = detInputExp.exp_id"
    222         " WHERE"
    223         "    detInputExp.exp_id IS NULL"
    224         "    AND rawExp.object != 'object'"
    225     );
    226 
    227     if (config->where) {
    228         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "rawExp");
     216    psString query = pxDataGet("dettool_pending.sql");
     217    if (!query) {
     218        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     219        return false;
     220    }
     221   
     222    psMetadata *where = psMetadataAlloc();
     223    PXOPT_COPY_STR(config->args, where, "-exp_id", "exp_id", "==");
     224    PXOPT_COPY_STR(config->args, where, "-exp_type", "exp_type", "==");
     225    PXOPT_COPY_STR(config->args, where, "-inst", "camera", "==");
     226    PXOPT_COPY_STR(config->args, where, "-telescope", "telescope", "==");
     227    PXOPT_COPY_STR(config->args, where, "-filter", "filter", "==");
     228
     229    if (psListLength(where->list)) {
     230        psString whereClause = psDBGenerateWhereConditionSQL(where, "rawExp");
    229231        psStringAppend(&query, " AND %s", whereClause);
    230232        psFree(whereClause);
    231233    }
     234    psFree(where);
    232235
    233236    if (!p_psDBRunQuery(config->dbh, query)) {
    … …  
    315318    // make sure that -exp_id was parsed correctly
    316319    // XXX this can be removed someday
     320    // XXX Special case for a multi : move into a macro?
    317321    if (item->type == PS_DATA_METADATA_MULTI) {
    318322        psListIterator *iter = psListIteratorAlloc(item->data.list, 0, false);
    … …  
    472476#if 0
    473477// This function is used to convert the det_id from an int, as it is used
    474 // internally, to be a string for external use.  The rational being that we may
     478// internally, to be a string for external use.  The rationale being that we may
    475479// want to change how det_id is generated in the future and don't want to
    476480// external programs to become depending on this value being an int.
    … …  
    543547    psMetadata *where = psMetadataAlloc();
    544548    PXOPT_COPY_STR(config->args, where, "-select_exp_type", "exp_type", "==");
    545     // map -inst -> camera
    546549    PXOPT_COPY_STR(config->args, where, "-select_inst", "camera", "==");
    547550    PXOPT_COPY_STR(config->args, where, "-select_telescope", "telescope", "==");
    … …  
    555558    PXOPT_COPY_F32(config->args, where, "-select_exp_time_min", "exp_time", ">=");
    556559    PXOPT_COPY_F32(config->args, where, "-select_exp_time_max", "exp_time", "<=");
    557     PXOPT_COPY_F32(config->args, where, "-select_ccd_temp_min", "ccd_temp", ">=");
    558     PXOPT_COPY_F32(config->args, where, "-select_ccd_temp_max", "ccd_temp", "<=");
    559     PXOPT_COPY_F32(config->args, where, "-select_pon_time_min", "pon_time", ">=");
    560     PXOPT_COPY_F32(config->args, where, "-select_pon_time_max", "pon_time", "<=");
    561     PXOPT_COPY_F32(config->args, where, "-select_posang_min", "posang", ">=");
    562     PXOPT_COPY_F32(config->args, where, "-select_posang_max", "posang", "<=");
    563     PXOPT_COPY_F32(config->args, where, "-select_solang_min", "solang", ">=");
    564     PXOPT_COPY_F32(config->args, where, "-select_solang_max", "solang", "<=");
     560    PXOPT_COPY_F64(config->args, where, "-select_ccd_temp_min", "ccd_temp", ">=");
     561    PXOPT_COPY_F64(config->args, where, "-select_ccd_temp_max", "ccd_temp", "<=");
     562    PXOPT_COPY_F64(config->args, where, "-select_pon_time_min", "pon_time", ">=");
     563    PXOPT_COPY_F64(config->args, where, "-select_pon_time_max", "pon_time", "<=");
     564    PXOPT_COPY_F64(config->args, where, "-select_posang_min", "posang", ">=");
     565    PXOPT_COPY_F64(config->args, where, "-select_posang_max", "posang", "<=");
     566    PXOPT_COPY_F64(config->args, where, "-select_solang_min", "solang", ">=");
     567    PXOPT_COPY_F64(config->args, where, "-select_solang_max", "solang", "<=");
    565568
    566569    if (!psListLength(where->list)) {
    … …  
    571574    // there is some namespace overlap between the names of the fields we'd
    572575    // like to search by to setup a detrun and the names of the fields we'd
    573     // like to assign values to so I've seperated them but prepending set- to
     576    // like to assign values to so I've separated them but prepending set- to
    574577    // the assigned values
    575578
    … …  
    731734    PS_ASSERT_PTR_NON_NULL(config, false);
    732735
    733     // required
    734     PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false);
    735 
    736     // optional
    737     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    738     PXOPT_LOOKUP_STR(det_type, config->args, "-set_det_type", false, false);
    739     PXOPT_LOOKUP_STR(mode, config->args, "-set_mode", false, false);
    740     // check mode
    741     if (mode && !isValidMode(config, mode)) {
    742         psError(PS_ERR_UNKNOWN, false, "invalud mode");
    743         return false;
    744     }
    745     PXOPT_LOOKUP_STR(camera, config->args, "-set_inst", false, false);
    746     PXOPT_LOOKUP_STR(telescope, config->args, "-set_telescope", false, false);
     736   
     737    PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false); // required
     738    PXOPT_LOOKUP_STR(det_type, config->args, "-set_det_type", false, false); // optional
     739    PXOPT_LOOKUP_STR(mode, config->args, "-set_mode", false, false); // optional
    747740    PXOPT_LOOKUP_STR(exp_type, config->args, "-set_exp_type", false, false);
    748741    PXOPT_LOOKUP_STR(filelevel, config->args, "-set_filelevel", false, false);
    749742    PXOPT_LOOKUP_STR(workdir, config->args, "-set_workdir", false, false);
    750743    PXOPT_LOOKUP_STR(filter, config->args, "-set_filter", false, false);
    751 
    752744    PXOPT_LOOKUP_F32(airmass_min, config->args, "-set_airmass_min", false, false);
    753745    PXOPT_LOOKUP_F32(airmass_max, config->args, "-set_airmass_max", false, false);
    754746    PXOPT_LOOKUP_F32(exp_time_min, config->args, "-set_exp_time_min", false, false);
    755747    PXOPT_LOOKUP_F32(exp_time_max, config->args, "-set_exp_time_max", false, false);
    756     PXOPT_LOOKUP_F32(ccd_temp_min, config->args, "-set_ccd_temp_min", false, false);
    757     PXOPT_LOOKUP_F32(ccd_temp_max, config->args, "-set_ccd_temp_max", false, false);
    758     PXOPT_LOOKUP_F32(posang_min, config->args, "-set_posang_min", false, false);
    759     PXOPT_LOOKUP_F32(posang_max, config->args, "-set_posang_max", false, false);
    760     PXOPT_LOOKUP_F32(solang_min, config->args, "-set_solang_min", false, false);
    761     PXOPT_LOOKUP_F32(solang_max, config->args, "-set_solang_max", false, false);
    762     PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
     748    PXOPT_LOOKUP_F64(ccd_temp_min, config->args, "-set_ccd_temp_min", false, false);
     749    PXOPT_LOOKUP_F64(ccd_temp_max, config->args, "-set_ccd_temp_max", false, false);
     750    PXOPT_LOOKUP_F64(posang_min, config->args, "-set_posang_min", false, false);
     751    PXOPT_LOOKUP_F64(posang_max, config->args, "-set_posang_max", false, false);
     752    PXOPT_LOOKUP_F64(solang_min, config->args, "-set_solang_min", false, false);
     753    PXOPT_LOOKUP_F64(solang_max, config->args, "-set_solang_max", false, false);
    763754    PXOPT_LOOKUP_TIME(registered, config->args, "-set_registered", false, false);
    764755    PXOPT_LOOKUP_TIME(time_begin, config->args, "-set_time_begin", false, false);
    … …  
    767758    PXOPT_LOOKUP_TIME(use_end, config->args, "-use_end", false, false);
    768759    PXOPT_LOOKUP_STR(reduction, config->args, "-set_reduction", false, false);
    769 
     760    PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
     761    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false); // optional
     762
     763    // check mode
     764    if (mode && !isValidMode(config, mode)) {
     765        psError(PS_ERR_UNKNOWN, false, "invalud mode");
     766        return false;
     767    }
    770768
    771769    // lookup the detRun that we will be basing this one on
    … …  
    925923    // XXX: possible mem leak: PXOPT_COPY* will free time_filter but NOTHING
    926924    // that has previously been allocated
    927     PXOPT_COPY_TIME(config->args, time_filter, "-filter_input_begin", "dateobs", ">=");
    928     PXOPT_COPY_TIME(config->args, time_filter, "-filter_input_end", "dateobs", "<");
     925    PXOPT_COPY_TIME(config->args, time_filter, "-set_input_begin", "dateobs", ">=");
     926    PXOPT_COPY_TIME(config->args, time_filter, "-set_input_end", "dateobs", "<");
    929927
    930928    // start a transaction so we don't end up with childlessed det_ids
    … …  
    951949    psS64 newDet_id = psDBLastInsertID(config->dbh);
    952950
    953     psString query = psStringCopy(
    954         "INSERT INTO detInputExp"
    955         "   SELECT"
    956         "       %d,"
    957         "       0,"
    958         "       detResidExp.exp_id,"
    959         "       detResidExp.accept"
    960         "   FROM detResidExp"
    961         "   JOIN rawExp"
    962         "       USING(exp_id)"
    963         "   WHERE det_id = %d"
    964     );
     951    psString query = pxDataGet("dettool_definebydetrun.sql");
     952    if (!query) {
     953        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     954        return false;
     955    }
    965956
    966957    if (time_filter->list->n) {
    … …  
    10171008    PS_ASSERT_PTR_NON_NULL(config, false);
    10181009
     1010    psMetadata *where = psMetadataAlloc();
     1011    PXOPT_COPY_STR(config->args, where, "-det_type", "det_type", "==");
     1012    PXOPT_COPY_STR(config->args, where, "-det_id",   "det_id", "==");
     1013
     1014    PXOPT_COPY_STR(config->args, where, "-inst", "camera", "==");
     1015    PXOPT_COPY_STR(config->args, where, "-telescope", "telescope", "==");
     1016    PXOPT_COPY_STR(config->args, where, "-filter", "filter", "==");
     1017
     1018    // airmass_min  < airmass  < airmass_max
     1019    PXOPT_COPY_F32(config->args, where, "-airmass", "airmass_min", "<=");
     1020    PXOPT_COPY_F32(config->args, where, "-airmass", "airmass_max", ">=");
     1021
     1022    // exp_time_min < exp_time < exp_time_max
     1023    PXOPT_COPY_F32(config->args, where, "-exp_time", "exp_time_min", "<=");
     1024    PXOPT_COPY_F32(config->args, where, "-exp_time", "exp_time_max", ">=");
     1025
     1026    // ccd_temp_min < ccd_temp < ccd_temp_max
     1027    PXOPT_COPY_F32(config->args, where, "-ccd_temp", "ccd_temp_min", "<=");
     1028    PXOPT_COPY_F32(config->args, where, "-ccd_temp", "ccd_temp_max", ">=");
     1029
     1030    PXOPT_COPY_F64(config->args, where, "-posang", "posang_min", "<=");
     1031    PXOPT_COPY_F64(config->args, where, "-posang", "posang_max", ">=");
     1032
    10191033    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    10201034    PXOPT_LOOKUP_BOOL(active, config->args, "-active", false);
    10211035    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    10221036
    1023     PXOPT_COPY_STR(config->args, config->where, "-inst", "camera", "==");
    1024     PXOPT_COPY_STR(config->args, config->where, "-telescope", "telescope", "==");
    1025     PXOPT_COPY_STR(config->args, config->where, "-filter", "filter", "==");
    1026 
    1027     // airmass_min  < airmass  < airmass_max
    1028     PXOPT_COPY_F32(config->args, config->where, "-airmass", "airmass_min", "<=");
    1029     PXOPT_COPY_F32(config->args, config->where, "-airmass", "airmass_max", ">=");
    1030 
    1031     // exp_time_min < exp_time < exp_time_max
    1032     PXOPT_COPY_F32(config->args, config->where, "-exp_time", "exp_time_min", "<=");
    1033     PXOPT_COPY_F32(config->args, config->where, "-exp_time", "exp_time_max", ">=");
    1034 
    1035     // ccd_temp_min < ccd_temp < ccd_temp_max
    1036     PXOPT_COPY_F32(config->args, config->where, "-ccd_temp", "ccd_temp_min", "<=");
    1037     PXOPT_COPY_F32(config->args, config->where, "-ccd_temp", "ccd_temp_max", ">=");
    1038 
    1039     PXOPT_COPY_F64(config->args, config->where, "-posang", "posang_min", "<=");
    1040     PXOPT_COPY_F64(config->args, config->where, "-posang", "posang_max", ">=");
    1041 
    10421037    psString query = pxDataGet("dettool_runs.sql");
    10431038    if (!query) {
    … …  
    10461041    }
    10471042
    1048     if (config->where && active) {
    1049         psString whereClause = psDBGenerateWhereSQL(config->where, "detRun");
     1043    if (psListLength(where->list) && active) {
     1044        psString whereClause = psDBGenerateWhereSQL(where, "detRun");
    10501045        psStringAppend(&query, " %s AND (detRun.state = 'run' OR detRun.state = 'stop' OR detRun.state = 'register')", whereClause);
    10511046        psFree(whereClause);
    10521047    }
    1053     if (config->where && !active) {
    1054         psString whereClause = psDBGenerateWhereSQL(config->where, "detRun");
     1048    if (psListLength(where->list) && !active) {
     1049        psString whereClause = psDBGenerateWhereSQL(where, "detRun");
    10551050        psStringAppend(&query, " %s", whereClause);
    10561051        psFree(whereClause);
    10571052    }
    1058     if (!config->where && active) {
     1053    if (!psListLength(where->list) && active) {
    10591054        psStringAppend(&query, " WHERE (detRun.state = 'run' OR detRun.state = 'stop' OR detRun.state = 'register')");
    10601055    }
     1056    psFree (where);
    10611057
    10621058    // treat limit == 0 as "no limit"
    … …  
    10801076    }
    10811077
    1082 // XXX old version
    1083 # if 0
    1084     // XXX fix the hard coding of the table name
    1085     psArray *runs = psDBSelectRows(config->dbh, "detRun", config->where, 0);
    1086     if (!runs) {
    1087         psError(PS_ERR_UNKNOWN, false, "database error");
    1088         return false;
    1089     }
    1090 # endif
    1091 
    10921078    if (!psArrayLength(runs)) {
    10931079        psTrace("dettool", PS_LOG_INFO, "no rows found");
    … …  
    11121098    PS_ASSERT_PTR_NON_NULL(config, false);
    11131099
     1100    psMetadata *where = psMetadataAlloc();
     1101    PXOPT_COPY_STR(config->args, where, "-det_type", "det_type", "==");
     1102
    11141103    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    11151104    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    11161105
    1117     psString query = psStringCopy(
    1118             "SELECT DISTINCT\n"
    1119             "   detRun.*\n"
    1120             " FROM detRun\n"
    1121             " LEFT JOIN detRun as foo\n"
    1122             "   ON foo.parent = detRun.det_id\n"
    1123             " WHERE\n"
    1124             "   detRun.state = 'stop'\n"
    1125             "   AND detRun.mode = 'master'\n"
    1126             "   AND foo.det_id IS NULL\n"
    1127         );
    1128 
    1129     if (config->where) {
    1130         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "detRun");
     1106    // find the exp_id of all the exposures that we want to queue up.
     1107    psString query = pxDataGet("dettool_childlessrun.sql");
     1108    if (!query) {
     1109        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1110        psFree(where);
     1111        return false;
     1112    }
     1113
     1114    if (psListLength(where->list)) {
     1115        psString whereClause = psDBGenerateWhereConditionSQL(where, "detRun");
    11311116        psStringAppend(&query, " AND %s", whereClause);
    11321117        psFree(whereClause);
    11331118    }
     1119    psFree (where);
    11341120
    11351121    // treat limit == 0 as "no limit"
    … …  
    11881174    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    11891175
    1190     // select detInputExp.*
    1191     // select rawExp.*
    1192     // by:
    1193     // exp_id
    1194 
    1195     psString query = psStringCopy(
    1196         "SELECT DISTINCT *"
    1197         " FROM detInputExp"
    1198         " JOIN rawExp"
    1199         " USING(exp_id)"
    1200         );
    1201 
    1202     if (config->where) {
    1203         psString whereClause = psDBGenerateWhereSQL(config->where, "detInputExp");
     1176    psMetadata *where = psMetadataAlloc();
     1177    PXOPT_COPY_STR(config->args, where, "-det_id",    "det_id", "==");
     1178    PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
     1179    PXOPT_COPY_S64(config->args, where, "-exp_id",    "exp_id", "==");
     1180
     1181    psString query = pxDataGet("dettool_input.sql");
     1182    if (!query) {
     1183        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1184        psFree(where);
     1185        return false;
     1186    }
     1187
     1188    if (psListLength(where->list)) {
     1189        psString whereClause = psDBGenerateWhereSQL(where, "detInputExp");
    12041190        psStringAppend(&query, " %s", whereClause);
    12051191        psFree(whereClause);
    12061192    }
     1193    psFree (where);
    12071194
    12081195    if (!p_psDBRunQuery(config->dbh, query)) {
    … …  
    12421229    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    12431230
     1231    psMetadata *where = psMetadataAlloc();
     1232
    12441233    psString query = pxDataGet("dettool_raw.sql");
    12451234    if (!query) {
    … …  
    12481237    }
    12491238
    1250     if (config->where) {
    1251         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "rawImfile");
     1239    if (psListLength(where->list)) {
     1240        psString whereClause = psDBGenerateWhereConditionSQL(where, "rawImfile");
    12521241        psStringAppend(&query, " AND %s", whereClause);
    12531242        psFree(whereClause);
    12541243    }
     1244    psFree (where);
    12551245
    12561246    if (!p_psDBRunQuery(config->dbh, query)) {
    … …  
    12881278    PS_ASSERT_PTR_NON_NULL(config, false);
    12891279
     1280    psMetadata *where = psMetadataAlloc();
     1281    PXOPT_COPY_STR(config->args, where, "-det_id",   "det_id", "==");
     1282    PXOPT_COPY_STR(config->args, where, "-exp_id",   "exp_id", "==");
     1283    PXOPT_COPY_STR(config->args, where, "-class_id", "class_id", "==");
     1284
    12901285    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    12911286    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    … …  
    12971292    }
    12981293
    1299     if (config->where) {
    1300         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "rawImfile");
     1294    if (psListLength(where->list)) {
     1295        psString whereClause = psDBGenerateWhereConditionSQL(where, "rawImfile");
    13011296        psStringAppend(&query, " AND %s", whereClause);
    13021297        psFree(whereClause);
    13031298    }
     1299    psFree (where);
    13041300
    13051301    // treat limit == 0 as "no limit"
    … …  
    13401336}
    13411337
    1342 static psArray *searchRawImfiles(pxConfig *config, psMetadata *where)
    1343 {
    1344     PS_ASSERT_PTR_NON_NULL(config, NULL);
    1345 
    1346     // use the default where if "where" is NULL
    1347     if (!where) {
    1348         where = config->where;
    1349     }
    1350 
    1351     // select exp_ids from detInputExp matching det_idp
    1352     // where query should be pre-generated
    1353     psArray *detInputExp =
    1354         detInputExpSelectRowObjects(config->dbh, where, 0);
    1355     if (!detInputExp) {
    1356         psError(PS_ERR_UNKNOWN, false, "no rawExp rows found");
    1357         return NULL;
    1358     }
    1359 
    1360     // generate where query with just the exp_ids
    1361     psMetadata *where_exp_ids = psMetadataAlloc();
    1362     for (long i = 0; i < psArrayLength(detInputExp); i++) {
    1363         detInputExpRow *row = detInputExp->data[i];
    1364         if (!psMetadataAddS64(where_exp_ids, PS_LIST_TAIL, "exp_id",
    1365                 PS_META_DUPLICATE_OK, "==", row->exp_id)
    1366         ) {
    1367             psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    1368             psFree(detInputExp);
    1369             psFree(where_exp_ids);
    1370             return NULL;
    1371         }
    1372     }
    1373     psFree(detInputExp);
    1374 
    1375     // select rawImfiles with matching exp_ids
    1376     psArray *rawImfiles =
    1377         rawImfileSelectRowObjects(config->dbh, where_exp_ids, 0);
    1378     psFree(where_exp_ids);
    1379     if (!rawImfiles) {
    1380         psError(PS_ERR_UNKNOWN, false, "no rawImfile rows found");
    1381         return NULL;
    1382     }
    1383 
    1384     return rawImfiles;
    1385 }
    1386 
    13871338static bool addprocessedimfileMode(pxConfig *config)
    13881339{
    13891340    PS_ASSERT_PTR_NON_NULL(config, false);
    13901341
    1391     // det_id, exp_id, class_id, uri, recipe, -bg, -bg_stdev
    1392     // are required
     1342    // det_id, exp_id, class_id, uri, recipe, -bg, -bg_stdev are required
    13931343    PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false);
    13941344    PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", true, false);
    … …  
    14161366    PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", false, false);
    14171367
    1418 
    14191368    // find the matching rawImfile by exp_id/class_id
    14201369    psMetadata *where = psMetadataAlloc();
    1421     if (!psMetadataAddStr(where, PS_LIST_TAIL, "exp_id", 0, "==", exp_id)) {
    1422         psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    1423         psFree(where);
    1424         return false;
    1425     }
    1426     if (!psMetadataAddStr(where, PS_LIST_TAIL, "class_id", 0, "==", class_id)) {
    1427         psError(PS_ERR_UNKNOWN, false, "failed to add item class_id");
    1428         psFree(where);
    1429         return false;
    1430     }
     1370    PXOPT_COPY_STR(config->args, where, "-exp_id",   "exp_id", "==");
     1371    PXOPT_COPY_STR(config->args, where, "-class_id", "class_id", "==");
    14311372
    14321373    psArray *rawImfiles = rawImfileSelectRowObjects(config->dbh, where, 0);
    14331374    psFree(where);
     1375
    14341376    if (!rawImfiles) {
    14351377        psError(PS_ERR_UNKNOWN, false, "no rawImfile rows found ");
    14361378        return false;
    14371379    }
    1438 
    14391380
    14401381    // create a new detProcessedImfile object
    … …  
    14731414}
    14741415
     1416static bool processedimfileMode(pxConfig *config)
     1417{
     1418    PS_ASSERT_PTR_NON_NULL(config, false);
     1419
     1420    char *value = NULL;
     1421
     1422    PXOPT_LOOKUP_BOOL(included, config->args, "-included", false);
     1423    PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
     1424    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1425    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1426
     1427    psMetadata *where = psMetadataAlloc();
     1428    PXOPT_COPY_STR(config->args, where, "-det_id", "det_id", "==");
     1429    PXOPT_COPY_STR(config->args, where, "-exp_id", "exp_id", "==");
     1430    PXOPT_COPY_STR(config->args, where, "-class_id", "class_id", "==");
     1431
     1432    psString query = pxDataGet("dettool_processedimfile.sql");
     1433    if (!query) {
     1434        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1435        psFree(where);
     1436        return false;
     1437    }
     1438
     1439    // add the two required restrictions: detRun.state and detRun.mode
     1440    // NOTE the above query requires one of the following two WHERE statements
     1441    {
     1442        bool status;
     1443        if ((value = psMetadataLookupStr(&status, config->args, "-select_state"))) {
     1444            psStringAppend(&query, " WHERE detRun.state = '%s'", value);
     1445        } else {
     1446            psStringAppend(&query, " WHERE detRun.state = 'run'");
     1447        }
     1448        if ((value = psMetadataLookupStr(&status, config->args, "-select_mode"))) {
     1449            psStringAppend(&query, " AND detRun.mode = '%s'", value);
     1450        } else {
     1451            psStringAppend(&query, " AND detRun.mode = 'master'");
     1452        }
     1453    }
     1454
     1455    if (psListLength(where->list)) {
     1456        psString whereClause = psDBGenerateWhereConditionSQL(where, "detProcessedImfile");
     1457        psStringAppend(&query, " AND %s", whereClause);
     1458        psFree(whereClause);
     1459    }
     1460    psFree (where);
     1461
     1462    // restrict search to included imfiles
     1463    if (included) {
     1464        psStringAppend(&query, " AND detInputExp.include = 1");
     1465    }
     1466
     1467    if (faulted) {
     1468        // list only faulted rows
     1469        psStringAppend(&query, " %s", "AND detProcessedImfile.fault != 0");
     1470    } else {
     1471        // don't list faulted rows
     1472        psStringAppend(&query, " %s", "AND detProcessedImfile.fault = 0");
     1473    }
     1474
     1475    // treat limit == 0 as "no limit"
     1476    if (limit) {
     1477        psString limitString = psDBGenerateLimitSQL(limit);
     1478        psStringAppend(&query, " %s", limitString);
     1479        psFree(limitString);
     1480    }
     1481
     1482    if (!p_psDBRunQuery(config->dbh, query)) {
     1483        psError(PS_ERR_UNKNOWN, false, "database error");
     1484        psFree(query);
     1485        return false;
     1486    }
     1487    psFree(query);
     1488
     1489    psArray *output = p_psDBFetchResult(config->dbh);
     1490    if (!output) {
     1491        psError(PS_ERR_UNKNOWN, false, "database error");
     1492        return false;
     1493    }
     1494    if (!psArrayLength(output)) {
     1495        psTrace("dettool", PS_LOG_INFO, "no rows found");
     1496        psFree(output);
     1497        return true;
     1498    }
     1499
     1500    // negative simple so the default is true
     1501    if (!ippdbPrintMetadatas(stdout, output, "rawImfile", !simple)) {
     1502        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1503        psFree(output);
     1504        return false;
     1505    }
     1506
     1507    psFree(output);
     1508
     1509    return true;
     1510}
     1511
     1512static bool revertprocessedimfileMode(pxConfig *config)
     1513{
     1514    PS_ASSERT_PTR_NON_NULL(config, false);
     1515
     1516    psMetadata *where = psMetadataAlloc();
     1517    PXOPT_COPY_STR(config->args, where, "-det_id", "det_id", "==");
     1518    PXOPT_COPY_STR(config->args, where, "-exp_id", "exp_id", "==");
     1519    PXOPT_COPY_STR(config->args, where, "-class_id", "class_id", "==");
     1520    PXOPT_COPY_S16(config->args, where, "-code", "fault", "==");
     1521
     1522    psString query = pxDataGet("dettool_revertprocessedimfile.sql");
     1523    if (!query) {
     1524        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1525        return false;
     1526    }
     1527
     1528    if (psListLength(where->list)) {
     1529        psString whereClause = psDBGenerateWhereConditionSQL(where, "detProcessedImfile");
     1530        psStringAppend(&query, " AND %s", whereClause);
     1531        psFree(whereClause);
     1532    }
     1533    psFree(where);
     1534
     1535    if (!p_psDBRunQuery(config->dbh, query)) {
     1536        psError(PS_ERR_UNKNOWN, false, "database error");
     1537        psFree(query);
     1538        return false;
     1539    }
     1540    psFree(query);
     1541
     1542    if (psDBAffectedRows(config->dbh) < 1) {
     1543        psError(PS_ERR_UNKNOWN, false, "should have affected atleast 1 row");
     1544        return false;
     1545    }
     1546
     1547    return true;
     1548}
     1549
    14751550static bool toprocessedexpMode(pxConfig *config)
    14761551{
    … …  
    14851560        return false;
    14861561    }
    1487 
    1488     // XXX does it make sense to accept any search params?
    1489 #if 0
    1490     if (config->where) {
    1491         psString whereClause = psDBGenerateWhereConditionSQL(config->where);
    1492         psStringAppend(&query, " AND %s", whereClause);
    1493         psFree(whereClause);
    1494     }
    1495 #endif
    14961562
    14971563    // treat limit == 0 as "no limit"
    … …  
    15611627    PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", true, false);
    15621628
    1563 
    1564     psString query = psStringCopy(
    1565         " SELECT DISTINCT"
    1566         "    detProcessedImfile.det_id,"
    1567         "    detRun.iteration,"
    1568         "    detRun.det_type,"
    1569         "    detProcessedImfile.exp_id"
    1570         " FROM detRun"
    1571         " JOIN detInputExp"
    1572         "    ON detRun.det_id = detInputExp.det_id"
    1573         "    AND detRun.iteration = detInputExp.iteration"
    1574         " JOIN rawExp"
    1575         "    ON detInputExp.exp_id = rawExp.exp_id"
    1576         " JOIN detProcessedImfile"
    1577         "    ON detInputExp.det_id = detProcessedImfile.det_id"
    1578         "    AND detInputExp.exp_id = detProcessedImfile.exp_id"
    1579         " LEFT JOIN detProcessedExp"
    1580         "    ON detInputExp.det_id = detProcessedExp.det_id"
    1581         "    AND detProcessedImfile.exp_id= detProcessedExp.exp_id"
    1582         " LEFT JOIN rawImfile"
    1583         "    ON detInputExp.exp_id = rawImfile.exp_id"
    1584         "    AND detProcessedImfile.class_id = rawImfile.class_id"
    1585         " WHERE"
    1586         "   detRun.state = 'run'"
    1587         "   AND detRun.mode = 'master'"
    1588         "   AND detProcessedExp.det_id IS NULL"
    1589         "   AND detProcessedExp.exp_id IS NULL"
    1590         "   AND detInputExp.include = 1"
    1591         "   AND detRun.det_id = %s"
    1592         "   AND detProcessedImfile.exp_id = '%s'"
    1593         " GROUP BY"
    1594         "    detProcessedImfile.class_id,"
    1595         "    rawImfile.class_id,"
    1596         "    detRun.det_id"
    1597         " HAVING"
    1598         "    COUNT(detProcessedImfile.class_id) = COUNT(rawImfile.class_id)"
    1599         );
     1629    psString query = pxDataGet("dettool_addprocessedexp.sql");
     1630    if (!query) {
     1631        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1632        psFree(where);
     1633        return false;
     1634    }
    16001635
    16011636    if (!p_psDBRunQuery(config->dbh, query, det_id, exp_id)) {
    … …  
    16541689    PS_ASSERT_PTR_NON_NULL(config, false);
    16551690
     1691    psMetadata *where = psMetadataAlloc();
     1692    PXOPT_COPY_STR(config->args, where, "-det_id", "det_id", "==");
     1693    PXOPT_COPY_STR(config->args, where, "-exp_id", "exp_id", "==");
     1694
    16561695    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1696    PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    16571697    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    1658     PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    16591698
    16601699    psString query = psStringCopy("SELECT * FROM detProcessedExp");
    16611700
    1662     if (config->where) {
    1663         psString whereClause = psDBGenerateWhereSQL(config->where, NULL);
     1701    if (psListLength(where->list)) {
     1702        psString whereClause = psDBGenerateWhereSQL(where, NULL);
    16641703        psStringAppend(&query, " %s", whereClause);
    16651704        psFree(whereClause);
    16661705    }
     1706    psFree(where);
    16671707
    16681708    if (faulted) {
    … …  
    17161756    PS_ASSERT_PTR_NON_NULL(config, false);
    17171757
     1758    psMetadata *where = psMetadataAlloc();
     1759    PXOPT_COPY_STR(config->args, where, "-det_id", "det_id", "==");
     1760    PXOPT_COPY_STR(config->args, where, "-exp_id", "exp_id", "==");
     1761    PXOPT_COPY_S16(config->args, where, "-code",   "fault", "==");
     1762
    17181763    psString query = pxDataGet("dettool_revertprocessedexp.sql");
    17191764    if (!query) {
    … …  
    17221767    }
    17231768
    1724     if (config->where) {
    1725         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "detProcessedExp");
     1769    if (psListLength(where->list)) {
     1770        psString whereClause = psDBGenerateWhereConditionSQL(where, "detProcessedExp");
    17261771        psStringAppend(&query, " AND %s", whereClause);
    17271772        psFree(whereClause);
    17281773    }
     1774    psFree(where);
    17291775
    17301776    if (!p_psDBRunQuery(config->dbh, query)) {
    … …  
    17561802        return false;
    17571803    }
    1758 
    1759     // XXX does it make sense to accept any search params?
    1760 #if 0
    1761     if (config->where) {
    1762         psString whereClause = psDBGenerateWhereConditionSQL(config->where);
    1763         psStringAppend(&query, " AND %s", whereClause);
    1764         psFree(whereClause);
    1765     }
    1766 #endif
    17671804
    17681805    // treat limit == 0 as "no limit"
    … …  
    18031840}
    18041841
    1805 static bool processedimfileMode(pxConfig *config)
    1806 {
    1807     PS_ASSERT_PTR_NON_NULL(config, false);
    1808 
    1809     char *value = NULL;
    1810 
    1811     PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    1812     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    1813     PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    1814 
    1815     psString query = psStringCopy(
    1816         " SELECT DISTINCT"
    1817         "   detRun.det_type,"
    1818         "   rawExp.exp_time,"
    1819         "   detProcessedImfile.*"
    1820         " FROM detProcessedImfile"
    1821         " JOIN detRun"
    1822         "   USING(det_id)"
    1823         " JOIN detInputExp"
    1824         "   ON detRun.det_id = detInputExp.det_id"
    1825         "   AND detRun.iteration = detInputExp.iteration"
    1826         "   AND detProcessedImfile.exp_id = detInputExp.exp_id"
    1827         " JOIN rawExp"
    1828         "   ON rawExp.exp_id = detProcessedImfile.exp_id"
    1829         " WHERE"
    1830     );
    1831     // NOTE the above WHERE is completed with the following line:
    1832 
    1833     // add the two required restrictions: detRun.state and detRun.mode
    1834     {
    1835         bool status;
    1836         if ((value = psMetadataLookupStr(&status, config->args, "-select_state"))) {
    1837             psStringAppend(&query, " detRun.state = '%s'", value);
    1838         } else {
    1839             psStringAppend(&query, " detRun.state = 'run'");
     1842// this is NOT a command-line mode : it is used by 'addstackedMode'
     1843static psArray *searchRawImfiles(pxConfig *config, psMetadata *where)
     1844{
     1845    PS_ASSERT_PTR_NON_NULL(config, NULL);
     1846
     1847    psMetadata *where = psMetadataAlloc();
     1848    PXOPT_COPY_STR(config->args, where, "-det_id",    "det_id", "==");
     1849    PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
     1850
     1851    // select exp_ids from detInputExp matching det_id & iteration
     1852    // where query should be pre-generated
     1853    psArray *detInputExp = detInputExpSelectRowObjects(config->dbh, where, 0);
     1854    psFree (where);
     1855
     1856    if (!detInputExp) {
     1857        psError(PS_ERR_UNKNOWN, false, "no rawExp rows found");
     1858        return NULL;
     1859    }
     1860
     1861    // generate where query with just the exp_ids
     1862    psMetadata *where_exp_ids = psMetadataAlloc();
     1863    for (long i = 0; i < psArrayLength(detInputExp); i++) {
     1864        detInputExpRow *row = detInputExp->data[i];
     1865        if (!psMetadataAddS64(where_exp_ids, PS_LIST_TAIL, "exp_id",
     1866                PS_META_DUPLICATE_OK, "==", row->exp_id)
     1867        ) {
     1868            psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
     1869            psFree(detInputExp);
     1870            psFree(where_exp_ids);
     1871            return NULL;
    18401872        }
    1841         if ((value = psMetadataLookupStr(&status, config->args, "-select_mode"))) {
    1842             psStringAppend(&query, " AND detRun.mode = '%s'", value);
    1843         } else {
    1844             psStringAppend(&query, " AND detRun.mode = 'master'");
    1845         }
    1846     }
    1847 
    1848     if (config->where) {
    1849         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "detProcessedImfile");
    1850         psStringAppend(&query, " AND %s", whereClause);
    1851         psFree(whereClause);
    1852     }
    1853 
    1854     {
    1855         bool status = false;
    1856         bool included = psMetadataLookupBool(&status, config->args, "-included");
    1857         if (!status) {
    1858             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    1859             return false;
    1860         }
    1861         // restrict search to included imfiles
    1862         if (included) {
    1863             psStringAppend(&query, " AND detInputExp.include = 1");
    1864         }
    1865     }
    1866 
    1867     if (faulted) {
    1868         // list only faulted rows
    1869         psStringAppend(&query, " %s", "AND detProcessedImfile.fault != 0");
    1870     } else {
    1871         // don't list faulted rows
    1872         psStringAppend(&query, " %s", "AND detProcessedImfile.fault = 0");
    1873     }
    1874 
    1875     // treat limit == 0 as "no limit"
    1876     if (limit) {
    1877         psString limitString = psDBGenerateLimitSQL(limit);
    1878         psStringAppend(&query, " %s", limitString);
    1879         psFree(limitString);
    1880     }
    1881 
    1882     if (!p_psDBRunQuery(config->dbh, query)) {
    1883         psError(PS_ERR_UNKNOWN, false, "database error");
    1884         psFree(query);
    1885         return false;
    1886     }
    1887     psFree(query);
    1888 
    1889     psArray *output = p_psDBFetchResult(config->dbh);
    1890     if (!output) {
    1891         psError(PS_ERR_UNKNOWN, false, "database error");
    1892         return false;
    1893     }
    1894     if (!psArrayLength(output)) {
    1895         psTrace("dettool", PS_LOG_INFO, "no rows found");
    1896         psFree(output);
    1897         return true;
    1898     }
    1899 
    1900     // negative simple so the default is true
    1901     if (!ippdbPrintMetadatas(stdout, output, "rawImfile", !simple)) {
    1902         psError(PS_ERR_UNKNOWN, false, "failed to print array");
    1903         psFree(output);
    1904         return false;
    1905     }
    1906 
    1907     psFree(output);
    1908 
    1909     return true;
    1910 }
    1911 
    1912 
    1913 static bool revertprocessedimfileMode(pxConfig *config)
    1914 {
    1915     PS_ASSERT_PTR_NON_NULL(config, false);
    1916 
    1917     psString query = pxDataGet("dettool_revertprocessedimfile.sql");
    1918     if (!query) {
    1919         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    1920         return false;
    1921     }
    1922 
    1923     if (config->where) {
    1924         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "detProcessedImfile");
    1925         psStringAppend(&query, " AND %s", whereClause);
    1926         psFree(whereClause);
    1927     }
    1928 
    1929     if (!p_psDBRunQuery(config->dbh, query)) {
    1930         psError(PS_ERR_UNKNOWN, false, "database error");
    1931         psFree(query);
    1932         return false;
    1933     }
    1934     psFree(query);
    1935 
    1936     if (psDBAffectedRows(config->dbh) < 1) {
    1937         psError(PS_ERR_UNKNOWN, false, "should have affected atleast 1 row");
    1938         return false;
    1939     }
    1940 
    1941     return true;
    1942 }
    1943 
     1873    }
     1874    psFree(detInputExp);
     1875
     1876    // select rawImfiles with matching exp_ids
     1877    psArray *rawImfiles =
     1878        rawImfileSelectRowObjects(config->dbh, where_exp_ids, 0);
     1879    psFree(where_exp_ids);
     1880    if (!rawImfiles) {
     1881        psError(PS_ERR_UNKNOWN, false, "no rawImfile rows found");
     1882        return NULL;
     1883    }
     1884
     1885    return rawImfiles;
     1886}
    19441887
    19451888static bool addstackedMode(pxConfig *config)
    … …  
    19471890    PS_ASSERT_PTR_NON_NULL(config, false);
    19481891
    1949     // det_id, class_id, uri, & recipe are required
     1892    // det_id, iteration, class_id, uri, & recipe are required
    19501893    PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false);
     1894    PXOPT_LOOKUP_S32(iteration, config->args, "-iteration", true, false);
    19511895    PXOPT_LOOKUP_STR(class_id, config->args, "-class_id", true, false);
    19521896
    … …  
    19671911    PXOPT_LOOKUP_F64(user_5, config->args, "-user_5", false, false);
    19681912
    1969     // default values
    1970     PXOPT_LOOKUP_S32(iteration, config->args, "-iteration", false, false);
    1971 
    19721913    // correlate the class_id against the input exposure(s)
    1973 
    1974     // we have to generate our own where clause as we want to search only by the
    1975     // det_id
    1976     psMetadata *where = psMetadataAlloc();
    1977     if (!psMetadataAddS64(where, PS_LIST_TAIL, "det_id", 0, "==",
    1978             (psS64)atoll(det_id))) {
    1979         psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    1980         psFree(where);
    1981         return false;
    1982     }
    1983 
    1984     psArray *rawImfiles = searchRawImfiles(config, where);
    1985     psFree(where);
     1914    // searchRawImfiles defines a where clause to search by det_id and iteration
     1915    psArray *rawImfiles = searchRawImfiles(config);
    19861916
    19871917    if (!rawImfiles) {
    … …  
    20451975    PS_ASSERT_PTR_NON_NULL(config, false);
    20461976
     1977    psMetadata *where = psMetadataAlloc();
     1978    PXOPT_COPY_STR(config->args, where, "-det_id",    "det_id", "==");
     1979    PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
     1980    PXOPT_COPY_STR(config->args, where, "-class_id",  "class_id", "==");
     1981    PXOPT_COPY_STR(config->args, where, "-recip",     "recipe", "==");
     1982
    20471983    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1984    PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    20481985    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    2049     PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    2050 
    2051     // select detStackedImfile.*
    2052     // by:
    2053     // where det_id, iteration, class_id is not in detNormalizedImfile
    2054 
    2055     psString query = psStringCopy(
    2056         "SELECT"
    2057         "   detStackedImfile.*"
    2058         " FROM detStackedImfile"
    2059         " JOIN detRun"
    2060         "   USING(det_id, iteration)"
    2061         " WHERE"
    2062         "   detRun.state = 'run'"
    2063         "   AND detRun.mode = 'master'"
    2064     );
    2065 
    2066     if (config->where) {
    2067         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "detStackedImfile");
     1986
     1987    psString query = pxDataGet("dettool_stacked.sql");
     1988    if (!query) {
     1989        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1990        psFree(where);
     1991        return false;
     1992    }
     1993
     1994    if (psListLength(where->list)) {
     1995        psString whereClause = psDBGenerateWhereConditionSQL(where, "detStackedImfile");
    20681996        psStringAppend(&query, " AND %s", whereClause);
    20691997        psFree(whereClause);
    20701998    }
     1999    psFree(where);
    20712000
    20722001    if (faulted) {
    … …  
    21202049    PS_ASSERT_PTR_NON_NULL(config, false);
    21212050
     2051    psMetadata *where = psMetadataAlloc();
     2052    PXOPT_COPY_STR(config->args, where, "-det_id",    "det_id", "==");
     2053    PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
     2054    PXOPT_COPY_STR(config->args, where, "-class_id",  "class_id", "==");
     2055    PXOPT_COPY_S16(config->args, where, "-code",      "fault", "==");
     2056
    21222057    psString query = pxDataGet("dettool_revertstacked.sql");
    21232058    if (!query) {
    … …  
    21262061    }
    21272062
    2128     if (config->where) {
    2129         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "detStackedImfile");
     2063    if (psListLength(where->list)) {
     2064        psString whereClause = psDBGenerateWhereConditionSQL(where, "detStackedImfile");
    21302065        psStringAppend(&query, " AND %s", whereClause);
    21312066        psFree(whereClause);
    21322067    }
     2068    psFree(where);
    21332069
    21342070    if (!p_psDBRunQuery(config->dbh, query)) {
    … …  
    21592095        return false;
    21602096    }
    2161 
    2162     // XXX does it make sense to accept any search params?
    2163 #if 0
    2164     if (config->where) {
    2165         psString whereClause = psDBGenerateWhereConditionSQL(config->where);
    2166         psStringAppend(&query, " AND %s", whereClause);
    2167         psFree(whereClause);
    2168     }
    2169 #endif
    21702097
    21712098    // treat limit == 0 as "no limit"
    … …  
    22402167    PS_ASSERT_PTR_NON_NULL(config, false);
    22412168
     2169    psMetadata *where = psMetadataAlloc();
     2170    PXOPT_COPY_STR(config->args, where, "-det_id",    "det_id", "==");
     2171    PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
     2172    PXOPT_COPY_STR(config->args, where, "-class_id",  "class_id", "==");
     2173
    22422174    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     2175    PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    22432176    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    2244     PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    22452177
    22462178    psString query = pxDataGet("dettool_normalizedstat.sql");
    … …  
    22582190    }
    22592191
    2260     if (config->where) {
    2261         psString whereClause = psDBGenerateWhereConditionSQL(config->where, NULL);
     2192    if (psListLength(where->list)) {
     2193        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    22622194        psStringAppend(&query, " AND %s", whereClause);
    22632195        psFree(whereClause);
    22642196    }
     2197    psFree(where);
    22652198
    22662199    // treat limit == 0 as "no limit"
    … …  
    23052238    PS_ASSERT_PTR_NON_NULL(config, false);
    23062239
     2240    psMetadata *where = psMetadataAlloc();
     2241    PXOPT_COPY_STR(config->args, where, "-det_id",    "det_id", "==");
     2242    PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
     2243    PXOPT_COPY_STR(config->args, where, "-class_id",  "class_id", "==");
     2244    PXOPT_COPY_S16(config->args, where, "-code",      "fault", "==");
     2245
    23072246    psString query = pxDataGet("dettool_revertnormalizedstat.sql");
    23082247    if (!query) {
    … …  
    23112250    }
    23122251
    2313     if (config->where) {
    2314         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "detNormalizedStatImfile");
     2252    if (psListLength(where->list)) {
     2253        psString whereClause = psDBGenerateWhereConditionSQL(where, "detNormalizedStatImfile");
    23152254        psStringAppend(&query, " AND %s", whereClause);
    23162255        psFree(whereClause);
    23172256    }
     2257    psFree(where);
    23182258
    23192259    if (!p_psDBRunQuery(config->dbh, query)) {
    … …  
    23392279    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    23402280
    2341     // select detNormalizedStatImfile.*
    2342     // by:
    2343     // where det_id, iteration, class_id is not in detNormalizedImfile
    2344 
    2345     psString query = psStringCopy(
    2346         "SELECT DISTINCT"
    2347         "   detRun.det_type,"
    2348         "   detRun.workdir,"
    2349         "   rawExp.camera,"
    2350         "   detStackedImfile.uri,"
    2351         "   detNormalizedStatImfile.*"
    2352         " FROM detRun"
    2353         " JOIN detStackedImfile"
    2354         "   USING(det_id, iteration)"
    2355         " JOIN detInputExp"
    2356         "   USING(det_id, iteration)"
    2357         " JOIN rawExp"
    2358         "   ON detInputExp.exp_id = rawExp.exp_id"
    2359         " JOIN detNormalizedStatImfile"
    2360         "   ON detStackedImfile.det_id = detNormalizedStatImfile.det_id"
    2361         "   AND detStackedImfile.iteration = detNormalizedStatImfile.iteration"
    2362         "   AND detStackedImfile.class_id = detNormalizedStatImfile.class_id"
    2363         " LEFT JOIN detNormalizedImfile"
    2364         "   ON detNormalizedStatImfile.det_id = detNormalizedImfile.det_id"
    2365         "   AND detNormalizedStatImfile.iteration = detNormalizedImfile.iteration"
    2366         "   AND detNormalizedStatImfile.class_id = detNormalizedImfile.class_id"
    2367         " WHERE"
    2368         "   detNormalizedImfile.det_id IS NULL"
    2369         "   AND detNormalizedImfile.iteration IS NULL"
    2370         "   AND detNormalizedImfile.class_id IS NULL"
    2371         "   AND detNormalizedStatImfile.fault = 0"
    2372         "   AND detRun.state = 'run'"
    2373         );
    2374 
    2375     // XXX does it make sense to accept any search params?
    2376 #if 0
    2377     if (config->where) {
    2378         psString whereClause = psDBGenerateWhereConditionSQL(config->where);
    2379         psStringAppend(&query, " AND %s", whereClause);
    2380         psFree(whereClause);
    2381     }
    2382 #endif
     2281    psString query = pxDataGet("dettool_tonormalize.sql");
     2282    if (!query) {
     2283        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     2284        return false;
     2285    }
    23832286
    23842287    // treat limit == 0 as "no limit"
    … …  
    24192322}
    24202323
    2421 #if 0
    2422 // XXX this function was left in commented as this method may be useful in the
    2423 // future
    2424 static psArray *validDetInputClassIds(pxConfig *config, const char *det_id)
    2425 {
    2426     PS_ASSERT_PTR_NON_NULL(config, NULL);
    2427     // det_id is input as a string because the fact that it is an integer
    2428     // is just a database impliementation detail.
    2429     PS_ASSERT_PTR_NON_NULL(det_id, NULL);
    2430 
    2431     psArray *rawImfiles = searchInputImfiles(config, det_id);
    2432     if (!rawImfiles) {
    2433         return NULL;
    2434     }
    2435 
    2436     psArray *valid_class_ids = NULL;
    2437     {
    2438         // All this jumping through hoops is so that we end up with unique
    2439         // values. PP thinks that making multiple passes through this array and
    2440         // deleting matched elements would end up being more expensive then a
    2441         // double sort and stagger scheme. JH thinks it would be cheaper to
    2442         // just do a unqiue sort and delete.  So this is really just a cheap
    2443         // hack to avoid implimenting a unique sort function but at least it's
    2444         // stable.
    2445         psHash *hash = psHashAlloc(psArrayLength(rawImfiles));
    2446         for (long i = 0; i < psArrayLength(rawImfiles); i++) {
    2447             psHashAdd(hash,
    2448                 ((rawImfileRow *)rawImfiles->data[i])->class_id,
    2449                 ((rawImfileRow *)rawImfiles->data[i])->class_id
    2450             );
    2451         }
    2452         valid_class_ids = psHashToArray(hash);
    2453         psFree(hash);
    2454     }
    2455     psFree(rawImfiles);
    2456 
    2457     return valid_class_ids;
    2458 }
    2459 
    2460 static psArray *searchInputImfiles(pxConfig *config, const char *det_id)
    2461 {
    2462     PS_ASSERT_PTR_NON_NULL(config, NULL);
    2463     // det_id is input as a string because the fact that it is an integer
    2464     // is just a database impliementation detail.
    2465     PS_ASSERT_PTR_NON_NULL(det_id, NULL);
    2466 
    2467     psArray *inputExps = NULL;
    2468     {
    2469         psMetadata *where = psMetadataAlloc();
    2470         if (!psMetadataAddS32(where, PS_LIST_TAIL, "det_id", 0, "==",
    2471                 (psS32)atoi(det_id))) {
    2472             psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    2473             psFree(where);
    2474             return NULL;
    2475         }
    2476         inputExps = detInputExpSelectRowObjects(config->dbh, where, 0);
    2477         psFree(where);
    2478     }
    2479     if (!inputExps) {
    2480         psError(PS_ERR_UNKNOWN, false, "no detInputExp rows found");
    2481         return NULL;
    2482     }
    2483 
    2484     // find rawImfiles associated with detInputExps
    2485     psArray *rawImfiles = NULL;
    2486     {
    2487         psMetadata *where = psMetadataAlloc();
    2488         for (long i = 0; i < psArrayLength(inputExps); i++) {
    2489             if (!psMetadataAddStr(where, PS_LIST_TAIL, "exp_id",
    2490                     PS_META_DUPLICATE_OK, "==",
    2491                     ((detInputExpRow *)inputExps->data[i])->exp_id)) {
    2492                 psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    2493                 psFree(inputExps);
    2494                 psFree(where);
    2495                 return NULL;
    2496             }
    2497         }
    2498         psFree(inputExps);
    2499         rawImfiles = rawImfileSelectRowObjects(config->dbh, where, 0);
    2500         // XXX this really should be sorted for uniqueness
    2501         psFree(where);
    2502     }
    2503     if (!rawImfiles) {
    2504         psError(PS_ERR_UNKNOWN, false, "no rawImfile rows found");
    2505         return NULL;
    2506     }
    2507 
    2508     return rawImfiles;
    2509 }
    2510 #endif
    2511 
    25122324static bool addnormalizedimfileMode(pxConfig *config)
    25132325{
    … …  
    25162328    // required
    25172329    PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false);
     2330    PXOPT_LOOKUP_S32(iteration, config->args, "-iteration", false, false);
    25182331    PXOPT_LOOKUP_STR(class_id, config->args, "-class_id", true, false);
    25192332
    … …  
    25332346    PXOPT_LOOKUP_F64(user_5, config->args, "-user_5", false, false);
    25342347    PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", false, false);
    2535 
    2536     // default values
    2537     PXOPT_LOOKUP_S32(iteration, config->args, "-iteration", false, false);
    25382348
    25392349    if (!detNormalizedImfileInsert(config->dbh,
    … …  
    25602370}
    25612371
    2562 
    25632372static bool normalizedimfileMode(pxConfig *config)
    25642373{
    25652374    PS_ASSERT_PTR_NON_NULL(config, false);
     2375
     2376    psMetadata *where = psMetadataAlloc();
     2377    PXOPT_COPY_STR(config->args, where, "-det_id",    "det_id", "==");
     2378    PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
     2379    PXOPT_COPY_STR(config->args, where, "-class_id",  "class_id", "==");
     2380    PXOPT_COPY_S16(config->args, where, "-code",      "fault", "==");
    25662381
    25672382    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    … …  
    25692384    PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    25702385
    2571     psString query = psStringCopy(
    2572         "SELECT"
    2573         " detNormalizedImfile.*"
    2574         " FROM detNormalizedImfile"
    2575         " JOIN detRun"
    2576         "   USING(det_id, iteration)"
    2577         " WHERE"
    2578         "   detRun.state = 'run'"
    2579         "   AND detRun.mode = 'master'"
    2580     );
    2581 
    2582     if (config->where) {
    2583         bool status;
    2584         int iteration = psMetadataLookupS32 (&status, config->where, "iteration");
    2585         if (status) {
    2586             psMetadataRemoveKey (config->where, "iteration");
    2587             psMetadataAddS32 (config->where, PS_LIST_TAIL, "iteration", 0, "==", iteration);
    2588         }
    2589         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "detNormalizedImfile");
     2386    psString query = pxDataGet("dettool_revertstacked.sql");
     2387    if (!query) {
     2388        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     2389        return false;
     2390    }
     2391
     2392    if (psListLength(where->list)) {
     2393        psString whereClause = psDBGenerateWhereConditionSQL(where, "detNormalizedImfile");
    25902394        psStringAppend(&query, " AND %s", whereClause);
    25912395        psFree(whereClause);
    25922396    }
     2397    psFree(where);
    25932398
    25942399    if (faulted) {
    … …  
    26422447    PS_ASSERT_PTR_NON_NULL(config, false);
    26432448
     2449    psMetadata *where = psMetadataAlloc();
     2450    PXOPT_COPY_STR(config->args, where, "-det_id",    "det_id", "==");
     2451    PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
     2452    PXOPT_COPY_STR(config->args, where, "-class_id",  "class_id", "==");
     2453    PXOPT_COPY_S16(config->args, where, "-code",      "fault", "==");
     2454
    26442455    psString query = pxDataGet("dettool_revertnormalizedimfile.sql");
    26452456    if (!query) {
    … …  
    26482459    }
    26492460
    2650     if (config->where) {
     2461    if (psListLength(where->list)) {
    26512462        psString whereClause = psDBGenerateWhereConditionSQL(config->where, "detNormalizedImfile");
    26522463        psStringAppend(&query, " AND %s", whereClause);
    26532464        psFree(whereClause);
    26542465    }
     2466    psFree(where);
    26552467
    26562468    if (!p_psDBRunQuery(config->dbh, query)) {
    … …  
    26682480    return true;
    26692481}
    2670 
    26712482
    26722483static bool tonormalizedexpMode(pxConfig *config)
    … …  
    26822493        return false;
    26832494    }
    2684 
    2685     // XXX does it make sense to accept any search params?
    2686 #if 0
    2687     if (config->where) {
    2688         psString whereClause = psDBGenerateWhereConditionSQL(config->where);
    2689         psStringAppend(&query, " AND %s", whereClause);
    2690         psFree(whereClause);
    2691     }
    2692 #endif
    26932495
    26942496    // treat limit == 0 as "no limit"
    … …  
    43894191    return true;
    43904192}
     4193
     4194
     4195#if 0
     4196// XXX this function was left in commented as this method may be useful in the
     4197// future
     4198static psArray *validDetInputClassIds(pxConfig *config, const char *det_id)
     4199{
     4200    PS_ASSERT_PTR_NON_NULL(config, NULL);
     4201    // det_id is input as a string because the fact that it is an integer
     4202    // is just a database impliementation detail.
     4203    PS_ASSERT_PTR_NON_NULL(det_id, NULL);
     4204
     4205    psArray *rawImfiles = searchInputImfiles(config, det_id);
     4206    if (!rawImfiles) {
     4207        return NULL;
     4208    }
     4209
     4210    psArray *valid_class_ids = NULL;
     4211    {
     4212        // All this jumping through hoops is so that we end up with unique
     4213        // values. PP thinks that making multiple passes through this array and
     4214        // deleting matched elements would end up being more expensive then a
     4215        // double sort and stagger scheme. JH thinks it would be cheaper to
     4216        // just do a unqiue sort and delete.  So this is really just a cheap
     4217        // hack to avoid implimenting a unique sort function but at least it's
     4218        // stable.
     4219        psHash *hash = psHashAlloc(psArrayLength(rawImfiles));
     4220        for (long i = 0; i < psArrayLength(rawImfiles); i++) {
     4221            psHashAdd(hash,
     4222                ((rawImfileRow *)rawImfiles->data[i])->class_id,
     4223                ((rawImfileRow *)rawImfiles->data[i])->class_id
     4224            );
     4225        }
     4226        valid_class_ids = psHashToArray(hash);
     4227        psFree(hash);
     4228    }
     4229    psFree(rawImfiles);
     4230
     4231    return valid_class_ids;
     4232}
     4233
     4234static psArray *searchInputImfiles(pxConfig *config, const char *det_id)
     4235{
     4236    PS_ASSERT_PTR_NON_NULL(config, NULL);
     4237    // det_id is input as a string because the fact that it is an integer
     4238    // is just a database impliementation detail.
     4239    PS_ASSERT_PTR_NON_NULL(det_id, NULL);
     4240
     4241    psArray *inputExps = NULL;
     4242    {
     4243        psMetadata *where = psMetadataAlloc();
     4244        if (!psMetadataAddS32(where, PS_LIST_TAIL, "det_id", 0, "==",
     4245                (psS32)atoi(det_id))) {
     4246            psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
     4247            psFree(where);
     4248            return NULL;
     4249        }
     4250        inputExps = detInputExpSelectRowObjects(config->dbh, where, 0);
     4251        psFree(where);
     4252    }
     4253    if (!inputExps) {
     4254        psError(PS_ERR_UNKNOWN, false, "no detInputExp rows found");
     4255        return NULL;
     4256    }
     4257
     4258    // find rawImfiles associated with detInputExps
     4259    psArray *rawImfiles = NULL;
     4260    {
     4261        psMetadata *where = psMetadataAlloc();
     4262        for (long i = 0; i < psArrayLength(inputExps); i++) {
     4263            if (!psMetadataAddStr(where, PS_LIST_TAIL, "exp_id",
     4264                    PS_META_DUPLICATE_OK, "==",
     4265                    ((detInputExpRow *)inputExps->data[i])->exp_id)) {
     4266                psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
     4267                psFree(inputExps);
     4268                psFree(where);
     4269                return NULL;
     4270            }
     4271        }
     4272        psFree(inputExps);
     4273        rawImfiles = rawImfileSelectRowObjects(config->dbh, where, 0);
     4274        // XXX this really should be sorted for uniqueness
     4275        psFree(where);
     4276    }
     4277    if (!rawImfiles) {
     4278        psError(PS_ERR_UNKNOWN, false, "no rawImfile rows found");
     4279        return NULL;
     4280    }
     4281
     4282    return rawImfiles;
     4283}
     4284#endif
     4285

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

    r18172 r18468  
    4646
    4747    // -pending
     48    // XXX EAM : is this used?  does it make sense?
    4849    psMetadata *pendingArgs = psMetadataAlloc();
    49     psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-exp_id",  0,
    50             "search by exposure ID", NULL);
    51     psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-exp_type",  0,
    52             "search by exposure type", NULL);
    53     psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-inst",  0,
    54             "search by camera", NULL);
    55     psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-telescope",  0,
    56             "search by telescope", NULL);
    57     psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-filter",  0,
    58             "search by filter", NULL);
    59     psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-uri",  0,
    60             "search by URL", NULL);
    61     psMetadataAddBool(pendingArgs, PS_LIST_TAIL, "-simple",  0,
    62             "use the simple output format", false);
     50    psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exposure ID", NULL);
     51    psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-exp_type",  0,            "search by exposure type", NULL);
     52    psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-inst",  0,            "search by camera", NULL);
     53    psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-telescope",  0,            "search by telescope", NULL);
     54    psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-filter",  0,            "search by filter", NULL);
     55    psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-uri",  0,            "search by URL", NULL);
     56    psMetadataAddBool(pendingArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    6357
    6458    // -definebytag
    6559    psMetadata *definebytagArgs = psMetadataAlloc();
    66     psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-exp_id",
    67             PS_META_DUPLICATE_OK,
    68             "include this exposure (multiple OK, required)", NULL);
    69     psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-det_type",  0,
    70             "define the type of detrend run (required)", NULL);
    71     psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-mode",  0,
    72             "define the mode of this detrend run", "master");
    73     psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-filelevel",  0,
    74             "define filelevel", NULL);
    75     psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-workdir",  0,
    76             "define workdir (required)", NULL);
    77     psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-inst",  0,
    78             "define camera", NULL);
    79     psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-telescope",  0,
    80             "define telescope", NULL);
    81     psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-exp_type",  0,
    82             "define exposure type", NULL);
    83     psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-filter",  0,
    84             "define filter ", NULL);
    85     psMetadataAddF32(definebytagArgs, PS_LIST_TAIL, "-airmass_min",  0,
    86             "define min airmass", NAN);
    87     psMetadataAddF32(definebytagArgs, PS_LIST_TAIL, "-airmass_max",  0,
    88             "define max airmass", NAN);
    89     psMetadataAddF32(definebytagArgs, PS_LIST_TAIL, "-exp_time_min",  0,
    90             "define min exposure time", NAN);
    91     psMetadataAddF32(definebytagArgs, PS_LIST_TAIL, "-exp_time_max",  0,
    92             "define max exposure time", NAN);
    93     psMetadataAddF64(definebytagArgs, PS_LIST_TAIL, "-ccd_temp_min",  0,
    94             "define min ccd tempature", NAN);
    95     psMetadataAddF64(definebytagArgs, PS_LIST_TAIL, "-ccd_temp_max",  0,
    96             "define max ccd tempature", NAN);
    97     psMetadataAddF64(definebytagArgs, PS_LIST_TAIL, "-posang_min",  0,
    98             "define min rotator position angle", NAN);
    99     psMetadataAddF64(definebytagArgs, PS_LIST_TAIL, "-posang_max",  0,
    100             "define max rotator position angle", NAN);
    101     psMetadataAddF64(definebytagArgs, PS_LIST_TAIL, "-solang_min",  0,
    102             "define min solar angle", NAN);
    103     psMetadataAddF64(definebytagArgs, PS_LIST_TAIL, "-solang_max",  0,
    104             "define max solar angle", NAN);
    105     psMetadataAddTime(definebytagArgs, PS_LIST_TAIL, "-registered",  0,
    106             "time detrend run was registered", now);
    107     psMetadataAddTime(definebytagArgs, PS_LIST_TAIL, "-time_begin",  0,
    108             "detrend applies to exposures taken during this period", NULL);
    109     psMetadataAddTime(definebytagArgs, PS_LIST_TAIL, "-time_end",  0,
    110             "detrend applies to exposures taken during this period", NULL);
    111     psMetadataAddTime(definebytagArgs, PS_LIST_TAIL, "-use_begin",  0,
    112             "start of detrend run applicable period", NULL);
    113     psMetadataAddTime(definebytagArgs, PS_LIST_TAIL, "-use_end",  0,
    114             "end of detrend run applicable period", NULL);
    115     psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-reduction",  0,
    116             "define reduction class for processing", NULL);
    117     psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-label",  0,
    118             "define detrun label", NULL);
    119     psMetadataAddBool(definebytagArgs, PS_LIST_TAIL, "-simple",  0,
    120             "use the simple output format", false);
     60    psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-exp_id",            PS_META_DUPLICATE_OK,           "include this exposure (multiple OK, required)", NULL);
     61    psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-det_type",  0,            "define the type of detrend run (required)", NULL);
     62    psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-mode",  0,            "define the mode of this detrend run", "master");
     63    psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-filelevel",  0,            "define filelevel", NULL);
     64    psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-workdir",  0,            "define workdir (required)", NULL);
     65    psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-inst",  0,            "define camera", NULL);
     66    psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-telescope",  0,            "define telescope", NULL);
     67    psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-exp_type",  0,            "define exposure type", NULL);
     68    psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-filter",  0,            "define filter ", NULL);
     69    psMetadataAddF32(definebytagArgs, PS_LIST_TAIL, "-airmass_min",  0,            "define min airmass", NAN);
     70    psMetadataAddF32(definebytagArgs, PS_LIST_TAIL, "-airmass_max",  0,            "define max airmass", NAN);
     71    psMetadataAddF32(definebytagArgs, PS_LIST_TAIL, "-exp_time_min",  0,            "define min exposure time", NAN);
     72    psMetadataAddF32(definebytagArgs, PS_LIST_TAIL, "-exp_time_max",  0,            "define max exposure time", NAN);
     73    psMetadataAddF64(definebytagArgs, PS_LIST_TAIL, "-ccd_temp_min",  0,            "define min ccd tempature", NAN);
     74    psMetadataAddF64(definebytagArgs, PS_LIST_TAIL, "-ccd_temp_max",  0,            "define max ccd tempature", NAN);
     75    psMetadataAddF64(definebytagArgs, PS_LIST_TAIL, "-posang_min",  0,            "define min rotator position angle", NAN);
     76    psMetadataAddF64(definebytagArgs, PS_LIST_TAIL, "-posang_max",  0,            "define max rotator position angle", NAN);
     77    psMetadataAddF64(definebytagArgs, PS_LIST_TAIL, "-solang_min",  0,            "define min solar angle", NAN);
     78    psMetadataAddF64(definebytagArgs, PS_LIST_TAIL, "-solang_max",  0,            "define max solar angle", NAN);
     79    psMetadataAddTime(definebytagArgs, PS_LIST_TAIL, "-registered",  0,            "time detrend run was registered", now);
     80    psMetadataAddTime(definebytagArgs, PS_LIST_TAIL, "-time_begin",  0,            "detrend applies to exposures taken during this period", NULL);
     81    psMetadataAddTime(definebytagArgs, PS_LIST_TAIL, "-time_end",  0,            "detrend applies to exposures taken during this period", NULL);
     82    psMetadataAddTime(definebytagArgs, PS_LIST_TAIL, "-use_begin",  0,            "start of detrend run applicable period", NULL);
     83    psMetadataAddTime(definebytagArgs, PS_LIST_TAIL, "-use_end",  0,            "end of detrend run applicable period", NULL);
     84    psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-reduction",  0,            "define reduction class for processing", NULL);
     85    psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-label",  0,            "define detrun label", NULL);
     86    psMetadataAddBool(definebytagArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    12187
    12288    // -definebyquery
    12389    psMetadata *definebyqueryArgs = psMetadataAlloc();
    124     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-det_type",  0,
    125             "define the type of detrend run (required)", NULL);
    126     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-mode",  0,
    127             "define the mode of this detrend run", "master");
    128     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-filelevel",  0,
    129             "define filelevel", NULL);
    130     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-workdir",  0,
    131             "define workdir (required)", NULL);
    132     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-inst",  0,
    133             "define camera (required)", NULL);
    134     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-telescope",  0,
    135             "define telescope", NULL);
    136     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-filter",  0,
    137             "define filter ", NULL);
    138     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-airmass_min",  0,
    139             "define min airmass", NAN);
    140     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-airmass_max",  0,
    141             "define max airmass", NAN);
    142     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-exp_time_min",  0,
    143             "define min exposure time", NAN);
    144     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-exp_time_max",  0,
    145             "define max exposure time", NAN);
    146     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-ccd_temp_min",  0,
    147             "define min ccd tempature", NAN);
    148     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-ccd_temp_max",  0,
    149             "define max ccd tempature", NAN);
    150     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-posang_min",  0,
    151             "define min rotator position angle", NAN);
    152     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-posang_max",  0,
    153             "define max rotator position angle", NAN);
    154     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-solang_min",  0,
    155             "define min solar angle", NAN);
    156     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-solang_max",  0,
    157             "define max solar angle", NAN);
    158     psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-registered",  0,
    159             "time detrend run was registered", now);
    160     psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-time_begin",  0,
    161             "detrend applies to exposures taken during this period", NULL);
    162     psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-time_end",  0,
    163             "detrend applies to exposures taken during this period", NULL);
    164     psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-use_begin",  0,
    165             "start of detrend run applicable period", NULL);
    166     psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-use_end",  0,
    167             "end of detrend run applicable period", NULL);
    168     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_exp_type",  0,
    169             "search for exp_type", NULL);
    170     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_inst",  0,
    171             "search for camera", NULL);
    172     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_telescope",  0,
    173             "search for telescope", NULL);
    174     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_filter",  0,
    175             "search for filter", NULL);
    176     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_uri",  0,
    177             "search for uri", NULL);
    178     psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-select_dateobs_begin", 0,
    179             "search for exposures by time (>=)", NULL);
    180     psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-select_dateobs_end", 0,
    181             "search for exposures by time (<)", NULL);
    182     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_airmass_min",  0,
    183             "define min airmass", NAN);
    184     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_airmass_max",  0,
    185             "define max airmass", NAN);
    186     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_sat_pixel_frac_max",  0,
    187             "define max fraction of saturated pixels", NAN);
    188     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_exp_time_min",  0,
    189             "define min exposure time", NAN);
    190     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_exp_time_max",  0,
    191             "define max exposure time", NAN);
    192     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_ccd_temp_min",  0,
    193             "define min ccd tempature", NAN);
    194     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_ccd_temp_max",  0,
    195             "define max ccd tempature", NAN);
    196     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_pon_time_min",  0,
    197             "define min power-on time", NAN);
    198     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_pon_time_max",  0,
    199             "define max power-on time", NAN);
    200     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_posang_min",  0,
    201             "define min rotator position angle", NAN);
    202     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_posang_max",  0,
    203             "define max rotator position angle", NAN);
    204     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_solang_min",  0,
    205             "define min solar angle", NAN);
    206     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_solang_max",  0,
    207             "define max solar angle", NAN);
    208     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-pretend",  0,
    209             "print the exposures that would be included in the detrend run and exit", false);
    210     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-reduction",  0,
    211             "define reduction class for processing", NULL);
    212     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-label",  0,
    213             "define detrun label", NULL);
    214     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-simple",  0,
    215             "use the simple output format", false);
    216 
    217     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-random_subset",  0,
    218             "use a random subset of elements", false);
    219     psMetadataAddS32(definebyqueryArgs, PS_LIST_TAIL, "-random_limit",  0,
    220             "use this number of random elements", 20);
     90    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-det_type",  0,            "define the type of detrend run (required)", NULL);
     91    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-mode",  0,            "define the mode of this detrend run", "master");
     92    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-filelevel",  0,            "define filelevel", NULL);
     93    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-workdir",  0,            "define workdir (required)", NULL);
     94    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-inst",  0,            "define camera (required)", NULL);
     95    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-telescope",  0,            "define telescope", NULL);
     96    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-filter",  0,            "define filter ", NULL);
     97    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-airmass_min",  0,            "define min airmass", NAN);
     98    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-airmass_max",  0,            "define max airmass", NAN);
     99    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-exp_time_min",  0,            "define min exposure time", NAN);
     100    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-exp_time_max",  0,            "define max exposure time", NAN);
     101    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-ccd_temp_min",  0,            "define min ccd tempature", NAN);
     102    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-ccd_temp_max",  0,            "define max ccd tempature", NAN);
     103    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-posang_min",  0,            "define min rotator position angle", NAN);
     104    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-posang_max",  0,            "define max rotator position angle", NAN);
     105    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-solang_min",  0,            "define min solar angle", NAN);
     106    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-solang_max",  0,            "define max solar angle", NAN);
     107    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-registered",  0,            "time detrend run was registered", now);
     108    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-time_begin",  0,            "detrend applies to exposures taken during this period", NULL);
     109    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-time_end",  0,            "detrend applies to exposures taken during this period", NULL);
     110    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-use_begin",  0,            "start of detrend run applicable period", NULL);
     111    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-use_end",  0,            "end of detrend run applicable period", NULL);
     112    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_exp_type",  0,            "search for exp_type", NULL);
     113    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_inst",  0,            "search for camera", NULL);
     114    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_telescope",  0,            "search for telescope", NULL);
     115    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_filter",  0,            "search for filter", NULL);
     116    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_uri",  0,            "search for uri", NULL);
     117    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-select_dateobs_begin", 0,            "search for exposures by time (>=)", NULL);
     118    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-select_dateobs_end", 0,            "search for exposures by time (<)", NULL);
     119    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_airmass_min",  0,            "define min airmass", NAN);
     120    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_airmass_max",  0,            "define max airmass", NAN);
     121    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_sat_pixel_frac_max",  0,            "define max fraction of saturated pixels", NAN);
     122    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_exp_time_min",  0,            "define min exposure time", NAN);
     123    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_exp_time_max",  0,            "define max exposure time", NAN);
     124    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_ccd_temp_min",  0,            "define min ccd tempature", NAN);
     125    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_ccd_temp_max",  0,            "define max ccd tempature", NAN);
     126    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_pon_time_min",  0,            "define min power-on time", NAN);
     127    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_pon_time_max",  0,            "define max power-on time", NAN);
     128    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_posang_min",  0,            "define min rotator position angle", NAN);
     129    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_posang_max",  0,            "define max rotator position angle", NAN);
     130    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_solang_min",  0,            "define min solar angle", NAN);
     131    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_solang_max",  0,            "define max solar angle", NAN);
     132    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-pretend",  0,            "print the exposures that would be included in the detrend run and exit", false);
     133    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-reduction",  0,            "define reduction class for processing", NULL);
     134    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-label",  0,            "define detrun label", NULL);
     135    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     136    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-random_subset",  0,            "use a random subset of elements", false);
     137    psMetadataAddS32(definebyqueryArgs, PS_LIST_TAIL, "-random_limit",  0,            "use this number of random elements", 20);
    221138
    222139    // -definebydetrun
    223140    psMetadata *definebydetrunArgs = psMetadataAlloc();
    224     psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-det_id",  0,
    225             "det ID to base a new detRun on (required)", NULL);
    226     psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-set_det_type",  0,
    227             "define the type of detrend run", NULL);
    228     psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-set_mode",  0,
    229             "define the mode of this detrend run", "master");
    230     psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-set_exp_type",  0,
    231             "define exposure type", NULL);
    232     psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-set_filelevel",  0,
    233             "define filelevel", NULL);
    234     psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-set_workdir",  0,
    235             "define workdir", NULL);
    236     psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-set_filter",  0,
    237             "define filter ", NULL);
    238     psMetadataAddF32(definebydetrunArgs, PS_LIST_TAIL, "-set_airmass_min",  0,
    239             "define airmass", NAN);
    240     psMetadataAddF32(definebydetrunArgs, PS_LIST_TAIL, "-set_airmass_max",  0,
    241             "define airmass", NAN);
    242     psMetadataAddF32(definebydetrunArgs, PS_LIST_TAIL, "-set_exp_time_min",  0,
    243             "define exposure time", NAN);
    244     psMetadataAddF32(definebydetrunArgs, PS_LIST_TAIL, "-set_exp_time_max",  0,
    245             "define exposure time", NAN);
    246     psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_ccd_temp_min",  0,
    247             "define ccd tempature", NAN);
    248     psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_ccd_temp_max",  0,
    249             "define ccd tempature", NAN);
    250     psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_posang_min",  0,
    251             "define rotator position angle", NAN);
    252     psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_posang_max",  0,
    253             "define rotator position angle", NAN);
    254     psMetadataAddTime(definebydetrunArgs, PS_LIST_TAIL, "-set_registered",  0,
    255             "time detrend run was registered", now);
    256     psMetadataAddTime(definebydetrunArgs, PS_LIST_TAIL, "-set_time_begin",  0,
    257             "start of period to apply detrend too", NULL);
    258     psMetadataAddTime(definebydetrunArgs, PS_LIST_TAIL, "-set_time_end",  0,
    259             "end of period to apply detrend too", NULL);
    260     psMetadataAddTime(definebydetrunArgs, PS_LIST_TAIL, "-set_use_begin",  0,
    261             "start of detrend run applicable period", NULL);
    262     psMetadataAddTime(definebydetrunArgs, PS_LIST_TAIL, "-set_use_end",  0,
    263             "end of detrend run applicable period", NULL);
    264     psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_solang_min",  0,
    265             "define solar angle", NAN);
    266     psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_solang_max",  0,
    267             "define solar angle", NAN);
    268     psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-filter_input_begin", 0,
    269             "filter input detrun exp to be in this period", NULL);
    270     psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-filter_input_end", 0,
    271             "filter input detrun exp to be in this period", NULL);
    272     psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-set_reduction",  0,
    273             "define reduction class for processing", NULL);
    274     psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-set_label",  0,
    275             "define detrun label", NULL);
    276     psMetadataAddBool(definebydetrunArgs, PS_LIST_TAIL, "-simple", 0,
    277             "use the simple output format", false);
    278 
     141    psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-det_id",  0,            "det ID to base a new detRun on (required)", NULL);
     142    psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-set_det_type",  0,            "define the type of detrend run", NULL);
     143    psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-set_mode",  0,            "define the mode of this detrend run", "master");
     144    psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-set_exp_type",  0,            "define exposure type", NULL);
     145    psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-set_filelevel",  0,            "define filelevel", NULL);
     146    psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-set_workdir",  0,            "define workdir", NULL);
     147    psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-set_filter",  0,            "define filter ", NULL);
     148    psMetadataAddF32(definebydetrunArgs, PS_LIST_TAIL, "-set_airmass_min",  0,            "define airmass", NAN);
     149    psMetadataAddF32(definebydetrunArgs, PS_LIST_TAIL, "-set_airmass_max",  0,            "define airmass", NAN);
     150    psMetadataAddF32(definebydetrunArgs, PS_LIST_TAIL, "-set_exp_time_min",  0,            "define exposure time", NAN);
     151    psMetadataAddF32(definebydetrunArgs, PS_LIST_TAIL, "-set_exp_time_max",  0,            "define exposure time", NAN);
     152    psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_ccd_temp_min",  0,            "define ccd tempature", NAN);
     153    psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_ccd_temp_max",  0,            "define ccd tempature", NAN);
     154    psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_posang_min",  0,            "define rotator position angle", NAN);
     155    psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_posang_max",  0,            "define rotator position angle", NAN);
     156    psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_solang_min",  0,            "define solar angle", NAN);
     157    psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_solang_max",  0,            "define solar angle", NAN);
     158    psMetadataAddTime(definebydetrunArgs, PS_LIST_TAIL, "-set_registered",  0,            "time detrend run was registered", now);
     159    psMetadataAddTime(definebydetrunArgs, PS_LIST_TAIL, "-set_time_begin",  0,            "start of period to apply detrend too", NULL);
     160    psMetadataAddTime(definebydetrunArgs, PS_LIST_TAIL, "-set_time_end",  0,            "end of period to apply detrend too", NULL);
     161    psMetadataAddTime(definebydetrunArgs, PS_LIST_TAIL, "-set_use_begin",  0,            "start of detrend run applicable period", NULL);
     162    psMetadataAddTime(definebydetrunArgs, PS_LIST_TAIL, "-set_use_end",  0,            "end of detrend run applicable period", NULL);
     163    psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-set_reduction",  0,            "define reduction class for processing", NULL);
     164    psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-set_label",  0,            "define detrun label", NULL);
     165    psMetadataAddBool(definebydetrunArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
     166    psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-set_input_begin", 0,     "require input exp to be in this period", NULL);
     167    psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-set_input_end", 0,       "require input exp to be in this period", NULL);
     168
     169    // XXX EAM : it looks like the corresponding dettool functions don't exist:
    279170    // -makecorrection
    280171    psMetadata *makecorrectionArgs = psMetadataAlloc();
    281     psMetadataAddStr(makecorrectionArgs, PS_LIST_TAIL, "-det_id",  0,
    282             "det ID to be corrected (required)", NULL);
    283     psMetadataAddBool(makecorrectionArgs, PS_LIST_TAIL, "-simple", 0,
    284             "use the simple output format", false);
     172    psMetadataAddStr(makecorrectionArgs, PS_LIST_TAIL, "-det_id",  0,            "det ID to be corrected (required)", NULL);
     173    psMetadataAddBool(makecorrectionArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
    285174
    286175    // -tocorrectexp
    287176    psMetadata *tocorrectexpArgs = psMetadataAlloc();
    288     psMetadataAddU64(tocorrectexpArgs, PS_LIST_TAIL, "-limit",  0,
    289             "limit result set to N items", 0);
    290     psMetadataAddBool(tocorrectexpArgs, PS_LIST_TAIL, "-simple",  0,
    291             "use the simple output format", false);
     177    psMetadataAddU64(tocorrectexpArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     178    psMetadataAddBool(tocorrectexpArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    292179
    293180    // -tocorrectimfile
    294181    psMetadata *tocorrectimfileArgs = psMetadataAlloc();
    295     psMetadataAddStr(tocorrectimfileArgs, PS_LIST_TAIL, "-det_id", 0,
    296             "search for detrend ID", NULL);
    297     psMetadataAddU64(tocorrectimfileArgs, PS_LIST_TAIL, "-limit",  0,
    298             "limit result set to N items", 0);
    299     psMetadataAddBool(tocorrectimfileArgs, PS_LIST_TAIL, "-simple",  0,
    300             "use the simple output format", false);
     182    psMetadataAddStr(tocorrectimfileArgs, PS_LIST_TAIL, "-det_id", 0,            "search for detrend ID", NULL);
     183    psMetadataAddU64(tocorrectimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     184    psMetadataAddBool(tocorrectimfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    301185
    302186    // -addcorrectimfile
    303187    psMetadata *addcorrectimfileArgs = psMetadataAlloc();
    304     psMetadataAddStr(addcorrectimfileArgs, PS_LIST_TAIL, "-det_id",  0,
    305             "define detrend ID (required)", NULL);
    306     psMetadataAddStr(addcorrectimfileArgs, PS_LIST_TAIL, "-class_id",  0,
    307             "search for class ID (required)", NULL);
    308     psMetadataAddStr(addcorrectimfileArgs, PS_LIST_TAIL, "-uri",  0,
    309             "define resid file URI", NULL);
    310     psMetadataAddF64(addcorrectimfileArgs, PS_LIST_TAIL, "-bg",  0,
    311             "define exposure background", NAN);
    312     psMetadataAddF64(addcorrectimfileArgs, PS_LIST_TAIL, "-bg_stdev",  0,
    313             "define exposure background stdev", NAN);
    314     psMetadataAddF64(addcorrectimfileArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,
    315             "define exposure background mean stdev", NAN);
    316     psMetadataAddF64(addcorrectimfileArgs, PS_LIST_TAIL, "-user_1",  0,
    317             "define user statistic (1)", NAN);
    318     psMetadataAddF64(addcorrectimfileArgs, PS_LIST_TAIL, "-user_2",  0,
    319             "define user statistic (2)", NAN);
    320     psMetadataAddF64(addcorrectimfileArgs, PS_LIST_TAIL, "-user_3",  0,
    321             "define user statistic (3)", NAN);
    322     psMetadataAddF64(addcorrectimfileArgs, PS_LIST_TAIL, "-user_4",  0,
    323             "define user statistic (4)", NAN);
    324     psMetadataAddF64(addcorrectimfileArgs, PS_LIST_TAIL, "-user_5",  0,
    325             "define user statistic (5)", NAN);
    326     psMetadataAddStr(addcorrectimfileArgs, PS_LIST_TAIL, "-path_base",  0,
    327             "define base output location", NULL);
     188    psMetadataAddStr(addcorrectimfileArgs, PS_LIST_TAIL, "-det_id",  0,            "define detrend ID (required)", NULL);
     189    psMetadataAddStr(addcorrectimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "search for class ID (required)", NULL);
     190    psMetadataAddStr(addcorrectimfileArgs, PS_LIST_TAIL, "-uri",  0,            "define resid file URI", NULL);
     191    psMetadataAddF64(addcorrectimfileArgs, PS_LIST_TAIL, "-bg",  0,            "define exposure background", NAN);
     192    psMetadataAddF64(addcorrectimfileArgs, PS_LIST_TAIL, "-bg_stdev",  0,            "define exposure background stdev", NAN);
     193    psMetadataAddF64(addcorrectimfileArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,            "define exposure background mean stdev", NAN);
     194    psMetadataAddF64(addcorrectimfileArgs, PS_LIST_TAIL, "-user_1",  0,            "define user statistic (1)", NAN);
     195    psMetadataAddF64(addcorrectimfileArgs, PS_LIST_TAIL, "-user_2",  0,            "define user statistic (2)", NAN);
     196    psMetadataAddF64(addcorrectimfileArgs, PS_LIST_TAIL, "-user_3",  0,            "define user statistic (3)", NAN);
     197    psMetadataAddF64(addcorrectimfileArgs, PS_LIST_TAIL, "-user_4",  0,            "define user statistic (4)", NAN);
     198    psMetadataAddF64(addcorrectimfileArgs, PS_LIST_TAIL, "-user_5",  0,            "define user statistic (5)", NAN);
     199    psMetadataAddStr(addcorrectimfileArgs, PS_LIST_TAIL, "-path_base",  0,            "define base output location", NULL);
    328200
    329201    // -runs
    330202    psMetadata *runsArgs = psMetadataAlloc();
    331     psMetadataAddStr(runsArgs, PS_LIST_TAIL, "-det_type",  0,
    332             "search for type of detrend run", NULL);
    333     psMetadataAddBool(runsArgs, PS_LIST_TAIL, "-simple",  0,
    334             "use the simple output format", false);
    335     psMetadataAddBool(runsArgs, PS_LIST_TAIL, "-active",  0,
    336             "only return active detRuns", false);
    337     psMetadataAddU64(runsArgs, PS_LIST_TAIL, "-limit",  0,
    338             "limit result set to N items", 0);
    339     psMetadataAddStr(runsArgs, PS_LIST_TAIL, "-det_id", 0,
    340             "search for detrend ID", NULL);
    341 
    342     psMetadataAddStr(runsArgs, PS_LIST_TAIL, "-inst", 0,
    343             "search for camera (instrument)", NULL);
    344     psMetadataAddStr(runsArgs, PS_LIST_TAIL, "-telescope", 0,
    345             "search for telescope", NULL);
    346     psMetadataAddStr(runsArgs, PS_LIST_TAIL, "-filter", 0,
    347             "search for filter", NULL);
    348 
    349     psMetadataAddF32(runsArgs, PS_LIST_TAIL, "-airmass", 0,
    350             "match airmass", NAN);
    351     psMetadataAddF32(runsArgs, PS_LIST_TAIL, "-exp_time", 0,
    352             "match exp time", NAN);
    353     psMetadataAddF32(runsArgs, PS_LIST_TAIL, "-ccd_temp", 0,
    354             "match ccd temp", NAN);
    355     psMetadataAddF64(runsArgs, PS_LIST_TAIL, "-posang", 0,
    356             "match posang", NAN);
     203    psMetadataAddStr(runsArgs, PS_LIST_TAIL, "-det_type",  0,            "search for type of detrend run", NULL);
     204    psMetadataAddStr(runsArgs, PS_LIST_TAIL, "-det_id", 0,            "search for detrend ID", NULL);
     205    psMetadataAddStr(runsArgs, PS_LIST_TAIL, "-inst", 0,            "search for camera (instrument)", NULL);
     206    psMetadataAddStr(runsArgs, PS_LIST_TAIL, "-telescope", 0,            "search for telescope", NULL);
     207    psMetadataAddStr(runsArgs, PS_LIST_TAIL, "-filter", 0,            "search for filter", NULL);
     208    psMetadataAddF32(runsArgs, PS_LIST_TAIL, "-airmass", 0,            "match airmass", NAN);
     209    psMetadataAddF32(runsArgs, PS_LIST_TAIL, "-exp_time", 0,            "match exp time", NAN);
     210    psMetadataAddF32(runsArgs, PS_LIST_TAIL, "-ccd_temp", 0,            "match ccd temp", NAN);
     211    psMetadataAddF64(runsArgs, PS_LIST_TAIL, "-posang", 0,            "match posang", NAN);
     212    psMetadataAddBool(runsArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     213    psMetadataAddBool(runsArgs, PS_LIST_TAIL, "-active",  0,            "only return active detRuns", false);
     214    psMetadataAddU64(runsArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    357215
    358216    // -childlessrun
    359217    psMetadata *childlessrunArgs = psMetadataAlloc();
    360     psMetadataAddStr(childlessrunArgs, PS_LIST_TAIL, "-det_type",  0,
    361             "search for type of detrend run", NULL);
    362     psMetadataAddU64(childlessrunArgs, PS_LIST_TAIL, "-limit",  0,
    363             "limit result set to N items", 0);
    364     psMetadataAddBool(childlessrunArgs, PS_LIST_TAIL, "-simple",  0,
    365             "use the simple output format", false);
     218    psMetadataAddStr(childlessrunArgs, PS_LIST_TAIL, "-det_type",  0,            "search for type of detrend run", NULL);
     219    psMetadataAddU64(childlessrunArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     220    psMetadataAddBool(childlessrunArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    366221
    367222    // -input
    368223    psMetadata *inputArgs = psMetadataAlloc();
    369     psMetadataAddStr(inputArgs, PS_LIST_TAIL, "-det_id", 0,
    370             "search for detrend ID", NULL);
    371     psMetadataAddS32(inputArgs, PS_LIST_TAIL, "-iteration",  0,
    372             "define iteration number", 0);
    373     psMetadataAddStr(inputArgs, PS_LIST_TAIL, "-exp_id",  0,
    374             "search for exp ID", NULL);
    375     psMetadataAddBool(inputArgs, PS_LIST_TAIL, "-simple",  0,
    376             "use the simple output format", false);
     224    psMetadataAddStr(inputArgs, PS_LIST_TAIL, "-det_id", 0,            "search for detrend ID", NULL);
     225    psMetadataAddS32(inputArgs, PS_LIST_TAIL, "-iteration",  0,            "define iteration number", 0);
     226    psMetadataAddS64(inputArgs, PS_LIST_TAIL, "-exp_id",  0,            "search for exp ID", NULL);
     227    psMetadataAddBool(inputArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    377228
    378229    // -raw
    379230    psMetadata *rawArgs = psMetadataAlloc();
    380     psMetadataAddBool(rawArgs, PS_LIST_TAIL, "-simple",  0,
    381             "use the simple output format", false);
     231    psMetadataAddBool(rawArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    382232
    383233    // -toprocessedimfile
    384234    psMetadata *toprocessedimfileArgs = psMetadataAlloc();
    385     psMetadataAddStr(toprocessedimfileArgs, PS_LIST_TAIL, "-det_id",  0,
    386             "search for detrend ID", NULL);
    387     psMetadataAddStr(toprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,
    388             "search for exp ID", NULL);
    389     psMetadataAddStr(toprocessedimfileArgs, PS_LIST_TAIL, "-class_id",  0,
    390             "search for class ID", NULL);
    391     psMetadataAddU64(toprocessedimfileArgs, PS_LIST_TAIL, "-limit",  0,
    392             "limit result set to N items", 0);
    393     psMetadataAddBool(toprocessedimfileArgs, PS_LIST_TAIL, "-simple",  0,
    394             "use the simple output format", false);
     235    psMetadataAddStr(toprocessedimfileArgs, PS_LIST_TAIL, "-det_id",  0,            "search for detrend ID", NULL);
     236    psMetadataAddStr(toprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "search for exp ID", NULL);
     237    psMetadataAddStr(toprocessedimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "search for class ID", NULL);
     238    psMetadataAddU64(toprocessedimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     239    psMetadataAddBool(toprocessedimfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    395240
    396241    // -addprocessedimfile
    397242    psMetadata *addprocessedimfileArgs = psMetadataAlloc();
    398     psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-det_id",  0,
    399             "define detrend ID (required)", NULL);
    400     psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,
    401             "define exp ID (required)", NULL);
    402     psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-class_id",  0,
    403             "define class ID (required)", NULL);
    404     psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-uri",  0,
    405             "define URI", NULL);
    406     psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-recip",  0,
    407             "define recipe", NULL);
    408     psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-bg",  0,
    409             "define exposure background", NAN);
    410     psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-bg_stdev",  0,
    411             "define exposure background stdev", NAN);
    412     psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,
    413             "define exposure background mean stdev", NAN);
    414     psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-fringe_0",  0,
    415             "define fringe slope (0th term)", NAN);
    416     psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-fringe_1",  0,
    417             "define fringe slope (1st term)", NAN);
    418     psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-fringe_2",  0,
    419             "define fringe slope (2nd term)", NAN);
    420     psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-user_1",  0,
    421             "define user statistic (1)", NAN);
    422     psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-user_2",  0,
    423             "define user statistic (2)", NAN);
    424     psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-user_3",  0,
    425             "define user statistic (3)", NAN);
    426     psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-user_4",  0,
    427             "define user statistic (4)", NAN);
    428     psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-user_5",  0,
    429             "define user statistic (5)", NAN);
    430     psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-path_base",  0,
    431             "define base output location", NULL);
    432     psMetadataAddS16(addprocessedimfileArgs, PS_LIST_TAIL, "-code",  0,
    433             "set fault code", 0);
     243    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-det_id",  0,            "define detrend ID (required)", NULL);
     244    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "define exp ID (required)", NULL);
     245    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "define class ID (required)", NULL);
     246    psMetadataAddS16(addprocessedimfileArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
     247    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-uri",  0,            "define URI", NULL);
     248    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-recip",  0,            "define recipe", NULL);
     249    psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-bg",  0,            "define exposure background", NAN);
     250    psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-bg_stdev",  0,            "define exposure background stdev", NAN);
     251    psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,            "define exposure background mean stdev", NAN);
     252    psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-fringe_0",  0,            "define fringe slope (0th term)", NAN);
     253    psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-fringe_1",  0,            "define fringe slope (1st term)", NAN);
     254    psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-fringe_2",  0,            "define fringe slope (2nd term)", NAN);
     255    psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-user_1",  0,            "define user statistic (1)", NAN);
     256    psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-user_2",  0,            "define user statistic (2)", NAN);
     257    psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-user_3",  0,            "define user statistic (3)", NAN);
     258    psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-user_4",  0,            "define user statistic (4)", NAN);
     259    psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-user_5",  0,            "define user statistic (5)", NAN);
     260    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-path_base",  0,            "define base output location", NULL);
    434261
    435262    // -processedimfile
    436263    psMetadata *processedimfileArgs = psMetadataAlloc();
    437     psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-det_id",  0,
    438             "search for detrend ID", NULL);
    439     psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,
    440             "search for exp ID", NULL);
    441     psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-class_id",  0,
    442             "search for class ID", NULL);
    443     psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-select_state",  0,
    444             "search for state", NULL);
    445     psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-select_mode",  0,
    446             "search for mode", NULL);
    447     psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-chip",  0,
    448             "restrict results to completed 'chip' sets", false);
    449     psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-exp",  0,
    450             "restrict results to complete 'exposures'", false);
    451     psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-included",  0,
    452             "restrict results to exposures 'includeded' in the current iteration", false);
    453     psMetadataAddU64(processedimfileArgs, PS_LIST_TAIL, "-limit",  0,
    454             "limit result set to N items", 0);
    455     psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-faulted",  0,
    456             "only return imfiles with a fault status set", false);
    457     psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-simple",  0,
    458             "use the simple output format", false);
     264    psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-det_id",  0,            "search for detrend ID", NULL);
     265    psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "search for exp ID", NULL);
     266    psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "search for class ID", NULL);
     267    psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-select_state",  0,            "search for state", NULL);
     268    psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-select_mode",  0,            "search for mode", NULL);
     269    psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-included",  0,            "restrict results to exposures 'includeded' in the current iteration", false);
     270    psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-faulted",  0,            "only return imfiles with a fault status set", false);
     271    psMetadataAddU64(processedimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     272    psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     273
     274    // XXX these don't seem to be used anymore
     275    // psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-chip",  0,            "restrict results to completed 'chip' sets", false);
     276    // psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-exp",  0,            "restrict results to complete 'exposures'", false);
    459277
    460278    // -revertprocessedimfile
    461279    psMetadata *revertprocessedimfileArgs = psMetadataAlloc();
    462     psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-det_id",  0,
    463             "search for detrend ID (required)", NULL);
    464     psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,
    465             "search by exposure ID", NULL);
    466     psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-class_id",  0,
    467             "search by class ID", NULL);
    468     psMetadataAddS16(revertprocessedimfileArgs, PS_LIST_TAIL, "-code",  0,
    469             "search by fault code", 0);
     280    psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-det_id",  0,            "search for detrend ID (required)", NULL);
     281    psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exposure ID", NULL);
     282    psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "search by class ID", NULL);
     283    psMetadataAddS16(revertprocessedimfileArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
    470284
    471285    // -toprocessedexp
    472286    psMetadata *toprocessedexpArgs = psMetadataAlloc();
    473     psMetadataAddU64(toprocessedexpArgs, PS_LIST_TAIL, "-limit",  0,
    474             "limit result set to N items", 0);
    475     psMetadataAddBool(toprocessedexpArgs, PS_LIST_TAIL, "-simple",  0,
    476             "use the simple output format", false);
     287    psMetadataAddU64(toprocessedexpArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     288    psMetadataAddBool(toprocessedexpArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    477289
    478290    // -addproccessedexp
    479291    psMetadata *addprocessedexpArgs = psMetadataAlloc();
    480     psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-det_id",  0,
    481             "define detrend ID (required)", NULL);
    482     psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-exp_id",  0,
    483             "define detrend ID (required)", NULL);
    484     psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-recip",  0,
    485             "define recipe", NULL);
    486     psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-bg",  0,
    487             "define exposure background", NAN);
    488     psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-bg_stdev",  0,
    489             "define exposure background stdev", NAN);
    490     psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,
    491             "define exposure background mean stdev", NAN);
    492     psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-fringe_0",  0,
    493             "define fringe slope (0th term)", NAN);
    494     psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-fringe_1",  0,
    495             "define fringe slope (1st term)", NAN);
    496     psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-fringe_2",  0,
    497             "define fringe slope (2nd term)", NAN);
    498     psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-user_1",  0,
    499             "define user statistic (1)", NAN);
    500     psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-user_2",  0,
    501             "define user statistic (2)", NAN);
    502     psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-user_3",  0,
    503             "define user statistic (3)", NAN);
    504     psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-user_4",  0,
    505             "define user statistic (4)", NAN);
    506     psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-user_5",  0,
    507             "define user statistic (5)", NAN);
    508     psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-path_base",  0,
    509             "define base output location", NULL);
    510     psMetadataAddS16(addprocessedexpArgs, PS_LIST_TAIL, "-code",  0,
    511             "set fault code", 0);
     292    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-det_id",  0,            "define detrend ID (required)", NULL);
     293    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-exp_id",  0,            "define detrend ID (required)", NULL);
     294    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-recip",  0,            "define recipe", NULL);
     295    psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-bg",  0,            "define exposure background", NAN);
     296    psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-bg_stdev",  0,            "define exposure background stdev", NAN);
     297    psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,            "define exposure background mean stdev", NAN);
     298    psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-fringe_0",  0,            "define fringe slope (0th term)", NAN);
     299    psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-fringe_1",  0,            "define fringe slope (1st term)", NAN);
     300    psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-fringe_2",  0,            "define fringe slope (2nd term)", NAN);
     301    psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-user_1",  0,            "define user statistic (1)", NAN);
     302    psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-user_2",  0,            "define user statistic (2)", NAN);
     303    psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-user_3",  0,            "define user statistic (3)", NAN);
     304    psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-user_4",  0,            "define user statistic (4)", NAN);
     305    psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-user_5",  0,            "define user statistic (5)", NAN);
     306    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-path_base",  0,            "define base output location", NULL);
     307    psMetadataAddS16(addprocessedexpArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
    512308
    513309    // -proccessedexp
    514310    psMetadata *processedexpArgs = psMetadataAlloc();
    515     psMetadataAddStr(processedexpArgs, PS_LIST_TAIL, "-det_id",  0,
    516             "define detrend ID", NULL);
    517     psMetadataAddStr(processedexpArgs, PS_LIST_TAIL, "-exp_id",  0,
    518             "define detrend ID", NULL);
    519     psMetadataAddU64(processedexpArgs, PS_LIST_TAIL, "-limit",  0,
    520             "limit result set to N items", 0);
    521     psMetadataAddBool(processedexpArgs, PS_LIST_TAIL, "-faulted",  0,
    522             "only return imfiles with a fault status set", false);
    523     psMetadataAddBool(processedexpArgs, PS_LIST_TAIL, "-simple",  0,
    524             "use the simple output format", false);
     311    psMetadataAddStr(processedexpArgs, PS_LIST_TAIL, "-det_id",  0,            "search by detrend ID", NULL);
     312    psMetadataAddStr(processedexpArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exp ID", NULL);
     313    psMetadataAddU64(processedexpArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     314    psMetadataAddBool(processedexpArgs, PS_LIST_TAIL, "-faulted",  0,            "only return imfiles with a fault status set", false);
     315    psMetadataAddBool(processedexpArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    525316
    526317    // -revertprocessedexp
    527318    psMetadata *revertprocessedexpArgs = psMetadataAlloc();
    528     psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-det_id",  0,
    529             "search by detrend ID (required)", NULL);
    530     psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-exp_id",  0,
    531             "search by exposure ID", NULL);
    532     psMetadataAddS16(revertprocessedexpArgs, PS_LIST_TAIL, "-code",  0,
    533             "search by fault code", 0);
     319    psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-det_id",  0,            "search by detrend ID (required)", NULL);
     320    psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exposure ID", NULL);
     321    psMetadataAddS16(revertprocessedexpArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
    534322
    535323    // -tostacked
    536324    psMetadata *tostackedArgs = psMetadataAlloc();
    537     psMetadataAddU64(tostackedArgs, PS_LIST_TAIL, "-limit",  0,
    538             "limit result set to N items", 0);
    539     psMetadataAddBool(tostackedArgs, PS_LIST_TAIL, "-simple",  0,
    540             "use the simple output format", false);
     325    psMetadataAddU64(tostackedArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     326    psMetadataAddBool(tostackedArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    541327
    542328    // -addstacked
    543329    psMetadata *addstackedArgs = psMetadataAlloc();
    544     psMetadataAddStr(addstackedArgs, PS_LIST_TAIL, "-det_id",  0,
    545             "define detrend ID (required)", NULL);
    546     psMetadataAddS32(addstackedArgs, PS_LIST_TAIL, "-iteration",  0,
    547             "define iteration number", 0);
    548     psMetadataAddStr(addstackedArgs, PS_LIST_TAIL, "-class_id",  0,
    549             "define class ID (required)", NULL);
    550     psMetadataAddStr(addstackedArgs, PS_LIST_TAIL, "-recip",  0,
    551             "define recipe", NULL);
    552     psMetadataAddF64(addstackedArgs, PS_LIST_TAIL, "-bg",  0,
    553             "define exposure background", NAN);
    554     psMetadataAddF64(addstackedArgs, PS_LIST_TAIL, "-bg_stdev",  0,
    555             "define exposure background stdev", NAN);
    556     psMetadataAddF64(addstackedArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,
    557             "define exposure background mean stdev", NAN);
    558     psMetadataAddF64(addstackedArgs, PS_LIST_TAIL, "-user_1",  0,
    559             "define user statistic (1)", NAN);
    560     psMetadataAddF64(addstackedArgs, PS_LIST_TAIL, "-user_2",  0,
    561             "define user statistic (2)", NAN);
    562     psMetadataAddF64(addstackedArgs, PS_LIST_TAIL, "-user_3",  0,
    563             "define user statistic (3)", NAN);
    564     psMetadataAddF64(addstackedArgs, PS_LIST_TAIL, "-user_4",  0,
    565             "define user statistic (4)", NAN);
    566     psMetadataAddF64(addstackedArgs, PS_LIST_TAIL, "-user_5",  0,
    567             "define user statistic (5)", NAN);
    568     psMetadataAddStr(addstackedArgs, PS_LIST_TAIL, "-uri",  0,
    569             "define URI", NULL);
    570     psMetadataAddS16(addstackedArgs, PS_LIST_TAIL, "-code",  0,
    571             "set fault code", 0);
     330    psMetadataAddStr(addstackedArgs, PS_LIST_TAIL, "-det_id",  0,            "define detrend ID (required)", NULL);
     331    psMetadataAddS32(addstackedArgs, PS_LIST_TAIL, "-iteration",  0,            "define iteration number (required)", 0);
     332    psMetadataAddStr(addstackedArgs, PS_LIST_TAIL, "-class_id",  0,            "define class ID (required)", NULL);
     333    psMetadataAddS16(addstackedArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
     334    psMetadataAddStr(addstackedArgs, PS_LIST_TAIL, "-uri",  0,            "define URI", NULL);
     335    psMetadataAddStr(addstackedArgs, PS_LIST_TAIL, "-recip",  0,            "define recipe", NULL);
     336    psMetadataAddF64(addstackedArgs, PS_LIST_TAIL, "-bg",  0,            "define exposure background", NAN);
     337    psMetadataAddF64(addstackedArgs, PS_LIST_TAIL, "-bg_stdev",  0,            "define exposure background stdev", NAN);
     338    psMetadataAddF64(addstackedArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,            "define exposure background mean stdev", NAN);
     339    psMetadataAddF64(addstackedArgs, PS_LIST_TAIL, "-user_1",  0,            "define user statistic (1)", NAN);
     340    psMetadataAddF64(addstackedArgs, PS_LIST_TAIL, "-user_2",  0,            "define user statistic (2)", NAN);
     341    psMetadataAddF64(addstackedArgs, PS_LIST_TAIL, "-user_3",  0,            "define user statistic (3)", NAN);
     342    psMetadataAddF64(addstackedArgs, PS_LIST_TAIL, "-user_4",  0,            "define user statistic (4)", NAN);
     343    psMetadataAddF64(addstackedArgs, PS_LIST_TAIL, "-user_5",  0,            "define user statistic (5)", NAN);
    572344
    573345    // -stacked
    574346    psMetadata *stackedArgs = psMetadataAlloc();
    575     psMetadataAddStr(stackedArgs, PS_LIST_TAIL, "-det_id",  0,
    576             "search for detrend ID", NULL);
    577     psMetadataAddS32(stackedArgs, PS_LIST_TAIL, "-iteration",  0,
    578             "search for iteration number", 0);
    579     psMetadataAddStr(stackedArgs, PS_LIST_TAIL, "-class_id",  0,
    580             "search for class ID", NULL);
    581     psMetadataAddStr(stackedArgs, PS_LIST_TAIL, "-recip",  0,
    582             "search for recipe", NULL);
    583     psMetadataAddU64(stackedArgs, PS_LIST_TAIL, "-limit",  0,
    584             "limit result set to N items", 0);
    585     psMetadataAddBool(stackedArgs, PS_LIST_TAIL, "-faulted",  0,
    586             "only return imfiles with a fault status set", false);
    587     psMetadataAddBool(stackedArgs, PS_LIST_TAIL, "-simple",  0,
    588             "use the simple output format", false);
     347    psMetadataAddStr(stackedArgs, PS_LIST_TAIL, "-det_id",  0,            "search for detrend ID", NULL);
     348    psMetadataAddS32(stackedArgs, PS_LIST_TAIL, "-iteration",  0,            "search for iteration number", 0);
     349    psMetadataAddStr(stackedArgs, PS_LIST_TAIL, "-class_id",  0,            "search for class ID", NULL);
     350    psMetadataAddStr(stackedArgs, PS_LIST_TAIL, "-recip",  0,            "search for recipe", NULL);
     351    psMetadataAddU64(stackedArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     352    psMetadataAddBool(stackedArgs, PS_LIST_TAIL, "-faulted",  0,            "only return imfiles with a fault status set", false);
     353    psMetadataAddBool(stackedArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    589354
    590355    // -revertstacked
    591356    psMetadata *revertstackedArgs= psMetadataAlloc();
    592     psMetadataAddStr(revertstackedArgs, PS_LIST_TAIL, "-det_id",  0,
    593             "search for detrend ID (required)", NULL);
    594     psMetadataAddS32(revertstackedArgs, PS_LIST_TAIL, "-iteration",  0,
    595             "search by iteration number", 0);
    596     psMetadataAddStr(revertstackedArgs, PS_LIST_TAIL, "-class_id",  0,
    597             "search by class ID", NULL);
    598     psMetadataAddS16(revertstackedArgs, PS_LIST_TAIL, "-code",  0,
    599             "search by fault code", 0);
     357    psMetadataAddStr(revertstackedArgs, PS_LIST_TAIL, "-det_id",  0,            "search for detrend ID (required)", NULL);
     358    psMetadataAddS32(revertstackedArgs, PS_LIST_TAIL, "-iteration",  0,            "search by iteration number", 0);
     359    psMetadataAddStr(revertstackedArgs, PS_LIST_TAIL, "-class_id",  0,            "search by class ID", NULL);
     360    psMetadataAddS16(revertstackedArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
     361
     362    // -tonormalizedstat
     363    psMetadata *tonormalizedstatArgs = psMetadataAlloc();
     364    psMetadataAddU64(tonormalizedstatArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     365    psMetadataAddBool(tonormalizedstatArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     366
     367    // -addnormalizedstat
     368    psMetadata *addnormstatArgs = psMetadataAlloc();
     369    psMetadataAddStr(addnormstatArgs, PS_LIST_TAIL, "-det_id",  0,            "define detrend ID (required)", NULL);
     370    psMetadataAddS32(addnormstatArgs, PS_LIST_TAIL, "-iteration",  0,            "define iteration number", 0);
     371    psMetadataAddStr(addnormstatArgs, PS_LIST_TAIL, "-class_id",  0,            "define class ID (required)", NULL);
     372    psMetadataAddF32(addnormstatArgs, PS_LIST_TAIL, "-norm",  0,            "define normal value (required)", NAN);
     373    psMetadataAddS16(addnormstatArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
     374
     375    // -normalizedstat
     376    psMetadata *normalizedstatArgs = psMetadataAlloc();
     377    psMetadataAddStr(normalizedstatArgs, PS_LIST_TAIL, "-det_id",  0,            "search by detrend ID", NULL);
     378    psMetadataAddS32(normalizedstatArgs, PS_LIST_TAIL, "-iteration",  0,            "search by iteration number", 0);
     379    psMetadataAddStr(normalizedstatArgs, PS_LIST_TAIL, "-class_id",  0,            "search by class ID", NULL);
     380    psMetadataAddU64(normalizedstatArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     381    psMetadataAddBool(normalizedstatArgs, PS_LIST_TAIL, "-faulted",  0,            "only return imfiles with a fault status set", false);
     382    psMetadataAddBool(normalizedstatArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     383
     384    // -revertnormalizedstat
     385    psMetadata *revertnormalizedstatArgs= psMetadataAlloc();
     386    psMetadataAddStr(revertnormalizedstatArgs, PS_LIST_TAIL, "-det_id",  0,            "search by detrend ID (required)", NULL);
     387    psMetadataAddS32(revertnormalizedstatArgs, PS_LIST_TAIL, "-iteration",  0,            "search by iteration number", 0);
     388    psMetadataAddStr(revertnormalizedstatArgs, PS_LIST_TAIL, "-class_id",  0,            "search by class ID", NULL);
     389    psMetadataAddS16(revertnormalizedstatArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
    600390
    601391    // -tonormalize
    602392    psMetadata *tonormalizeArgs = psMetadataAlloc();
    603     psMetadataAddU64(tonormalizeArgs, PS_LIST_TAIL, "-limit",  0,
    604             "limit result set to N items", 0);
    605     psMetadataAddBool(tonormalizeArgs, PS_LIST_TAIL, "-simple",  0,
    606             "use the simple output format", false);
    607 
    608     // -addnormalizedstat
    609     psMetadata *addnormstatArgs = psMetadataAlloc();
    610     psMetadataAddStr(addnormstatArgs, PS_LIST_TAIL, "-det_id",  0,
    611             "define detrend ID (required)", NULL);
    612     psMetadataAddS32(addnormstatArgs, PS_LIST_TAIL, "-iteration",  0,
    613             "define iteration number", 0);
    614     psMetadataAddStr(addnormstatArgs, PS_LIST_TAIL, "-class_id",  0,
    615             "define class ID (required)", NULL);
    616     psMetadataAddF32(addnormstatArgs, PS_LIST_TAIL, "-norm",  0,
    617             "define normal value (required)", NAN);
    618     psMetadataAddS16(addnormstatArgs, PS_LIST_TAIL, "-code",  0,
    619             "set fault code", 0);
    620 
    621     // -normalizedstat
    622     psMetadata *normalizedstatArgs = psMetadataAlloc();
    623     psMetadataAddStr(normalizedstatArgs, PS_LIST_TAIL, "-det_id",  0,
    624             "search by detrend ID", NULL);
    625     psMetadataAddS32(normalizedstatArgs, PS_LIST_TAIL, "-iteration",  0,
    626             "search by iteration number", 0);
    627     psMetadataAddStr(normalizedstatArgs, PS_LIST_TAIL, "-class_id",  0,
    628             "search by class ID", NULL);
    629     psMetadataAddU64(normalizedstatArgs, PS_LIST_TAIL, "-limit",  0,
    630             "limit result set to N items", 0);
    631     psMetadataAddBool(normalizedstatArgs, PS_LIST_TAIL, "-faulted",  0,
    632             "only return imfiles with a fault status set", false);
    633     psMetadataAddBool(normalizedstatArgs, PS_LIST_TAIL, "-simple",  0,
    634             "use the simple output format", false);
    635 
    636     // -revertnormalizedstat
    637     psMetadata *revertnormalizedstatArgs= psMetadataAlloc();
    638     psMetadataAddStr(revertnormalizedstatArgs, PS_LIST_TAIL, "-det_id",  0,
    639             "search by detrend ID (required)", NULL);
    640     psMetadataAddS32(revertnormalizedstatArgs, PS_LIST_TAIL, "-iteration",  0,
    641             "search by iteration number", 0);
    642     psMetadataAddStr(revertnormalizedstatArgs, PS_LIST_TAIL, "-class_id",  0,
    643             "search by class ID", NULL);
    644     psMetadataAddS16(revertnormalizedstatArgs, PS_LIST_TAIL, "-code",  0,
    645             "search by fault code", 0);
    646 
    647     // -tonormstat
    648     psMetadata *tonormstatArgs = psMetadataAlloc();
    649     psMetadataAddU64(tonormstatArgs, PS_LIST_TAIL, "-limit",  0,
    650             "limit result set to N items", 0);
    651     psMetadataAddBool(tonormstatArgs, PS_LIST_TAIL, "-simple",  0,
    652             "use the simple output format", false);
     393    psMetadataAddU64(tonormalizeArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     394    psMetadataAddBool(tonormalizeArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    653395
    654396    // -addnormalizedimfile
    655397    psMetadata *addnormalizedimfileArgs = psMetadataAlloc();
    656     psMetadataAddStr(addnormalizedimfileArgs, PS_LIST_TAIL, "-det_id", 0,
    657             "define detrend ID (required)", NULL);
    658     psMetadataAddS32(addnormalizedimfileArgs, PS_LIST_TAIL, "-iteration", 0,
    659             "define iteration number", 0);
    660     psMetadataAddStr(addnormalizedimfileArgs, PS_LIST_TAIL, "-class_id", 0,
    661             "define class ID (required)", NULL);
    662     psMetadataAddStr(addnormalizedimfileArgs, PS_LIST_TAIL, "-uri", 0,
    663             "define URI", NULL);
    664     psMetadataAddF64(addnormalizedimfileArgs, PS_LIST_TAIL, "-bg", 0,
    665             "define exposure background", NAN);
    666     psMetadataAddF64(addnormalizedimfileArgs, PS_LIST_TAIL, "-bg_stdev", 0,
    667             "define exposure background stdev", NAN);
    668     psMetadataAddF64(addnormalizedimfileArgs, PS_LIST_TAIL, "-bg_mean_stdev", 0,
    669             "define exposure background mean stdev", NAN);
    670     psMetadataAddF64(addnormalizedimfileArgs, PS_LIST_TAIL, "-user_1",  0,
    671             "define user statistic (1)", NAN);
    672     psMetadataAddF64(addnormalizedimfileArgs, PS_LIST_TAIL, "-user_2",  0,
    673             "define user statistic (2)", NAN);
    674     psMetadataAddF64(addnormalizedimfileArgs, PS_LIST_TAIL, "-user_3",  0,
    675             "define user statistic (3)", NAN);
    676     psMetadataAddF64(addnormalizedimfileArgs, PS_LIST_TAIL, "-user_4",  0,
    677             "define user statistic (4)", NAN);
    678     psMetadataAddF64(addnormalizedimfileArgs, PS_LIST_TAIL, "-user_5",  0,
    679             "define user statistic (5)", NAN);
    680     psMetadataAddStr(addnormalizedimfileArgs, PS_LIST_TAIL, "-path_base", 0,
    681             "define base output location", NULL);
    682     psMetadataAddS16(addnormalizedimfileArgs, PS_LIST_TAIL, "-code",  0,
    683             "set fault code", 0);
     398    psMetadataAddStr(addnormalizedimfileArgs, PS_LIST_TAIL, "-det_id", 0,            "define detrend ID (required)", NULL);
     399    psMetadataAddS32(addnormalizedimfileArgs, PS_LIST_TAIL, "-iteration", 0,            "define iteration number", 0);
     400    psMetadataAddStr(addnormalizedimfileArgs, PS_LIST_TAIL, "-class_id", 0,            "define class ID (required)", NULL);
     401    psMetadataAddS16(addnormalizedimfileArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
     402    psMetadataAddStr(addnormalizedimfileArgs, PS_LIST_TAIL, "-uri", 0,            "define URI", NULL);
     403    psMetadataAddF64(addnormalizedimfileArgs, PS_LIST_TAIL, "-bg", 0,            "define exposure background", NAN);
     404    psMetadataAddF64(addnormalizedimfileArgs, PS_LIST_TAIL, "-bg_stdev", 0,            "define exposure background stdev", NAN);
     405    psMetadataAddF64(addnormalizedimfileArgs, PS_LIST_TAIL, "-bg_mean_stdev", 0,            "define exposure background mean stdev", NAN);
     406    psMetadataAddF64(addnormalizedimfileArgs, PS_LIST_TAIL, "-user_1",  0,            "define user statistic (1)", NAN);
     407    psMetadataAddF64(addnormalizedimfileArgs, PS_LIST_TAIL, "-user_2",  0,            "define user statistic (2)", NAN);
     408    psMetadataAddF64(addnormalizedimfileArgs, PS_LIST_TAIL, "-user_3",  0,            "define user statistic (3)", NAN);
     409    psMetadataAddF64(addnormalizedimfileArgs, PS_LIST_TAIL, "-user_4",  0,            "define user statistic (4)", NAN);
     410    psMetadataAddF64(addnormalizedimfileArgs, PS_LIST_TAIL, "-user_5",  0,            "define user statistic (5)", NAN);
     411    psMetadataAddStr(addnormalizedimfileArgs, PS_LIST_TAIL, "-path_base", 0,            "define base output location", NULL);
    684412
    685413    // -normalizedimfile
    686414    psMetadata *normalizedimfileArgs = psMetadataAlloc();
    687     psMetadataAddStr(normalizedimfileArgs, PS_LIST_TAIL, "-det_id",  0,
    688             "search for detrend ID", NULL);
    689     psMetadataAddS32(normalizedimfileArgs, PS_LIST_TAIL, "-iteration",  0,
    690             "search for iteration number", 0);
    691     psMetadataAddStr(normalizedimfileArgs, PS_LIST_TAIL, "-class_id",  0,
    692             "search for class ID", NULL);
    693     psMetadataAddStr(normalizedimfileArgs, PS_LIST_TAIL, "-recip",  0,
    694             "search for recipe", NULL);
    695     psMetadataAddU64(normalizedimfileArgs, PS_LIST_TAIL, "-limit",  0,
    696             "limit result set to N items", 0);
    697     psMetadataAddBool(normalizedimfileArgs, PS_LIST_TAIL, "-faulted",  0,
    698             "only return imfiles with a fault status set", false);
    699     psMetadataAddBool(normalizedimfileArgs, PS_LIST_TAIL, "-simple",  0,
    700             "use the simple output format", false);
     415    psMetadataAddStr(normalizedimfileArgs, PS_LIST_TAIL, "-det_id",  0,            "search for detrend ID", NULL);
     416    psMetadataAddS32(normalizedimfileArgs, PS_LIST_TAIL, "-iteration",  0,            "search for iteration number", 0);
     417    psMetadataAddStr(normalizedimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "search for class ID", NULL);
     418    psMetadataAddStr(normalizedimfileArgs, PS_LIST_TAIL, "-recip",  0,            "search for recipe", NULL);
     419    psMetadataAddU64(normalizedimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     420    psMetadataAddBool(normalizedimfileArgs, PS_LIST_TAIL, "-faulted",  0,            "only return imfiles with a fault status set", false);
     421    psMetadataAddBool(normalizedimfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    701422
    702423    // -revertnormalizedimfile
    703424    psMetadata *revertnormalizedimfileArgs = psMetadataAlloc();
    704     psMetadataAddStr(revertnormalizedimfileArgs, PS_LIST_TAIL, "-det_id", 0,
    705             "search by detrend ID (required)", NULL);
    706     psMetadataAddS32(revertnormalizedimfileArgs, PS_LIST_TAIL, "-iteration", 0,
    707             "search by iteration number", 0);
    708     psMetadataAddStr(revertnormalizedimfileArgs, PS_LIST_TAIL, "-class_id", 0,
    709             "search by class ID", NULL);
    710     psMetadataAddS16(revertnormalizedimfileArgs, PS_LIST_TAIL, "-code",  0,
    711             "search by fault code", 0);
     425    psMetadataAddStr(revertnormalizedimfileArgs, PS_LIST_TAIL, "-det_id", 0,            "search by detrend ID (required)", NULL);
     426    psMetadataAddS32(revertnormalizedimfileArgs, PS_LIST_TAIL, "-iteration", 0,            "search by iteration number", 0);
     427    psMetadataAddStr(revertnormalizedimfileArgs, PS_LIST_TAIL, "-class_id", 0,            "search by class ID", NULL);
     428    psMetadataAddS16(revertnormalizedimfileArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
     429
     430    XXX EAM : cleaned to this point
     431        break into separate files
    712432
    713433    // -tonormalizedexp
    714434    psMetadata *tonormalizedexpArgs = psMetadataAlloc();
    715     psMetadataAddU64(tonormalizedexpArgs, PS_LIST_TAIL, "-limit",  0,
    716             "limit result set to N items", 0);
    717     psMetadataAddBool(tonormalizedexpArgs, PS_LIST_TAIL, "-simple",  0,
    718             "use the simple output format", false);
     435    psMetadataAddU64(tonormalizedexpArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     436    psMetadataAddBool(tonormalizedexpArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    719437
    720438    // -addnormalizedexp
    721439    psMetadata *addnormalizedexpArgs = psMetadataAlloc();
    722     psMetadataAddStr(addnormalizedexpArgs, PS_LIST_TAIL, "-det_id",  0,
    723             "define detrend ID (required)", NULL);
    724     psMetadataAddS32(addnormalizedexpArgs, PS_LIST_TAIL, "-iteration",  0,
    725             "define iteration number", 0);
    726     psMetadataAddStr(addnormalizedexpArgs, PS_LIST_TAIL, "-recip",  0,
    727             "search for recipe", NULL);
    728     psMetadataAddF64(addnormalizedexpArgs, PS_LIST_TAIL, "-bg",  0,
    729             "define exposure background", NAN);
    730     psMetadataAddF64(addnormalizedexpArgs, PS_LIST_TAIL, "-bg_stdev",  0,
    731             "define exposure background stdev", NAN);
    732     psMetadataAddF64(addnormalizedexpArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,
    733             "define exposure background mean stdev", NAN);
    734 
    735     psMetadataAddF64(addnormalizedexpArgs, PS_LIST_TAIL, "-user_1",  0,
    736             "define user statistic (1)", NAN);
    737     psMetadataAddF64(addnormalizedexpArgs, PS_LIST_TAIL, "-user_2",  0,
    738             "define user statistic (2)", NAN);
    739     psMetadataAddF64(addnormalizedexpArgs, PS_LIST_TAIL, "-user_3",  0,
    740             "define user statistic (3)", NAN);
    741     psMetadataAddF64(addnormalizedexpArgs, PS_LIST_TAIL, "-user_4",  0,
    742             "define user statistic (4)", NAN);
    743     psMetadataAddF64(addnormalizedexpArgs, PS_LIST_TAIL, "-user_5",  0,
    744             "define user statistic (5)", NAN);
    745 
    746     psMetadataAddStr(addnormalizedexpArgs, PS_LIST_TAIL, "-path_base",  0,
    747             "define base output location", NULL);
    748     psMetadataAddS16(addnormalizedexpArgs, PS_LIST_TAIL, "-code",  0,
    749             "set fault code", 0);
     440    psMetadataAddStr(addnormalizedexpArgs, PS_LIST_TAIL, "-det_id",  0,            "define detrend ID (required)", NULL);
     441    psMetadataAddS32(addnormalizedexpArgs, PS_LIST_TAIL, "-iteration",  0,            "define iteration number", 0);
     442    psMetadataAddStr(addnormalizedexpArgs, PS_LIST_TAIL, "-recip",  0,            "search for recipe", NULL);
     443    psMetadataAddF64(addnormalizedexpArgs, PS_LIST_TAIL, "-bg",  0,            "define exposure background", NAN);
     444    psMetadataAddF64(addnormalizedexpArgs, PS_LIST_TAIL, "-bg_stdev",  0,            "define exposure background stdev", NAN);
     445    psMetadataAddF64(addnormalizedexpArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,            "define exposure background mean stdev", NAN);
     446    psMetadataAddF64(addnormalizedexpArgs, PS_LIST_TAIL, "-user_1",  0,            "define user statistic (1)", NAN);
     447    psMetadataAddF64(addnormalizedexpArgs, PS_LIST_TAIL, "-user_2",  0,            "define user statistic (2)", NAN);
     448    psMetadataAddF64(addnormalizedexpArgs, PS_LIST_TAIL, "-user_3",  0,            "define user statistic (3)", NAN);
     449    psMetadataAddF64(addnormalizedexpArgs, PS_LIST_TAIL, "-user_4",  0,            "define user statistic (4)", NAN);
     450    psMetadataAddF64(addnormalizedexpArgs, PS_LIST_TAIL, "-user_5",  0,            "define user statistic (5)", NAN);
     451    psMetadataAddStr(addnormalizedexpArgs, PS_LIST_TAIL, "-path_base",  0,            "define base output location", NULL);
     452    psMetadataAddS16(addnormalizedexpArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
    750453
    751454    // -normalizedexp
    752455    psMetadata *normalizedexpArgs = psMetadataAlloc();
    753     psMetadataAddStr(normalizedexpArgs, PS_LIST_TAIL, "-det_id",  0,
    754             "define detrend ID", NULL);
    755     psMetadataAddS32(normalizedexpArgs, PS_LIST_TAIL, "-iteration",  0,
    756             "define iteration number", 0);
    757     psMetadataAddStr(normalizedexpArgs, PS_LIST_TAIL, "-recip",  0,
    758             "search for recipe", NULL);
    759     psMetadataAddF64(normalizedexpArgs, PS_LIST_TAIL, "-bg",  0,
    760             "define exposure background", NAN);
    761     psMetadataAddF64(normalizedexpArgs, PS_LIST_TAIL, "-bg_stdev",  0,
    762             "define exposure background stdev", NAN);
    763     psMetadataAddF64(normalizedexpArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,
    764             "define exposure background mean stdev", NAN);
    765     psMetadataAddStr(normalizedexpArgs, PS_LIST_TAIL, "-path_base",  0,
    766             "define base output location", NULL);
    767     psMetadataAddU64(normalizedexpArgs, PS_LIST_TAIL, "-limit",  0,
    768             "limit result set to N items", 0);
    769     psMetadataAddBool(normalizedexpArgs, PS_LIST_TAIL, "-faulted",  0,
    770             "only return imfiles with a fault status set", false);
    771     psMetadataAddBool(normalizedexpArgs, PS_LIST_TAIL, "-simple",  0,
    772             "use the simple output format", false);
     456    psMetadataAddStr(normalizedexpArgs, PS_LIST_TAIL, "-det_id",  0,            "define detrend ID", NULL);
     457    psMetadataAddS32(normalizedexpArgs, PS_LIST_TAIL, "-iteration",  0,            "define iteration number", 0);
     458    psMetadataAddStr(normalizedexpArgs, PS_LIST_TAIL, "-recip",  0,            "search for recipe", NULL);
     459    psMetadataAddF64(normalizedexpArgs, PS_LIST_TAIL, "-bg",  0,            "define exposure background", NAN);
     460    psMetadataAddF64(normalizedexpArgs, PS_LIST_TAIL, "-bg_stdev",  0,            "define exposure background stdev", NAN);
     461    psMetadataAddF64(normalizedexpArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,            "define exposure background mean stdev", NAN);
     462    psMetadataAddStr(normalizedexpArgs, PS_LIST_TAIL, "-path_base",  0,            "define base output location", NULL);
     463    psMetadataAddU64(normalizedexpArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     464    psMetadataAddBool(normalizedexpArgs, PS_LIST_TAIL, "-faulted",  0,            "only return imfiles with a fault status set", false);
     465    psMetadataAddBool(normalizedexpArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    773466
    774467    // -revertnormalizedexp
    775468    psMetadata *revertnormalizedexpArgs = psMetadataAlloc();
    776     psMetadataAddStr(revertnormalizedexpArgs, PS_LIST_TAIL, "-det_id", 0,
    777             "search by detrend ID (required)", NULL);
    778     psMetadataAddS32(revertnormalizedexpArgs, PS_LIST_TAIL, "-iteration", 0,
    779             "search by iteration number", 0);
    780     psMetadataAddS16(revertnormalizedexpArgs, PS_LIST_TAIL, "-code",  0,
    781             "search by fault code", 0);
     469    psMetadataAddStr(revertnormalizedexpArgs, PS_LIST_TAIL, "-det_id", 0,            "search by detrend ID (required)", NULL);
     470    psMetadataAddS32(revertnormalizedexpArgs, PS_LIST_TAIL, "-iteration", 0,            "search by iteration number", 0);
     471    psMetadataAddS16(revertnormalizedexpArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
    782472
    783473    // -toresidimfile
    784474    psMetadata *toresidimfileArgs = psMetadataAlloc();
    785     psMetadataAddU64(toresidimfileArgs, PS_LIST_TAIL, "-limit",  0,
    786             "limit result set to N items", 0);
    787     psMetadataAddBool(toresidimfileArgs, PS_LIST_TAIL, "-simple",  0,
    788             "use the simple output format", false);
     475    psMetadataAddU64(toresidimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     476    psMetadataAddBool(toresidimfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    789477
    790478    // -toresidexp
    791479    psMetadata *toresidexpArgs = psMetadataAlloc();
    792     psMetadataAddU64(toresidexpArgs, PS_LIST_TAIL, "-limit",  0,
    793             "limit result set to N items", 0);
    794     psMetadataAddBool(toresidexpArgs, PS_LIST_TAIL, "-simple",  0,
    795             "use the simple output format", false);
     480    psMetadataAddU64(toresidexpArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     481    psMetadataAddBool(toresidexpArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    796482
    797483    // -addresidimfile
    798484    psMetadata *addresidimfileArgs = psMetadataAlloc();
    799     psMetadataAddStr(addresidimfileArgs, PS_LIST_TAIL, "-det_id",  0,
    800             "define detrend ID (required)", NULL);
    801     psMetadataAddS32(addresidimfileArgs, PS_LIST_TAIL, "-iteration",  0,
    802             "define iteration number", 0);
    803     psMetadataAddStr(addresidimfileArgs, PS_LIST_TAIL, "-exp_id",  0,
    804             "define detrend ID (required)", NULL);
    805     psMetadataAddStr(addresidimfileArgs, PS_LIST_TAIL, "-class_id",  0,
    806             "define class ID (required)", NULL);
    807     psMetadataAddStr(addresidimfileArgs, PS_LIST_TAIL, "-uri",  0,
    808             "define resid file URI", NULL);
    809     psMetadataAddStr(addresidimfileArgs, PS_LIST_TAIL, "-recip",  0,
    810             "define recipe", NULL);
    811     psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-bg",  0,
    812             "define exposure background", NAN);
    813     psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-bg_stdev",  0,
    814             "define exposure background stdev", NAN);
    815     psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,
    816             "define exposure background mean stdev", NAN);
    817     psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-bg_skewness",  0,
    818             "define exposure background skewness", NAN);
    819     psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-bg_kurtosis",  0,
    820             "define exposure background kurtosis", NAN);
    821     psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-bin_stdev",  0,
    822             "define exposure background binned stdev", NAN);
    823     psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-fringe_0",  0,
    824             "define fringe slope (0th term)", NAN);
    825     psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-fringe_1",  0,
    826             "define fringe slope (1st term)", NAN);
    827     psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-fringe_2",  0,
    828             "define fringe slope (2nd term)", NAN);
    829     psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-fringe_resid_0",  0,
    830             "define fringe residual (0th term)", NAN);
    831     psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-fringe_resid_1",  0,
    832             "define fringe residual (1st term)", NAN);
    833     psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-fringe_resid_2",  0,
    834             "define fringe residual (2nd term)", NAN);
    835     psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-user_1",  0,
    836             "define user statistic (1)", NAN);
    837     psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-user_2",  0,
    838             "define user statistic (2)", NAN);
    839     psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-user_3",  0,
    840             "define user statistic (3)", NAN);
    841     psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-user_4",  0,
    842             "define user statistic (4)", NAN);
    843     psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-user_5",  0,
    844             "define user statistic (5)", NAN);
    845     psMetadataAddStr(addresidimfileArgs, PS_LIST_TAIL, "-path_base",  0,
    846             "define base output location", NULL);
    847     psMetadataAddS16(addresidimfileArgs, PS_LIST_TAIL, "-code",  0,
    848             "set fault code", 0);
     485    psMetadataAddStr(addresidimfileArgs, PS_LIST_TAIL, "-det_id",  0,            "define detrend ID (required)", NULL);
     486    psMetadataAddS32(addresidimfileArgs, PS_LIST_TAIL, "-iteration",  0,            "define iteration number", 0);
     487    psMetadataAddStr(addresidimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "define detrend ID (required)", NULL);
     488    psMetadataAddStr(addresidimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "define class ID (required)", NULL);
     489    psMetadataAddStr(addresidimfileArgs, PS_LIST_TAIL, "-uri",  0,            "define resid file URI", NULL);
     490    psMetadataAddStr(addresidimfileArgs, PS_LIST_TAIL, "-recip",  0,            "define recipe", NULL);
     491    psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-bg",  0,            "define exposure background", NAN);
     492    psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-bg_stdev",  0,            "define exposure background stdev", NAN);
     493    psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,            "define exposure background mean stdev", NAN);
     494    psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-bg_skewness",  0,            "define exposure background skewness", NAN);
     495    psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-bg_kurtosis",  0,            "define exposure background kurtosis", NAN);
     496    psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-bin_stdev",  0,            "define exposure background binned stdev", NAN);
     497    psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-fringe_0",  0,            "define fringe slope (0th term)", NAN);
     498    psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-fringe_1",  0,            "define fringe slope (1st term)", NAN);
     499    psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-fringe_2",  0,            "define fringe slope (2nd term)", NAN);
     500    psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-fringe_resid_0",  0,            "define fringe residual (0th term)", NAN);
     501    psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-fringe_resid_1",  0,            "define fringe residual (1st term)", NAN);
     502    psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-fringe_resid_2",  0,            "define fringe residual (2nd term)", NAN);
     503    psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-user_1",  0,            "define user statistic (1)", NAN);
     504    psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-user_2",  0,            "define user statistic (2)", NAN);
     505    psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-user_3",  0,            "define user statistic (3)", NAN);
     506    psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-user_4",  0,            "define user statistic (4)", NAN);
     507    psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-user_5",  0,            "define user statistic (5)", NAN);
     508    psMetadataAddStr(addresidimfileArgs, PS_LIST_TAIL, "-path_base",  0,            "define base output location", NULL);
     509    psMetadataAddS16(addresidimfileArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
    849510
    850511    // -residimfile
    851512    psMetadata *residimfileArgs = psMetadataAlloc();
    852     psMetadataAddStr(residimfileArgs, PS_LIST_TAIL, "-det_id",  0,
    853             "search for detrend ID", NULL);
    854     psMetadataAddS32(residimfileArgs, PS_LIST_TAIL, "-iteration",  0,
    855             "search for iteration number", 0);
    856     psMetadataAddStr(residimfileArgs, PS_LIST_TAIL, "-exp_id",  0,
    857             "define detrend ID", NULL);
    858     psMetadataAddStr(residimfileArgs, PS_LIST_TAIL, "-class_id",  0,
    859             "search for class ID", NULL);
    860     psMetadataAddStr(residimfileArgs, PS_LIST_TAIL, "-recip",  0,
    861             "search for recipe", NULL);
    862     psMetadataAddU64(residimfileArgs, PS_LIST_TAIL, "-limit",  0,
    863             "limit result set to N items", 0);
    864     psMetadataAddBool(residimfileArgs, PS_LIST_TAIL, "-faulted",  0,
    865             "only return imfiles with a fault status set", false);
    866     psMetadataAddBool(residimfileArgs, PS_LIST_TAIL, "-simple",  0,
    867             "use the simple output format", false);
    868     psMetadataAddStr(residimfileArgs, PS_LIST_TAIL, "-select_state",  0,
    869             "search for state", NULL);
     513    psMetadataAddStr(residimfileArgs, PS_LIST_TAIL, "-det_id",  0,            "search for detrend ID", NULL);
     514    psMetadataAddS32(residimfileArgs, PS_LIST_TAIL, "-iteration",  0,            "search for iteration number", 0);
     515    psMetadataAddStr(residimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "define detrend ID", NULL);
     516    psMetadataAddStr(residimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "search for class ID", NULL);
     517    psMetadataAddStr(residimfileArgs, PS_LIST_TAIL, "-recip",  0,            "search for recipe", NULL);
     518    psMetadataAddU64(residimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     519    psMetadataAddBool(residimfileArgs, PS_LIST_TAIL, "-faulted",  0,            "only return imfiles with a fault status set", false);
     520    psMetadataAddBool(residimfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     521    psMetadataAddStr(residimfileArgs, PS_LIST_TAIL, "-select_state",  0,            "search for state", NULL);
    870522
    871523    // -revertresidimfile
    872524    psMetadata *revertresidimfileArgs =  psMetadataAlloc();
    873     psMetadataAddStr(revertresidimfileArgs, PS_LIST_TAIL, "-det_id", 0,
    874             "search by detrend ID (required)", NULL);
    875     psMetadataAddS32(revertresidimfileArgs, PS_LIST_TAIL, "-iteration", 0,
    876             "search by iteration number", 0);
    877     psMetadataAddStr(revertresidimfileArgs, PS_LIST_TAIL, "-exp_id",  0,
    878             "search by detrend ID", NULL);
    879     psMetadataAddStr(revertresidimfileArgs, PS_LIST_TAIL, "-class_id",  0,
    880             "search for class ID", NULL);
    881     psMetadataAddS16(revertresidimfileArgs, PS_LIST_TAIL, "-code",  0,
    882             "search by fault code", 0);
     525    psMetadataAddStr(revertresidimfileArgs, PS_LIST_TAIL, "-det_id", 0,            "search by detrend ID (required)", NULL);
     526    psMetadataAddS32(revertresidimfileArgs, PS_LIST_TAIL, "-iteration", 0,            "search by iteration number", 0);
     527    psMetadataAddStr(revertresidimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by detrend ID", NULL);
     528    psMetadataAddStr(revertresidimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "search for class ID", NULL);
     529    psMetadataAddS16(revertresidimfileArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
    883530
    884531    // -addresidexp
    885532    psMetadata *addresidexpArgs = psMetadataAlloc();
    886     psMetadataAddStr(addresidexpArgs, PS_LIST_TAIL, "-det_id",  0,
    887             "define detrend ID (required)", NULL);
    888     psMetadataAddS32(addresidexpArgs, PS_LIST_TAIL, "-iteration",  0,
    889             "define iteration number", 0);
    890     psMetadataAddStr(addresidexpArgs, PS_LIST_TAIL, "-exp_id",  0,
    891             "define detrend ID (required)", NULL);
    892     psMetadataAddStr(addresidexpArgs, PS_LIST_TAIL, "-recip",  0,
    893             "define recipe", NULL);
    894     psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-bg",  0,
    895             "define exposure background", NAN);
    896     psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-bg_stdev",  0,
    897             "define exposure background stdev", NAN);
    898     psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,
    899             "define exposure background mean stdev", NAN);
    900     psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-bg_skewness",  0,
    901             "define exposure background skewness", NAN);
    902     psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-bg_kurtosis",  0,
    903             "define exposure background kurtosis", NAN);
    904     psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-bin_stdev",  0,
    905             "define exposure background binned stdev", NAN);
    906     psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-fringe_0",  0,
    907             "define fringe slope (0th term)", NAN);
    908     psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-fringe_1",  0,
    909             "define fringe slope (1st term)", NAN);
    910     psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-fringe_2",  0,
    911             "define fringe slope (2nd term)", NAN);
    912     psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-fringe_resid_0",  0,
    913             "define fringe residual (0th term)", NAN);
    914     psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-fringe_resid_1",  0,
    915             "define fringe residual (1st term)", NAN);
    916     psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-fringe_resid_2",  0,
    917             "define fringe residual (2nd term)", NAN);
    918     psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-user_1",  0,
    919             "define user statistic (1)", NAN);
    920     psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-user_2",  0,
    921             "define user statistic (2)", NAN);
    922     psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-user_3",  0,
    923             "define user statistic (3)", NAN);
    924     psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-user_4",  0,
    925             "define user statistic (4)", NAN);
    926     psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-user_5",  0,
    927             "define user statistic (5)", NAN);
    928     psMetadataAddStr(addresidexpArgs, PS_LIST_TAIL, "-path_base",  0,
    929             "define base output location", NULL);
    930     psMetadataAddS16(addresidexpArgs, PS_LIST_TAIL, "-code",  0,
    931             "set fault code", 0);
    932     psMetadataAddBool(addresidexpArgs, PS_LIST_TAIL, "-reject",  0,
    933             "exposure is not to be stacked in the next iteration", false);
     533    psMetadataAddStr(addresidexpArgs, PS_LIST_TAIL, "-det_id",  0,            "define detrend ID (required)", NULL);
     534    psMetadataAddS32(addresidexpArgs, PS_LIST_TAIL, "-iteration",  0,            "define iteration number", 0);
     535    psMetadataAddStr(addresidexpArgs, PS_LIST_TAIL, "-exp_id",  0,            "define detrend ID (required)", NULL);
     536    psMetadataAddStr(addresidexpArgs, PS_LIST_TAIL, "-recip",  0,            "define recipe", NULL);
     537    psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-bg",  0,            "define exposure background", NAN);
     538    psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-bg_stdev",  0,            "define exposure background stdev", NAN);
     539    psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,            "define exposure background mean stdev", NAN);
     540    psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-bg_skewness",  0,            "define exposure background skewness", NAN);
     541    psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-bg_kurtosis",  0,            "define exposure background kurtosis", NAN);
     542    psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-bin_stdev",  0,            "define exposure background binned stdev", NAN);
     543    psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-fringe_0",  0,            "define fringe slope (0th term)", NAN);
     544    psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-fringe_1",  0,            "define fringe slope (1st term)", NAN);
     545    psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-fringe_2",  0,            "define fringe slope (2nd term)", NAN);
     546    psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-fringe_resid_0",  0,            "define fringe residual (0th term)", NAN);
     547    psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-fringe_resid_1",  0,            "define fringe residual (1st term)", NAN);
     548    psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-fringe_resid_2",  0,            "define fringe residual (2nd term)", NAN);
     549    psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-user_1",  0,            "define user statistic (1)", NAN);
     550    psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-user_2",  0,            "define user statistic (2)", NAN);
     551    psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-user_3",  0,            "define user statistic (3)", NAN);
     552    psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-user_4",  0,            "define user statistic (4)", NAN);
     553    psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-user_5",  0,            "define user statistic (5)", NAN);
     554    psMetadataAddStr(addresidexpArgs, PS_LIST_TAIL, "-path_base",  0,            "define base output location", NULL);
     555    psMetadataAddS16(addresidexpArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
     556    psMetadataAddBool(addresidexpArgs, PS_LIST_TAIL, "-reject",  0,            "exposure is not to be stacked in the next iteration", false);
    934557
    935558    // -residexp
    936559    psMetadata *residexpArgs = psMetadataAlloc();
    937     psMetadataAddStr(residexpArgs, PS_LIST_TAIL, "-det_id",  0,
    938             "search for detrend ID", NULL);
    939     psMetadataAddS32(residexpArgs, PS_LIST_TAIL, "-iteration",  0,
    940             "search for iteration number", 0);
    941     psMetadataAddStr(residexpArgs, PS_LIST_TAIL, "-exp_id",  0,
    942             "search for exp ID", NULL);
    943     psMetadataAddStr(residexpArgs, PS_LIST_TAIL, "-recip",  0,
    944             "search for recipe", NULL);
    945     psMetadataAddU64(residexpArgs, PS_LIST_TAIL, "-limit",  0,
    946             "limit result set to N items", 0);
    947     psMetadataAddBool(residexpArgs, PS_LIST_TAIL, "-faulted",  0,
    948             "only return imfiles with a fault status set", false);
    949     psMetadataAddBool(residexpArgs, PS_LIST_TAIL, "-reject",  0,
    950             "search for acceptable residuals", false);
    951     psMetadataAddBool(residexpArgs, PS_LIST_TAIL, "-simple",  0,
    952             "use the simple output format", false);
     560    psMetadataAddStr(residexpArgs, PS_LIST_TAIL, "-det_id",  0,            "search for detrend ID", NULL);
     561    psMetadataAddS32(residexpArgs, PS_LIST_TAIL, "-iteration",  0,            "search for iteration number", 0);
     562    psMetadataAddStr(residexpArgs, PS_LIST_TAIL, "-exp_id",  0,            "search for exp ID", NULL);
     563    psMetadataAddStr(residexpArgs, PS_LIST_TAIL, "-recip",  0,            "search for recipe", NULL);
     564    psMetadataAddU64(residexpArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     565    psMetadataAddBool(residexpArgs, PS_LIST_TAIL, "-faulted",  0,            "only return imfiles with a fault status set", false);
     566    psMetadataAddBool(residexpArgs, PS_LIST_TAIL, "-reject",  0,            "search for acceptable residuals", false);
     567    psMetadataAddBool(residexpArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    953568
    954569    // -revertresidexp
    955570    psMetadata *revertresidexpArgs = psMetadataAlloc();
    956     psMetadataAddStr(revertresidexpArgs, PS_LIST_TAIL, "-det_id", 0,
    957             "search by detrend ID (required)", NULL);
    958     psMetadataAddS32(revertresidexpArgs, PS_LIST_TAIL, "-iteration", 0,
    959             "search by iteration number", 0);
    960     psMetadataAddStr(revertresidexpArgs, PS_LIST_TAIL, "-exp_id",  0,
    961             "search by detrend ID", NULL);
    962     psMetadataAddS16(revertresidexpArgs, PS_LIST_TAIL, "-code",  0,
    963             "search by fault code", 0);
     571    psMetadataAddStr(revertresidexpArgs, PS_LIST_TAIL, "-det_id", 0,            "search by detrend ID (required)", NULL);
     572    psMetadataAddS32(revertresidexpArgs, PS_LIST_TAIL, "-iteration", 0,            "search by iteration number", 0);
     573    psMetadataAddStr(revertresidexpArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by detrend ID", NULL);
     574    psMetadataAddS16(revertresidexpArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
    964575
    965576    // -todetrunsummary
    966577    psMetadata *todetrunsummaryArgs = psMetadataAlloc();
    967     psMetadataAddBool(todetrunsummaryArgs, PS_LIST_TAIL, "-simple",  0,
    968             "use the simple output format", false);
    969     psMetadataAddU64(todetrunsummaryArgs, PS_LIST_TAIL, "-limit",  0,
    970             "limit result set to N items", 0);
     578    psMetadataAddBool(todetrunsummaryArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     579    psMetadataAddU64(todetrunsummaryArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    971580
    972581    // -updateresidexp
    973582    psMetadata *updateresidexpArgs = psMetadataAlloc();
    974     psMetadataAddStr(updateresidexpArgs, PS_LIST_TAIL, "-det_id",  0,
    975             "define detrend ID", NULL);
    976     psMetadataAddS32(updateresidexpArgs, PS_LIST_TAIL, "-iteration",  0,
    977             "define iteration number", 0);
    978     psMetadataAddStr(updateresidexpArgs, PS_LIST_TAIL, "-exp_id",  0,
    979             "define exp ID", NULL);
    980     psMetadataAddStr(updateresidexpArgs, PS_LIST_TAIL, "-recip",  0,
    981             "define recipe", NULL);
    982     psMetadataAddF64(updateresidexpArgs, PS_LIST_TAIL, "-bg",  0,
    983             "define exposure background", NAN);
    984     psMetadataAddF64(updateresidexpArgs, PS_LIST_TAIL, "-bg_stdev",  0,
    985             "define exposure background stdev", NAN);
    986     psMetadataAddF64(updateresidexpArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,
    987             "define exposure background mean stdev", NAN);
    988     psMetadataAddStr(updateresidexpArgs, PS_LIST_TAIL, "-path_base",  0,
    989             "define base output location", NULL);
    990     psMetadataAddBool(updateresidexpArgs, PS_LIST_TAIL, "-reject",  0,
    991             "exposure is not to be stacked in the next iteration", false);
     583    psMetadataAddStr(updateresidexpArgs, PS_LIST_TAIL, "-det_id",  0,            "define detrend ID", NULL);
     584    psMetadataAddS32(updateresidexpArgs, PS_LIST_TAIL, "-iteration",  0,            "define iteration number", 0);
     585    psMetadataAddStr(updateresidexpArgs, PS_LIST_TAIL, "-exp_id",  0,            "define exp ID", NULL);
     586    psMetadataAddStr(updateresidexpArgs, PS_LIST_TAIL, "-recip",  0,            "define recipe", NULL);
     587    psMetadataAddF64(updateresidexpArgs, PS_LIST_TAIL, "-bg",  0,            "define exposure background", NAN);
     588    psMetadataAddF64(updateresidexpArgs, PS_LIST_TAIL, "-bg_stdev",  0,            "define exposure background stdev", NAN);
     589    psMetadataAddF64(updateresidexpArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,            "define exposure background mean stdev", NAN);
     590    psMetadataAddStr(updateresidexpArgs, PS_LIST_TAIL, "-path_base",  0,            "define base output location", NULL);
     591    psMetadataAddBool(updateresidexpArgs, PS_LIST_TAIL, "-reject",  0,            "exposure is not to be stacked in the next iteration", false);
    992592
    993593    // -adddetrunsummary
    994594    psMetadata *adddetrunsummaryArgs = psMetadataAlloc();
    995     psMetadataAddStr(adddetrunsummaryArgs, PS_LIST_TAIL, "-det_id",  0,
    996             "define detrend ID (required)", NULL);
    997     psMetadataAddS32(adddetrunsummaryArgs, PS_LIST_TAIL, "-iteration",  0,
    998             "define iteration number", 0);
    999     psMetadataAddF64(adddetrunsummaryArgs, PS_LIST_TAIL, "-bg",  0,
    1000             "define exposure background", NAN);
    1001     psMetadataAddF64(adddetrunsummaryArgs, PS_LIST_TAIL, "-bg_stdev",  0,
    1002             "define exposure background stdev", NAN);
    1003     psMetadataAddF64(adddetrunsummaryArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,
    1004             "define exposure background mean stdev", NAN);
    1005     psMetadataAddS16(adddetrunsummaryArgs, PS_LIST_TAIL, "-code",  0,
    1006             "set fault code", 0);
    1007     psMetadataAddBool(adddetrunsummaryArgs, PS_LIST_TAIL, "-accept",  0,
    1008             "declare that this detrun iteration is accepted as a master", false);
    1009     psMetadataAddBool(adddetrunsummaryArgs, PS_LIST_TAIL, "-again",  0,
    1010             "start a new iteration of this detrend run", false);
     595    psMetadataAddStr(adddetrunsummaryArgs, PS_LIST_TAIL, "-det_id",  0,            "define detrend ID (required)", NULL);
     596    psMetadataAddS32(adddetrunsummaryArgs, PS_LIST_TAIL, "-iteration",  0,            "define iteration number", 0);
     597    psMetadataAddF64(adddetrunsummaryArgs, PS_LIST_TAIL, "-bg",  0,            "define exposure background", NAN);
     598    psMetadataAddF64(adddetrunsummaryArgs, PS_LIST_TAIL, "-bg_stdev",  0,            "define exposure background stdev", NAN);
     599    psMetadataAddF64(adddetrunsummaryArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,            "define exposure background mean stdev", NAN);
     600    psMetadataAddS16(adddetrunsummaryArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
     601    psMetadataAddBool(adddetrunsummaryArgs, PS_LIST_TAIL, "-accept",  0,            "declare that this detrun iteration is accepted as a master", false);
     602    psMetadataAddBool(adddetrunsummaryArgs, PS_LIST_TAIL, "-again",  0,            "start a new iteration of this detrend run", false);
    1011603
    1012604    // -detrunsummary
    1013605    psMetadata *detrunsummaryArgs = psMetadataAlloc();
    1014     psMetadataAddStr(detrunsummaryArgs, PS_LIST_TAIL, "-det_id",  0,
    1015             "search for detrend ID", NULL);
    1016     psMetadataAddU64(detrunsummaryArgs, PS_LIST_TAIL, "-limit",  0,
    1017                      "limit result set to N items", 0);
    1018     psMetadataAddS32(detrunsummaryArgs, PS_LIST_TAIL, "-iteration",  0,
    1019             "search for iteration number", 0);
    1020     psMetadataAddBool(detrunsummaryArgs, PS_LIST_TAIL, "-faulted",  0,
    1021             "only return imfiles with a fault status set", false);
    1022     psMetadataAddBool(detrunsummaryArgs, PS_LIST_TAIL, "-reject",  0,
    1023             "search for acceptable residuals", false);
    1024     psMetadataAddBool(detrunsummaryArgs, PS_LIST_TAIL, "-simple",  0,
    1025             "use the simple output format", false);
     606    psMetadataAddStr(detrunsummaryArgs, PS_LIST_TAIL, "-det_id",  0,            "search for detrend ID", NULL);
     607    psMetadataAddU64(detrunsummaryArgs, PS_LIST_TAIL, "-limit",  0,                     "limit result set to N items", 0);
     608    psMetadataAddS32(detrunsummaryArgs, PS_LIST_TAIL, "-iteration",  0,            "search for iteration number", 0);
     609    psMetadataAddBool(detrunsummaryArgs, PS_LIST_TAIL, "-faulted",  0,            "only return imfiles with a fault status set", false);
     610    psMetadataAddBool(detrunsummaryArgs, PS_LIST_TAIL, "-reject",  0,            "search for acceptable residuals", false);
     611    psMetadataAddBool(detrunsummaryArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    1026612
    1027613    // -revertdetrunsummary
    1028614    psMetadata *revertdetrunsummaryArgs = psMetadataAlloc();
    1029     psMetadataAddStr(revertdetrunsummaryArgs, PS_LIST_TAIL, "-det_id", 0,
    1030             "search by detrend ID (required)", NULL);
    1031     psMetadataAddS32(revertdetrunsummaryArgs, PS_LIST_TAIL, "-iteration", 0,
    1032             "search by iteration number", 0);
    1033     psMetadataAddS16(revertdetrunsummaryArgs, PS_LIST_TAIL, "-code",  0,
    1034             "search by fault code", 0);
     615    psMetadataAddStr(revertdetrunsummaryArgs, PS_LIST_TAIL, "-det_id", 0,            "search by detrend ID (required)", NULL);
     616    psMetadataAddS32(revertdetrunsummaryArgs, PS_LIST_TAIL, "-iteration", 0,            "search by iteration number", 0);
     617    psMetadataAddS16(revertdetrunsummaryArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
    1035618
    1036619    // -updatedetrunsummary
    1037620    psMetadata *updatedetrunsummaryArgs = psMetadataAlloc();
    1038     psMetadataAddStr(updatedetrunsummaryArgs, PS_LIST_TAIL, "-det_id",  0,
    1039             "search for detrend master for detrend ID (required)", NULL);
    1040     psMetadataAddBool(updatedetrunsummaryArgs, PS_LIST_TAIL, "-accept",  0,
    1041             "declare that this detrun iteration is accepted as a master", false);
    1042     psMetadataAddBool(updatedetrunsummaryArgs, PS_LIST_TAIL, "-reject",  0,
    1043             "reject this detrun iteration as a master", false);
     621    psMetadataAddStr(updatedetrunsummaryArgs, PS_LIST_TAIL, "-det_id",  0,            "search for detrend master for detrend ID (required)", NULL);
     622    psMetadataAddBool(updatedetrunsummaryArgs, PS_LIST_TAIL, "-accept",  0,            "declare that this detrun iteration is accepted as a master", false);
     623    psMetadataAddBool(updatedetrunsummaryArgs, PS_LIST_TAIL, "-reject",  0,            "reject this detrun iteration as a master", false);
    1044624
    1045625    // -updatedetrun
    1046626    psMetadata *updatedetrunArgs = psMetadataAlloc();
    1047     psMetadataAddStr(updatedetrunArgs, PS_LIST_TAIL, "-det_id",  0,
    1048             "search for detrend master for detrend ID (required)", NULL);
    1049     psMetadataAddBool(updatedetrunArgs, PS_LIST_TAIL, "-again",  0,
    1050             "start a new iteration of this detrend run", false);
    1051     psMetadataAddStr(updatedetrunArgs, PS_LIST_TAIL, "-state",  0,
    1052             "set the state of this detrend run", false);
     627    psMetadataAddStr(updatedetrunArgs, PS_LIST_TAIL, "-det_id",  0,            "search for detrend master for detrend ID (required)", NULL);
     628    psMetadataAddBool(updatedetrunArgs, PS_LIST_TAIL, "-again",  0,            "start a new iteration of this detrend run", false);
     629    psMetadataAddStr(updatedetrunArgs, PS_LIST_TAIL, "-state",  0,            "set the state of this detrend run", false);
    1053630
    1054631    // -rerun
    1055632    psMetadata *rerunArgs = psMetadataAlloc();
    1056     psMetadataAddStr(rerunArgs, PS_LIST_TAIL, "-det_id",  0,
    1057             "search for detrend master for detrend ID (required)", NULL);
    1058     psMetadataAddStr(rerunArgs, PS_LIST_TAIL, "-exp_id",  PS_META_DUPLICATE_OK,
    1059             "include this exposure (multiple OK, required)", NULL);
     633    psMetadataAddStr(rerunArgs, PS_LIST_TAIL, "-det_id",  0,            "search for detrend master for detrend ID (required)", NULL);
     634    psMetadataAddStr(rerunArgs, PS_LIST_TAIL, "-exp_id",  PS_META_DUPLICATE_OK,            "include this exposure (multiple OK, required)", NULL);
    1060635
    1061636    // -register_detrend
    1062637    psMetadata *register_detrendArgs = psMetadataAlloc();
    1063     psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-det_type",  0,
    1064             "define the type of detrend run (required)", NULL);
    1065     psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-mode",  0,
    1066             "define the mode of this detrend run", "master");
    1067     psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-filelevel",  0,
    1068             "define filelevel (required)", NULL);
    1069     psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-workdir",  0,
    1070             "define workdir", NULL);
    1071     psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-inst",  0,
    1072             "define camera", NULL);
    1073     psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-telescope",  0,
    1074             "define telescope", NULL);
    1075     psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-exp_type",  0,
    1076             "define exposure type", NULL);
    1077     psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-filter",  0,
    1078             "define filter ", NULL);
    1079     psMetadataAddF32(register_detrendArgs, PS_LIST_TAIL, "-airmass_min",  0,
    1080             "define min airmass", NAN);
    1081     psMetadataAddF32(register_detrendArgs, PS_LIST_TAIL, "-airmass_max",  0,
    1082             "define max airmass", NAN);
    1083     psMetadataAddF32(register_detrendArgs, PS_LIST_TAIL, "-exp_time_min",  0,
    1084             "define min exposure time", NAN);
    1085     psMetadataAddF32(register_detrendArgs, PS_LIST_TAIL, "-exp_time_max",  0,
    1086             "define max exposure time", NAN);
    1087     psMetadataAddF64(register_detrendArgs, PS_LIST_TAIL, "-ccd_temp_min",  0,
    1088             "define min ccd tempature", NAN);
    1089     psMetadataAddF64(register_detrendArgs, PS_LIST_TAIL, "-ccd_temp_max",  0,
    1090             "define max ccd tempature", NAN);
    1091     psMetadataAddF64(register_detrendArgs, PS_LIST_TAIL, "-posang_min",  0,
    1092             "define min rotator position angle", NAN);
    1093     psMetadataAddF64(register_detrendArgs, PS_LIST_TAIL, "-posang_max",  0,
    1094             "define max rotator position angle", NAN);
    1095     psMetadataAddF64(register_detrendArgs, PS_LIST_TAIL, "-solang_min",  0,
    1096             "define min solar angle", NAN);
    1097     psMetadataAddF64(register_detrendArgs, PS_LIST_TAIL, "-solang_max",  0,
    1098             "define max solar angle", NAN);
    1099     psMetadataAddTime(register_detrendArgs, PS_LIST_TAIL, "-registered",  0,
    1100             "time detrend run was registered", now);
    1101     psMetadataAddTime(register_detrendArgs, PS_LIST_TAIL, "-time_begin",  0,
    1102             "detrend applies to exposures taken during this period", NULL);
    1103     psMetadataAddTime(register_detrendArgs, PS_LIST_TAIL, "-time_end",  0,
    1104             "detrend applies to exposures taken during this period", NULL);
    1105     psMetadataAddTime(register_detrendArgs, PS_LIST_TAIL, "-use_begin",  0,
    1106             "start of detrend run applicable period", NULL);
    1107     psMetadataAddTime(register_detrendArgs, PS_LIST_TAIL, "-use_end",  0,
    1108             "end of detrend run applicable period", NULL);
    1109     psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-parent",  0,
    1110             "define parent det_id", NULL);
    1111     psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-label",  0,
    1112             "define detrun label", NULL);
    1113     psMetadataAddBool(register_detrendArgs, PS_LIST_TAIL, "-simple",  0,
    1114             "use the simple output format", false);
     638    psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-det_type",  0,            "define the type of detrend run (required)", NULL);
     639    psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-mode",  0,            "define the mode of this detrend run", "master");
     640    psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-filelevel",  0,            "define filelevel (required)", NULL);
     641    psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-workdir",  0,            "define workdir", NULL);
     642    psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-inst",  0,            "define camera", NULL);
     643    psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-telescope",  0,            "define telescope", NULL);
     644    psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-exp_type",  0,            "define exposure type", NULL);
     645    psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-filter",  0,            "define filter ", NULL);
     646    psMetadataAddF32(register_detrendArgs, PS_LIST_TAIL, "-airmass_min",  0,            "define min airmass", NAN);
     647    psMetadataAddF32(register_detrendArgs, PS_LIST_TAIL, "-airmass_max",  0,            "define max airmass", NAN);
     648    psMetadataAddF32(register_detrendArgs, PS_LIST_TAIL, "-exp_time_min",  0,            "define min exposure time", NAN);
     649    psMetadataAddF32(register_detrendArgs, PS_LIST_TAIL, "-exp_time_max",  0,            "define max exposure time", NAN);
     650    psMetadataAddF64(register_detrendArgs, PS_LIST_TAIL, "-ccd_temp_min",  0,            "define min ccd tempature", NAN);
     651    psMetadataAddF64(register_detrendArgs, PS_LIST_TAIL, "-ccd_temp_max",  0,            "define max ccd tempature", NAN);
     652    psMetadataAddF64(register_detrendArgs, PS_LIST_TAIL, "-posang_min",  0,            "define min rotator position angle", NAN);
     653    psMetadataAddF64(register_detrendArgs, PS_LIST_TAIL, "-posang_max",  0,            "define max rotator position angle", NAN);
     654    psMetadataAddF64(register_detrendArgs, PS_LIST_TAIL, "-solang_min",  0,            "define min solar angle", NAN);
     655    psMetadataAddF64(register_detrendArgs, PS_LIST_TAIL, "-solang_max",  0,            "define max solar angle", NAN);
     656    psMetadataAddTime(register_detrendArgs, PS_LIST_TAIL, "-registered",  0,            "time detrend run was registered", now);
     657    psMetadataAddTime(register_detrendArgs, PS_LIST_TAIL, "-time_begin",  0,            "detrend applies to exposures taken during this period", NULL);
     658    psMetadataAddTime(register_detrendArgs, PS_LIST_TAIL, "-time_end",  0,            "detrend applies to exposures taken during this period", NULL);
     659    psMetadataAddTime(register_detrendArgs, PS_LIST_TAIL, "-use_begin",  0,            "start of detrend run applicable period", NULL);
     660    psMetadataAddTime(register_detrendArgs, PS_LIST_TAIL, "-use_end",  0,            "end of detrend run applicable period", NULL);
     661    psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-parent",  0,            "define parent det_id", NULL);
     662    psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-label",  0,            "define detrun label", NULL);
     663    psMetadataAddBool(register_detrendArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    1115664
    1116665    // -register_detrend_imfile
    1117666    psMetadata *register_detrend_imfileArgs = psMetadataAlloc();
    1118     psMetadataAddStr(register_detrend_imfileArgs, PS_LIST_TAIL, "-det_id",  0,
    1119             "define detrend ID (required)", NULL);
    1120     psMetadataAddStr(register_detrend_imfileArgs, PS_LIST_TAIL, "-class_id",  0,
    1121             "search for class ID (required)", NULL);
    1122     psMetadataAddStr(register_detrend_imfileArgs, PS_LIST_TAIL, "-uri",  0,
    1123             "define resid file URI (required)", NULL);
    1124     psMetadataAddF64(register_detrend_imfileArgs, PS_LIST_TAIL, "-bg",  0,
    1125             "define exposure background", NAN);
    1126     psMetadataAddF64(register_detrend_imfileArgs, PS_LIST_TAIL, "-bg_stdev",  0,
    1127             "define exposure background stdev", NAN);
    1128     psMetadataAddF64(register_detrend_imfileArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,
    1129             "define exposure background mean stdev", NAN);
    1130     psMetadataAddF64(register_detrend_imfileArgs, PS_LIST_TAIL, "-user_1",  0,
    1131             "define user statistic (1)", NAN);
    1132     psMetadataAddF64(register_detrend_imfileArgs, PS_LIST_TAIL, "-user_2",  0,
    1133             "define user statistic (2)", NAN);
    1134     psMetadataAddF64(register_detrend_imfileArgs, PS_LIST_TAIL, "-user_3",  0,
    1135             "define user statistic (3)", NAN);
    1136     psMetadataAddF64(register_detrend_imfileArgs, PS_LIST_TAIL, "-user_4",  0,
    1137             "define user statistic (4)", NAN);
    1138     psMetadataAddF64(register_detrend_imfileArgs, PS_LIST_TAIL, "-user_5",  0,
    1139             "define user statistic (5)", NAN);
    1140     psMetadataAddStr(register_detrend_imfileArgs, PS_LIST_TAIL, "-path_base",  0,
    1141             "define base output location", NULL);
     667    psMetadataAddStr(register_detrend_imfileArgs, PS_LIST_TAIL, "-det_id",  0,            "define detrend ID (required)", NULL);
     668    psMetadataAddStr(register_detrend_imfileArgs, PS_LIST_TAIL, "-class_id",  0,            "search for class ID (required)", NULL);
     669    psMetadataAddStr(register_detrend_imfileArgs, PS_LIST_TAIL, "-uri",  0,            "define resid file URI (required)", NULL);
     670    psMetadataAddF64(register_detrend_imfileArgs, PS_LIST_TAIL, "-bg",  0,            "define exposure background", NAN);
     671    psMetadataAddF64(register_detrend_imfileArgs, PS_LIST_TAIL, "-bg_stdev",  0,            "define exposure background stdev", NAN);
     672    psMetadataAddF64(register_detrend_imfileArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,            "define exposure background mean stdev", NAN);
     673    psMetadataAddF64(register_detrend_imfileArgs, PS_LIST_TAIL, "-user_1",  0,            "define user statistic (1)", NAN);
     674    psMetadataAddF64(register_detrend_imfileArgs, PS_LIST_TAIL, "-user_2",  0,            "define user statistic (2)", NAN);
     675    psMetadataAddF64(register_detrend_imfileArgs, PS_LIST_TAIL, "-user_3",  0,            "define user statistic (3)", NAN);
     676    psMetadataAddF64(register_detrend_imfileArgs, PS_LIST_TAIL, "-user_4",  0,            "define user statistic (4)", NAN);
     677    psMetadataAddF64(register_detrend_imfileArgs, PS_LIST_TAIL, "-user_5",  0,            "define user statistic (5)", NAN);
     678    psMetadataAddStr(register_detrend_imfileArgs, PS_LIST_TAIL, "-path_base",  0,            "define base output location", NULL);
    1142679
    1143680    psFree(now);
    … …  
    1175712    PXOPT_ADD_MODE("-revertnormalizedstat",  "", DETTOOL_MODE_REVERTNORMALIZEDSTAT,   revertnormalizedstatArgs);
    1176713
    1177     PXOPT_ADD_MODE("-tonormalizedstat",      "", DETTOOL_MODE_TONORMALIZEDSTAT,    tonormstatArgs);
     714    PXOPT_ADD_MODE("-tonormalizedstat",      "", DETTOOL_MODE_TONORMALIZEDSTAT,    tonormalizedstatArgs);
    1178715    PXOPT_ADD_MODE("-addnormalizedimfile", "", DETTOOL_MODE_ADDNORMALIZEDIMFILE,addnormalizedimfileArgs);
    1179716    PXOPT_ADD_MODE("-normalizedimfile","", DETTOOL_MODE_NORMALIZEDIMFILE, normalizedimfileArgs);
    … …  
    1213750    psFree(modes);
    1214751
    1215     // setup search criterion
    1216 #define addWhereStr(name) \
    1217 { \
    1218     psString str = NULL; \
    1219     bool status = false; \
    1220     if ((str = psMetadataLookupStr(&status, config->args, "-" #name))) { \
    1221         if (!psMetadataAddStr(config->where, PS_LIST_TAIL, #name, 0, "==", str)) {\
    1222             psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
    1223             psFree(config); \
    1224             return NULL; \
    1225         } \
    1226     } \
    1227 }
    1228 
    1229752    // generate SQL where clause
    1230753    config->where = psMetadataAlloc();
    1231754
    1232755    addWhereStr(det_id);
    1233     {
    1234         // XXX this is broke because you can't specify -iteration 0
    1235         psMetadataItem *item = psMetadataLookup(config->args, "-iteration");
    1236         if (item && psStrcasestr(item->comment, "found")) {
    1237             if (!psMetadataAddS32(config->where, PS_LIST_TAIL, "iteration", 0, "==", item->data.S32)) {
    1238                 psError(PS_ERR_UNKNOWN, false, "failed to add item iteration");
    1239                 psFree(config);
    1240                 return NULL;
    1241             }
    1242         }
    1243     }
    1244     addWhereStr(det_type);
    1245     addWhereStr(exp_id);
    1246     addWhereStr(class_id);
    1247     // convert '-inst' to 'camera'
    1248     {
    1249         psString str = NULL;
    1250         bool status = false;
    1251         if ((str = psMetadataLookupStr(&status, config->args, "-inst"))) {
    1252             if (!psMetadataAddStr(config->where, PS_LIST_TAIL, "camera", 0, "==", str)) {
    1253                 psError(PS_ERR_UNKNOWN, false, "failed to add item camera");
    1254                 psFree(config);
    1255                 return NULL;
    1256             }
    1257         }
    1258     }
    1259     addWhereStr(telescope);
    1260     addWhereStr(exp_type);
    1261     {
    1262         int n = 0;
    1263         bool status = false;
    1264         if ((n = psMetadataLookupS32(&status, config->args, "-imfiles"))) {
    1265             if (!psMetadataAddS32(config->where, PS_LIST_TAIL, "imfiles", 0, "==", n)) {
    1266                 psError(PS_ERR_UNKNOWN, false, "failed to add item imfiles");
    1267                 psFree(config);
    1268                 return NULL;
    1269             }
    1270         }
    1271     }
    1272     addWhereStr(filter);
    1273     addWhereStr(recipe);
    1274     {
    1275         int n = 0;
    1276         bool status = false;
    1277         if ((n = psMetadataLookupS32(&status, config->args, "-guide_version"))) {
    1278             if (!psMetadataAddS32(config->where, PS_LIST_TAIL, "guide_version", 0, "==", n)) {
    1279                 psError(PS_ERR_UNKNOWN, false, "failed to add item guide_version");
    1280                 psFree(config);
    1281                 return NULL;
    1282             }
    1283         }
    1284     }
    1285     {
    1286         bool boolean = false;
    1287         bool status = false;
    1288 
    1289         // map reject -> !accept
    1290         if ((boolean = psMetadataLookupBool(&status, config->args, "-reject"))) {
    1291             if (!psMetadataAddBool(config->where, PS_LIST_TAIL, "accept", 0, "==", !boolean)) {
    1292                 psError(PS_ERR_UNKNOWN, false, "failed to add item reject");
    1293                 psFree(config);
    1294                 return NULL;
    1295             }
    1296         }
    1297     }
    1298 
    1299     // convert '-code' to 'fault'
    1300     {
    1301         psS16 fault = 0;
    1302         bool status = false;
    1303         if ((fault = psMetadataLookupS16(&status, config->args, "-code"))) {
    1304             if (!psMetadataAddS16(config->where, PS_LIST_TAIL, "fault", 0, "==", fault)) {
    1305                 psError(PS_ERR_UNKNOWN, false, "failed to add item fault");
    1306                 psFree(config);
    1307                 return NULL;
    1308             }
    1309         }
    1310     }
     756    PXOPT_ADD_WHERE_S32(iteration);
     757    PXOPT_ADD_WHERE_STR(det_type);
     758    PXOPT_ADD_WHERE_STR(exp_id);
     759    PXOPT_ADD_WHERE_STR(class_id);
     760    PXOPT_ADD_WHERE_STR_ALIAS("-inst","camera");
     761    PXOPT_ADD_WHERE_STR(telescope);
     762    PXOPT_ADD_WHERE_STR(exp_type);
     763    PXOPT_ADD_WHERE_S32(imfiles);
     764    PXOPT_ADD_WHERE_STR(filter);
     765    PXOPT_ADD_WHERE_STR(recipe);
     766    PXOPT_ADD_WHERE_S32(guide_version);
     767    PXOPT_ADD_WHERE_BOOL_ALIAS_INVERT("-reject", "accept");
     768    PXOPT_ADD_WHERE_S16_ALIAS("-code", "fault");
    1311769
    1312770    if (config->where->list->n < 1) {

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

    r18336 r18468  
    216216    psFree(modes);
    217217
    218     // setup search criterion
    219 #define addWhereStr(name) \
    220 { \
    221     psString str = NULL; \
    222     bool status = false; \
    223     if ((str = psMetadataLookupStr(&status, config->args, "-" #name))) { \
    224         if (!psMetadataAddStr(config->where, PS_LIST_TAIL, #name, 0, "==", str)) {\
    225             psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
    226             psFree(config); \
    227             return NULL; \
    228         } \
    229     } \
    230 }
    231 
    232 #define addWhereS32(name) \
    233 { \
    234     psS32 s32 = 0; \
    235     bool status = false; \
    236     if ((s32= psMetadataLookupS32(&status, config->args, "-" #name))) { \
    237         if (!psMetadataAddS32(config->where, PS_LIST_TAIL, #name, 0, "==", s32)) { \
    238             psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
    239             psFree(config); \
    240             return NULL; \
    241         } \
    242     } \
    243 }
    244 
    245 
    246218    // generate SQL where clause
    247219    config->where = psMetadataAlloc();
    248220
    249 {
    250     psString str = NULL;
    251     bool status = false;
    252     if ((str = psMetadataLookupStr(&status, config->args, "-diff_id"))) {
    253         if (!psMetadataAddS64(config->where, PS_LIST_TAIL, "diff_id", 0, "==", (psS64)atoll(str))) {
    254             psError(PS_ERR_UNKNOWN, false, "failed to add item diff_id");
    255             psFree(config);
    256             return NULL;
    257         }
    258     }
    259 }
    260 {
    261     psString str = NULL;
    262     bool status = false;
    263     if ((str = psMetadataLookupStr(&status, config->args, "-warp_id"))) {
    264         if (!psMetadataAddS64(config->where, PS_LIST_TAIL, "warp_id", 0, "==", (psS64)atoll(str))) {
    265             psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    266             psFree(config);
    267             return NULL;
    268         }
    269     }
    270 }
    271     addWhereStr(skycell_id);
    272     addWhereStr(tess_id);
    273 
    274     // convert '-code' to 'fault'
    275     {
    276         psS16 fault = 0;
    277         bool status = false;
    278         if ((fault = psMetadataLookupS16(&status, config->args, "-code"))) {
    279             if (!psMetadataAddS16(config->where, PS_LIST_TAIL, "fault", 0, "==", fault)) {
    280                 psError(PS_ERR_UNKNOWN, false, "failed to add item fault");
    281                 psFree(config);
    282                 return NULL;
    283             }
    284         }
    285     }
     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");
    286226
    287227    if (config->where->list->n < 1) {

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

    r18172 r18468  
    214214    psFree(modes);
    215215
    216     // setup search criterion
    217 #define addWhereStr(name) \
    218 { \
    219     psString str = NULL; \
    220     bool status = false; \
    221     if ((str = psMetadataLookupStr(&status, config->args, "-" #name))) { \
    222         if (!psMetadataAddStr(config->where, PS_LIST_TAIL, #name, 0, "==", str)) {\
    223             psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
    224             psFree(config); \
    225             return NULL; \
    226         } \
    227     } \
    228 }
    229 
    230216    // generate SQL where clause
    231217    config->where = psMetadataAlloc();
    232218
    233 {   
    234     psString str = NULL;
    235     bool status = false;
    236     if ((str = psMetadataLookupStr(&status, config->args, "-corr_id"))) {
    237         if (!psMetadataAddS64(config->where, PS_LIST_TAIL, "corr_id", 0, "==", (psS64)atoll(str))) {
    238             psError(PS_ERR_UNKNOWN, false, "failed to add item corr_id");
    239             psFree(config);
    240             return NULL;
    241         }
    242     }
    243 }
     219    PXOPT_ADD_WHERE_S64(corr_id);
    244220
    245221    if (config->where->list->n < 1) {

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

    r18172 r18468  
    146146    psFree(defineArgs);
    147147
    148     // setup search criterion
    149 #define addWhereStr(name) \
    150     if ((str = psMetadataLookupStr(&status, config->args, "-" #name))) { \
    151         if (!psMetadataAddStr(config->where, PS_LIST_TAIL, #name, 0, "==", str)) {\
    152             psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
    153             exit(EXIT_FAILURE); \
    154         } \
    155     }
    156 
    157148    // generate SQL where clause
    158149    config->where = psMetadataAlloc();
    159150
    160 {
    161     psString str = NULL;
    162     int n = 0;
    163     bool status = false;
    164 
    165     addWhereStr(exp_id);
    166     // convert '-inst' to 'camera'
    167     if ((str = psMetadataLookupStr(&status, config->args, "-inst"))) {
    168         if (!psMetadataAddStr(config->where, PS_LIST_TAIL, "camera", 0, "==", str)) {
    169             psError(PS_ERR_UNKNOWN, false, "failed to add item camera");
    170             exit(EXIT_FAILURE);
    171         }
    172     }
    173     addWhereStr(telescope);
    174     addWhereStr(exp_type);
    175     if ((n = psMetadataLookupS32(&status, config->args, "-imfiles"))) {
    176         if (!psMetadataAddS32(config->where, PS_LIST_TAIL, "imfiles", 0, "==", n)) {
    177             psError(PS_ERR_UNKNOWN, false, "failed to add item imfiles");
    178             exit(EXIT_FAILURE);
    179         }
    180     }
    181     addWhereStr(filter);
    182     addWhereStr(stats);
    183     addWhereStr(recipe);
    184     if ((n = psMetadataLookupS32(&status, config->args, "-guide_version"))) {
    185         if (!psMetadataAddS32(config->where, PS_LIST_TAIL, "guide_version", 0, "==", n)) {
    186             psError(PS_ERR_UNKNOWN, false, "failed to add item guide_version");
    187             exit(EXIT_FAILURE);
    188         }
    189     }
    190 }
     151    PXOPT_ADD_WHERE_STR_ALIAS("-inst","camera");
     152    PXOPT_ADD_WHERE_STR(telescope);
     153    PXOPT_ADD_WHERE_STR(exp_type);
     154    PXOPT_ADD_WHERE_S32(imfiles);
     155    PXOPT_ADD_WHERE_STR(filter);
     156    PXOPT_ADD_WHERE_STR(stats);
     157    PXOPT_ADD_WHERE_STR(recipe);
     158    PXOPT_ADD_WHERE_S32(guide_version);
    191159
    192160    if (config->where->list->n < 1) {

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

    r18172 r18468  
    184184    psFree(modes);
    185185
    186     // setup search criterion
    187 #define addWhereStr(name) \
    188 { \
    189     psString str = NULL; \
    190     bool status = false; \
    191     if ((str = psMetadataLookupStr(&status, config->args, "-" #name))) { \
    192         if (!psMetadataAddStr(config->where, PS_LIST_TAIL, #name, 0, "==", str)) {\
    193             psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
    194             psFree(config); \
    195             return NULL; \
    196         } \
    197     } \
    198 }
    199 
    200 #define addWhereS32(name) \
    201 { \
    202     psS32 s32 = 0; \
    203     bool status = false; \
    204     if ((s32= psMetadataLookupS32(&status, config->args, "-" #name))) { \
    205         if (!psMetadataAddS32(config->where, PS_LIST_TAIL, #name, 0, "==", s32)) { \
    206             psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
    207             psFree(config); \
    208             return NULL; \
    209         } \
    210     } \
    211 }
    212 
    213 
    214186    // generate SQL where clause
    215187    config->where = psMetadataAlloc();
    216188
    217 {
    218     psString str = NULL;
    219     bool status = false;
    220     if ((str = psMetadataLookupStr(&status, config->args, "-warp_id"))) {
    221         if (!psMetadataAddS64(config->where, PS_LIST_TAIL, "warp_id", 0, "==", (psS64)atoll(str))) {
    222             psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    223             psFree(config);
    224             return NULL;
    225         }
    226     }
    227 }
    228     addWhereStr(skycell_id);
    229     addWhereStr(tess_id);
    230     addWhereStr(exp_id);
    231 
    232     // convert '-code' to 'fault'
    233     {
    234         psS16 fault = 0;
    235         bool status = false;
    236         if ((fault = psMetadataLookupS16(&status, config->args, "-code"))) {
    237             if (!psMetadataAddS16(config->where, PS_LIST_TAIL, "fault", 0, "==", fault)) {
    238                 psError(PS_ERR_UNKNOWN, false, "failed to add item fault");
    239                 psFree(config);
    240                 return NULL;
    241             }
    242         }
    243     }
     189    PXOPT_ADD_WHERE_S64(warp_id);
     190    PXOPT_ADD_WHERE_STR(skycell_id);
     191    PXOPT_ADD_WHERE_STR(tess_id);
     192    PXOPT_ADD_WHERE_STR(exp_id);
     193    PXOPT_ADD_WHERE_STR_ALIAS("-code", "fault");
    244194
    245195    if (config->where->list->n < 1) {

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

    r18377 r18468  
    208208    psFree(modes);
    209209
    210     // setup search criterion
    211 #define addWhereStr(name) \
    212 { \
    213     psString str = NULL; \
    214     bool status = false; \
    215     if ((str = psMetadataLookupStr(&status, config->args, "-" #name))) { \
    216         if (!psMetadataAddStr(config->where, PS_LIST_TAIL, #name, 0, "==", str)) {\
    217             psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
    218             psFree(config); \
    219             return NULL; \
    220         } \
    221     } \
    222 }
    223 
    224210    // generate SQL where clause
    225211    config->where = psMetadataAlloc();
    226212
    227     addWhereStr(req_id);
    228     addWhereStr(job_id);
     213    PXOPT_ADD_WHERE_STR(req_id);
     214    PXOPT_ADD_WHERE_STR(job_id);
    229215
    230216    if (config->where->list->n < 1) {

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

    r17015 r18468  
    4343    config->dbh             = NULL;
    4444    config->modules         = NULL;
    45     config->where           = NULL;
     45    // XXX config->where           = NULL;
    4646    config->args            = NULL;
    4747
    … …  
    5454    psFree(config->dbh);
    5555    psFree(config->modules);
    56     psFree(config->where);
     56    // XXX psFree(config->where);
    5757    psFree(config->args);
    5858}

  • branches/eam_branch_20080706/ippTools/src/pxconfig.h

    r14018 r18468  
    3030    psDB *dbh;
    3131    psMetadata *args;
    32     psMetadata *where;
     32    // XXX deprecate psMetadata *where;
    3333    int argc;
    3434    char **argv;

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

    r18336 r18468  
    101101    psFree(modes);
    102102
    103     // setup search criterion
    104 #define addWhereStr(name) \
    105 { \
    106     psString str = NULL; \
    107     bool status = false; \
    108     if ((str = psMetadataLookupStr(&status, config->args, "-" #name))) { \
    109         if (!psMetadataAddStr(config->where, PS_LIST_TAIL, #name, 0, "==", str)) {\
    110             psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
    111             psFree(config); \
    112             return NULL; \
    113         } \
    114     } \
    115 }
    116 
    117103    // generate SQL where clause
    118104    config->where = psMetadataAlloc();
    119105
    120     addWhereStr(det_id);
    121     {
    122         int n = 0;
    123         bool status = false;
    124         if ((n = psMetadataLookupS32(&status, config->args, "-iteration"))) {
    125             if (!psMetadataAddS32(config->where, PS_LIST_TAIL, "iteration", 0, "==", n)) {
    126                 psError(PS_ERR_UNKNOWN, false, "failed to add item iteration");
    127                 psFree(config);
    128                 return NULL;
    129             }
    130         }
    131     }
    132     addWhereStr(det_type);
    133     addWhereStr(exp_id);
    134     addWhereStr(class_id);
    135     // convert '-inst' to 'camera'
    136     {
    137         psString str = NULL;
    138         bool status = false;
    139         if ((str = psMetadataLookupStr(&status, config->args, "-inst"))) {
    140             if (!psMetadataAddStr(config->where, PS_LIST_TAIL, "camera", 0, "==", str)) {
    141                 psError(PS_ERR_UNKNOWN, false, "failed to add item camera");
    142                 psFree(config);
    143                 return NULL;
    144             }
    145         }
    146     }
    147     addWhereStr(telescope);
    148     {
    149         int n = 0;
    150         bool status = false;
    151         if ((n = psMetadataLookupS32(&status, config->args, "-imfiles"))) {
    152             if (!psMetadataAddS32(config->where, PS_LIST_TAIL, "imfiles", 0, "==", n)) {
    153                 psError(PS_ERR_UNKNOWN, false, "failed to add item imfiles");
    154                 psFree(config);
    155                 return NULL;
    156             }
    157         }
    158     }
    159     addWhereStr(filter);
    160     addWhereStr(stats);
    161     addWhereStr(recipe);
    162     {
    163         int n = 0;
    164         bool status = false;
    165         if ((n = psMetadataLookupS32(&status, config->args, "-guide_version"))) {
    166             if (!psMetadataAddS32(config->where, PS_LIST_TAIL, "guide_version", 0, "==", n)) {
    167                 psError(PS_ERR_UNKNOWN, false, "failed to add item guide_version");
    168                 psFree(config);
    169                 return NULL;
    170             }
    171         }
    172     }
    173     {
    174         bool boolean = false;
    175         bool status = false;
    176 
    177         if ((boolean = psMetadataLookupBool(&status, config->args, "-accept"))) {
    178             if (!psMetadataAddBool(config->where, PS_LIST_TAIL, "accept", 0, "==", boolean)) {
    179                 psError(PS_ERR_UNKNOWN, false, "failed to add item accept");
    180                 psFree(config);
    181                 return NULL;
    182             }
    183         }
    184     }
     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);
    185109
    186110    if (config->where->list->n < 1) {

  • branches/eam_branch_20080706/ippTools/src/pxtools.h

    r18366 r18468  
    253253  PXOPT_COPY_PRIMITIVE(from, to, psU64, U64, oldname, newname, comment)
    254254
     255
     256/*** these PXOPT_ADD_WHERE macros are used to construct the default sql elements ***/
     257
     258#define PXOPT_ADD_WHERE_STR(name) \
     259{ \
     260    psString str = NULL; \
     261    bool status = false; \
     262    if ((str = psMetadataLookupStr(&status, config->args, "-" #name))) { \
     263        if (!psMetadataAddStr(config->where, PS_LIST_TAIL, #name, 0, "==", str)) {\
     264            psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
     265            psFree(config); \
     266            return NULL; \
     267        } \
     268    } \
     269}
     270
     271#define PXOPT_ADD_WHERE_STR_ALIAS(name,realname) \
     272{ \
     273    psString str = NULL; \
     274    bool status = false; \
     275    if ((str = psMetadataLookupStr(&status, config->args, name))) { \
     276        if (!psMetadataAddStr(config->where, PS_LIST_TAIL, realname, 0, "==", str)) {\
     277            psError(PS_ERR_UNKNOWN, false, "failed to add item %s", name); \
     278            psFree(config); \
     279            return NULL; \
     280        } \
     281    } \
     282}
     283
     284#define PXOPT_ADD_WHERE_S16(name) \
     285{ \
     286    psS16 s16 = 0; \
     287    bool status = false; \
     288    if ((s16= psMetadataLookupS16(&status, config->args, "-" #name))) { \
     289        if (!psMetadataAddS16(config->where, PS_LIST_TAIL, #name, 0, "==", s16)) { \
     290            psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
     291            psFree(config); \
     292            return NULL; \
     293        } \
     294    } \
     295}
     296
     297#define PXOPT_ADD_WHERE_BOOL(name) \
     298{ \
     299    bool value = false;  \
     300    bool status = false; \
     301    if ((value = psMetadataLookupBool(&status, config->args, "-" #name))) { \
     302        if (!psMetadataAddBool(config->where, PS_LIST_TAIL, #name, 0, "==", value)) { \
     303            psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
     304            psFree(config); \
     305            return NULL; \
     306        } \
     307    } \
     308}
     309
     310#define PXOPT_ADD_WHERE_S32(name) \
     311{ \
     312    psS32 s32 = 0; \
     313    bool status = false; \
     314    if ((s32= psMetadataLookupS32(&status, config->args, "-" #name))) { \
     315        if (!psMetadataAddS32(config->where, PS_LIST_TAIL, #name, 0, "==", s32)) { \
     316            psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
     317            psFree(config); \
     318            return NULL; \
     319        } \
     320    } \
     321}
     322
     323#define PXOPT_ADD_WHERE_S64(name) \
     324{ \
     325    psS64 s64 = 0; \
     326    bool status = false; \
     327    if ((s64= psMetadataLookupS64(&status, config->args, "-" #name))) { \
     328        if (!psMetadataAddS64(config->where, PS_LIST_TAIL, #name, 0, "==", s64)) { \
     329            psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
     330            psFree(config); \
     331            return NULL; \
     332        } \
     333    } \
     334}
     335
     336#define PXOPT_ADD_WHERE_F32(name) \
     337{ \
     338    psF32 var = 0; \
     339    bool status = false; \
     340    if ((var = psMetadataLookupF32(&status, config->args, "-" #name))) { \
     341        if (!isnan(var)) { \
     342            if (!psMetadataAddF32(config->where, PS_LIST_TAIL, #name, 0, "==", var)) { \
     343                psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
     344                psFree(config); \
     345                return NULL; \
     346            } \
     347        } \
     348    } \
     349}
     350
     351#define PXOPT_ADD_WHERE_F64(name) \
     352{ \
     353    psF64 var = 0; \
     354    bool status = false; \
     355    if ((var = psMetadataLookupF64(&status, config->args, "-" #name))) { \
     356        if (!isnan(var))  { \
     357            if (!psMetadataAddF64(config->where, PS_LIST_TAIL, #name, 0, "==", var)) { \
     358                psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
     359                psFree(config); \
     360                return NULL; \
     361            } \
     362        } \
     363    } \
     364}
     365
     366#define PXOPT_ADD_WHERE_BOOL_ALIAS(flag,name)   \
     367{ \
     368    bool value = 0; \
     369    bool status = false; \
     370    if ((value = psMetadataLookupBool(&status, config->args, flag))) {  \
     371        if (!psMetadataAddBOOL(config->where, PS_LIST_TAIL, name, 0, "==", value)) { \
     372            psError(PS_ERR_UNKNOWN, false, "failed to add item %s", flag); \
     373            psFree(config); \
     374            return NULL; \
     375        } \
     376    } \
     377}
     378
     379#define PXOPT_ADD_WHERE_S16_ALIAS(flag,name)    \
     380{ \
     381    psS16 s16 = 0; \
     382    bool status = false; \
     383    if ((s16= psMetadataLookupS16(&status, config->args, flag))) {      \
     384        if (!psMetadataAddS16(config->where, PS_LIST_TAIL, name, 0, "==", s16)) { \
     385            psError(PS_ERR_UNKNOWN, false, "failed to add item %s", flag); \
     386            psFree(config); \
     387            return NULL; \
     388        } \
     389    } \
     390}
     391
     392#define PXOPT_ADD_WHERE_S32_ALIAS(flag,name)    \
     393{ \
     394    psS32 s32 = 0; \
     395    bool status = false; \
     396    if ((s32= psMetadataLookupS32(&status, config->args, flag))) {      \
     397        if (!psMetadataAddS32(config->where, PS_LIST_TAIL, name, 0, "==", s32)) { \
     398            psError(PS_ERR_UNKNOWN, false, "failed to add item %s", flag); \
     399            psFree(config); \
     400            return NULL; \
     401        } \
     402    } \
     403}
     404
     405#define PXOPT_ADD_WHERE_S64_ALIAS(flag,name)    \
     406{ \
     407    psS64 s64 = 0; \
     408    bool status = false; \
     409    if ((s64= psMetadataLookupS64(&status, config->args, flag))) {      \
     410        if (!psMetadataAddS64(config->where, PS_LIST_TAIL, name, 0, "==", s64)) { \
     411            psError(PS_ERR_UNKNOWN, false, "failed to add item %s", flag); \
     412            psFree(config); \
     413            return NULL; \
     414        } \
     415    } \
     416}
     417
     418#define PXOPT_ADD_WHERE_F32_ALIAS(flag,name)    \
     419{ \
     420    psF32 var = 0; \
     421    bool status = false; \
     422    if ((var = psMetadataLookupF32(&status, config->args, flag))) {     \
     423        if (!isnan(var))  { \
     424            if (!psMetadataAddF32(config->where, PS_LIST_TAIL, name, 0, "==", var)) { \
     425                psError(PS_ERR_UNKNOWN, false, "failed to add item %s", flag); \
     426                psFree(config); \
     427                return NULL; \
     428            } \
     429        } \
     430    } \
     431}
     432
     433#define PXOPT_ADD_WHERE_F64_ALIAS(flag,name)    \
     434{ \
     435    psF64 var = 0; \
     436    bool status = false; \
     437    if ((var = psMetadataLookupF64(&status, config->args, flag))) {     \
     438        if (!isnan(var))  { \
     439            if (!psMetadataAddF64(config->where, PS_LIST_TAIL, name, 0, "==", var)) { \
     440                psError(PS_ERR_UNKNOWN, false, "failed to add item %s", flag); \
     441                psFree(config); \
     442                return NULL; \
     443            } \
     444        } \
     445    } \
     446}
     447
     448#define PXOPT_ADD_WHERE_TIME_STR(name) \
     449{ \
     450    psString str = NULL; \
     451    bool status = false; \
     452    if ((str = psMetadataLookupStr(&status, config->args, "-" #name))) { \
     453        psTime *time = psTimeFromISO(str, PS_TIME_UTC); \
     454        if (!time) { \
     455            psError(PS_ERR_UNKNOWN, false, "failed to convert " #name " into a psTime object"); \
     456            psFree(config); \
     457            return NULL; \
     458        } \
     459        psMetadataItem *item = psMetadataLookup(config->args, "-" #name); \
     460        if (item) { \
     461            str = item->comment; \
     462        } else { \
     463            str = NULL; \
     464        } \
     465        if (!psMetadataAddTime(config->where, PS_LIST_TAIL, #name, 0, str, time)) {\
     466            psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
     467            psFree(config); \
     468            return NULL; \
     469        } \
     470        psFree(time); \
     471    } \
     472}
     473
    255474#endif // PXTOOLS_H

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

    r18314 r18468  
    222222    psFree(modes);
    223223
    224     // setup search criterion
    225 #define addWhereStr(name) \
    226 { \
    227     psString str = NULL; \
    228     bool status = false; \
    229     if ((str = psMetadataLookupStr(&status, config->args, "-" #name))) { \
    230         if (!psMetadataAddStr(config->where, PS_LIST_TAIL, #name, 0, "==", str)) {\
    231             psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
    232             psFree(config); \
    233             return NULL; \
    234         } \
    235     } \
    236 }
    237 
    238224    // generate SQL where clause
    239225    config->where = psMetadataAlloc();
    240226
    241     addWhereStr(exp_name);
    242     addWhereStr(telescope);
    243     // convert '-inst' to 'camera'
    244     {
    245         psString str = NULL;
    246         bool status = false;
    247         if ((str = psMetadataLookupStr(&status, config->args, "-inst"))) {
    248             if (!psMetadataAddStr(config->where, PS_LIST_TAIL, "camera", 0, "==", str)) {
    249                 psError(PS_ERR_UNKNOWN, false, "failed to add item camera");
    250                 psFree(config);
    251                 return NULL;
    252             }
    253         }
    254     }
    255     addWhereStr(exp_type);
    256     addWhereStr(class);
    257     addWhereStr(class_id);
     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);
    258233
    259234    if (config->where->list->n < 1) {

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

    r18336 r18468  
    297297    psFree(modes);
    298298
    299     // setup search criterion
    300 #define addWhereStr(name) \
    301 { \
    302     psString str = NULL; \
    303     bool status = false; \
    304     if ((str = psMetadataLookupStr(&status, config->args, "-" #name))) { \
    305         if (!psMetadataAddStr(config->where, PS_LIST_TAIL, #name, 0, "==", str)) {\
    306             psError(PXTOOLS_ERR_PROG, false, "failed to add item " #name); \
    307             psFree(config); \
    308             return NULL; \
    309         } \
    310     } \
    311 }
    312 
    313299    // generate SQL where clause
    314300    config->where = psMetadataAlloc();
    315301
    316     addWhereStr(exp_id);
    317     addWhereStr(exp_name);
    318     // convert '-inst' to 'camera'
    319     {
    320         psString str = NULL;
    321         bool status = false;
    322         if ((str = psMetadataLookupStr(&status, config->args, "-inst"))) {
    323             if (!psMetadataAddStr(config->where, PS_LIST_TAIL, "camera", 0, "==", str)) {
    324                 psError(PXTOOLS_ERR_PROG, false, "failed to add item camera");
    325                 psFree(config);
    326                 return NULL;
    327             }
    328         }
    329     }
    330 
    331     addWhereStr(telescope);
    332     addWhereStr(exp_type);
    333     addWhereStr(class);
    334     addWhereStr(class_id);
    335     addWhereStr(tmp_class_id);
    336     addWhereStr(filter);
    337 
    338     // convert '-code' to 'fault'
    339     {
    340         psS16 fault = 0;
    341         bool status = false;
    342         if ((fault = psMetadataLookupS16(&status, config->args, "-code"))) {
    343             if (!psMetadataAddS16(config->where, PS_LIST_TAIL, "fault", 0, "==", fault)) {
    344                 psError(PS_ERR_UNKNOWN, false, "failed to add item fault");
    345                 psFree(config);
    346                 return NULL;
    347             }
    348         }
    349     }
     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");
    350312
    351313    if (config->where->list->n < 1) {
    … …  
    353315        config->where = NULL;
    354316    }
    355 
    356317
    357318    // define Database handle, if used

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

    r18336 r18468  
    226226    psFree(modes);
    227227
    228     // setup search criterion
    229 #define addWhereStr(name) \
    230 { \
    231     psString str = NULL; \
    232     bool status = false; \
    233     if ((str = psMetadataLookupStr(&status, config->args, "-" #name))) { \
    234         if (!psMetadataAddStr(config->where, PS_LIST_TAIL, #name, 0, "==", str)) {\
    235             psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
    236             psFree(config); \
    237             return NULL; \
    238         } \
    239     } \
    240 }
    241 
    242 #define addWhereS32(name) \
    243 { \
    244     psS32 s32 = 0; \
    245     bool status = false; \
    246     if ((s32= psMetadataLookupS32(&status, config->args, "-" #name))) { \
    247         if (!psMetadataAddS32(config->where, PS_LIST_TAIL, #name, 0, "==", s32)) { \
    248             psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
    249             psFree(config); \
    250             return NULL; \
    251         } \
    252     } \
    253 }
    254 
    255 
    256228    // generate SQL where clause
    257229    config->where = psMetadataAlloc();
    258230
    259 {
    260     psString str = NULL;
    261     bool status = false;
    262     if ((str = psMetadataLookupStr(&status, config->args, "-warp_id"))) {
    263         if (!psMetadataAddS64(config->where, PS_LIST_TAIL, "warp_id", 0, "==", (psS64)atoll(str))) {
    264             psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    265             psFree(config);
    266             return NULL;
    267         }
    268     }
    269 }
    270 
    271 {
    272     psString str = NULL;
    273     bool status = false;
    274     if ((str = psMetadataLookupStr(&status, config->args, "-stack_id"))) {
    275         if (!psMetadataAddS64(config->where, PS_LIST_TAIL, "stack_id", 0, "==", (psS64)atoll(str))) {
    276             psError(PS_ERR_UNKNOWN, false, "failed to add item stack_id");
    277             psFree(config);
    278             return NULL;
    279         }
    280     }
    281 }
    282 
    283     addWhereStr(skycell_id);
    284     addWhereStr(tess_id);
    285 
    286     // convert '-code' to 'fault'
    287     {
    288         psS16 fault = 0;
    289         bool status = false;
    290         if ((fault = psMetadataLookupS16(&status, config->args, "-code"))) {
    291             if (!psMetadataAddS16(config->where, PS_LIST_TAIL, "fault", 0, "==", fault)) {
    292                 psError(PS_ERR_UNKNOWN, false, "failed to add item fault");
    293                 psFree(config);
    294                 return NULL;
    295             }
    296         }
    297     }
     231    PXOPT_ADD_WHERE_S64(warp_id);
     232    PXOPT_ADD_WHERE_S64(stack_id);
     233    PXOPT_ADD_WHERE_STR(skycell_id);
     234    PXOPT_ADD_WHERE_STR(tess_id);
     235    PXOPT_ADD_WHERE_S16_ALIAS("-code","fault");
    298236
    299237    if (config->where->list->n < 1) {

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

    r18467 r18468  
    429429    psFree(modes);
    430430
    431     // setup search criterion
    432 #define addWhereStr(name) \
    433 { \
    434     psString str = NULL; \
    435     bool status = false; \
    436     if ((str = psMetadataLookupStr(&status, config->args, "-" #name))) { \
    437         if (!psMetadataAddStr(config->where, PS_LIST_TAIL, #name, 0, "==", str)) {\
    438             psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
    439             psFree(config); \
    440             return NULL; \
    441         } \
    442     } \
    443 }
    444 
    445 #define addWhereS32(name) \
    446 { \
    447     psS32 s32 = 0; \
    448     bool status = false; \
    449     if ((s32= psMetadataLookupS32(&status, config->args, "-" #name))) { \
    450         if (!psMetadataAddS32(config->where, PS_LIST_TAIL, #name, 0, "==", s32)) { \
    451             psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
    452             psFree(config); \
    453             return NULL; \
    454         } \
    455     } \
    456 }
    457 
    458 
    459431    // generate SQL where clause
    460432    config->where = psMetadataAlloc();
    461433
    462 {
    463     psS64 warp_id = -1;
    464     bool status = false;
    465     if ((warp_id = psMetadataLookupS64(&status, config->args, "-warp_id"))) {
    466         if (!psMetadataAddS64(config->where, PS_LIST_TAIL, "warp_id", 0, "==", warp_id)) {
    467             psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    468             psFree(config);
    469             return NULL;
    470         }
    471     }
    472 }
    473     addWhereStr(skycell_id);
    474     addWhereStr(tess_id);
    475     addWhereStr(exp_id);
    476 
    477     // convert '-code' to 'fault'
    478     {
    479         psS16 fault = 0;
    480         bool status = false;
    481         if ((fault = psMetadataLookupS16(&status, config->args, "-code"))) {
    482             if (!psMetadataAddS16(config->where, PS_LIST_TAIL, "fault", 0, "==", fault)) {
    483                 psError(PS_ERR_UNKNOWN, false, "failed to add item fault");
    484                 psFree(config);
    485                 return NULL;
    486             }
    487         }
    488     }
     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");
    489439
    490440    if (config->where->list->n < 1) {
Note: See TracChangeset for help on using the changeset viewer.