IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
May 10, 2022, 5:16:45 PM (4 years ago)
Author:
eugene
Message:

first cut at fpcamtool code (it builds at least)

Location:
branches/eam_branches/ipp-20220316/ippTools
Files:
9 added
5 edited

Legend:

Unmodified
Added
Removed

  • branches/eam_branches/ipp-20220316/ippTools/share/Makefile.am

    r42097 r42197  
    543543        remotetool_listcomponent.sql \
    544544        remotetool_doneprep.sql \
    545         remotetool_updatepoll.sql
     545        remotetool_updatepoll.sql \
     546        fpcamtool_addprocessedexp.sql \
     547        fpcamtool_find_cam_and_chip_id.sql \
     548        fpcamtool_find_cam_id.sql \
     549        fpcamtool_find_processedexp.sql \
     550        fpcamtool_pendingexp.sql \
     551        fpcamtool_queue_cam_id.sql \
     552        fpcamtool_revertprocessedexp.sql \
     553        fpcamtool_revertupdatedexp.sql
     554

  • branches/eam_branches/ipp-20220316/ippTools/share/fpcamtool_find_cam_and_chip_id.sql

    r42195 r42197  
    44(
    55 SELECT
    6      chipRun.chip_id,
    7      rawExp.ra,
    8      rawExp.decl
     6     exp_id,
     7     chip_id,
    98 FROM chipRun
    109 JOIN rawExp
    … …  
    1211 WHERE
    1312      chipRun.state = 'full'
    14  -- AND exp_id = 162
    15  -- AND chip_id = 140
     13 -- WHERE HOOK for chip:
     14  AND %s
    1615) AS myChip
    1716JOIN
    1817(
    1918SELECT
     19    exp_id,
     20    camRun.chip_id as cam_chip_id,
    2021    camRun.cam_id,
    21     rawExp.ra,
    22     rawExp.decl
     22    camRun.state,
     23    camRun.workdir,
     24    camRun.workdir_state,
     25    camRun.label,
     26    camRun.data_group,
     27    camRun.dist_group,
     28    camRun.reduction,
     29    camRun.dvodb,
     30    camRun.software_ver,
     31    camRun.note
    2332FROM camRun
    2433JOIN chipRun
    … …  
    2837WHERE
    2938     camRun.state = 'full'
    30 -- AND exp_id = 162
    31 -- AND cam_id = 234
     39-- WHERE HOOK for cam:
     40  AND %s
    3241) AS myCam
    3342USING(exp_id)
    34 
    35  

  • branches/eam_branches/ipp-20220316/ippTools/src/Makefile.am

    r36511 r42197  
    3535        releasetool \
    3636        fftool \
     37        fpcamtool \
    3738        remotetool
    3839
    … …  
    5556        pxtoolsErrorCodes.h \
    5657        pxtree.h \
     58        pxfpcam.h \
    5759        pxwarp.h
    5860
    … …  
    9193        releasetool.h \
    9294        fftool.h \
     95        fpcamtool.h \
    9396        remotetool.h
    9497
    … …  
    116119        pxtoolsErrorCodes.c \
    117120        pxtree.c \
     121        pxfpcam.c \
    118122        pxwarp.c
    119123
    … …  
    174178    camtool.c \
    175179    camtoolConfig.c
     180
     181fpcamtool_CFLAGS = $(PSLIB_CFLAGS) $(PSMODULES_CFLAGS) $(IPPDB_CFLAGS)
     182fpcamtool_LDADD = $(PSLIB_LIBS) $(PSMODULES_LIBS) $(IPPDB_LIBS) libpxtools.la
     183fpcamtool_SOURCES = \
     184    fpcamtool.c \
     185    fpcamtoolConfig.c
    176186
    177187faketool_CFLAGS = $(PSLIB_CFLAGS) $(PSMODULES_CFLAGS) $(IPPDB_CFLAGS)

  • branches/eam_branches/ipp-20220316/ippTools/src/fpcamtool.c

    r42195 r42197  
    2727
    2828#include "pxtools.h"
    29 #include "pxcam.h"
     29#include "pxfpcam.h"
    3030#include "fpcamtool.h"
    3131
    … …  
    4040static bool maskedMode(pxConfig *config);
    4141static bool unblockMode(pxConfig *config);
    42 static bool pendingcleanuprunMode(pxConfig *config);
    43 static bool pendingcleanupexpMode(pxConfig *config);
    44 static bool donecleanupMode(pxConfig *config);
    45 static bool exportrunMode(pxConfig *config);
    46 static bool importrunMode(pxConfig *config);
    47 
    48 # define MODECASE(caseName, func) \
    49     case caseName: \
    50     if (!func(config)) { \
    51         goto FAIL; \
    52     } \
    53     break;
     42
     43# define MODECASE(caseName, func) case caseName: if (!func(config)) { goto FAIL; } break;
    5444
    5545int main(int argc, char **argv)
    … …  
    5747    psLibInit(NULL);
    5848
    59     pxConfig *config = camtoolConfig(NULL, argc, argv);
     49    pxConfig *config = fpcamtoolConfig(NULL, argc, argv);
    6050    if (!config) {
    6151        psError(PXTOOLS_ERR_CONFIG, false, "failed to configure");
    … …  
    6454
    6555    switch (config->mode) {
    66         MODECASE(CAMTOOL_MODE_DEFINEBYQUERY,        definebyqueryMode);
    67         MODECASE(CAMTOOL_MODE_UPDATERUN,            updaterunMode);
    68         MODECASE(CAMTOOL_MODE_PENDINGEXP,           pendingexpMode);
    69         MODECASE(CAMTOOL_MODE_ADDPROCESSEDEXP,      addprocessedexpMode);
    70         MODECASE(CAMTOOL_MODE_PROCESSEDEXP,         processedexpMode);
    71         MODECASE(CAMTOOL_MODE_REVERTPROCESSEDEXP,   revertprocessedexpMode);
    72         MODECASE(CAMTOOL_MODE_UPDATEPROCESSEDEXP,   updateprocessedexpMode);
    73         MODECASE(CAMTOOL_MODE_BLOCK,                blockMode);
    74         MODECASE(CAMTOOL_MODE_MASKED,               maskedMode);
    75         MODECASE(CAMTOOL_MODE_UNBLOCK,              unblockMode);
    76         MODECASE(CAMTOOL_MODE_PENDINGCLEANUPRUN,    pendingcleanuprunMode);
    77         MODECASE(CAMTOOL_MODE_PENDINGCLEANUPEXP,    pendingcleanupexpMode);
    78         MODECASE(CAMTOOL_MODE_DONECLEANUP,          donecleanupMode);
    79         MODECASE(CAMTOOL_MODE_EXPORTRUN,            exportrunMode);
    80         MODECASE(CAMTOOL_MODE_IMPORTRUN,            importrunMode);
     56        MODECASE(FPCAMTOOL_MODE_DEFINEBYQUERY,        definebyqueryMode);
     57        MODECASE(FPCAMTOOL_MODE_UPDATERUN,            updaterunMode);
     58        MODECASE(FPCAMTOOL_MODE_PENDINGEXP,           pendingexpMode);
     59        MODECASE(FPCAMTOOL_MODE_ADDPROCESSEDEXP,      addprocessedexpMode);
     60        MODECASE(FPCAMTOOL_MODE_PROCESSEDEXP,         processedexpMode);
     61        MODECASE(FPCAMTOOL_MODE_REVERTPROCESSEDEXP,   revertprocessedexpMode);
     62        MODECASE(FPCAMTOOL_MODE_UPDATEPROCESSEDEXP,   updateprocessedexpMode);
     63        MODECASE(FPCAMTOOL_MODE_BLOCK,                blockMode);
     64        MODECASE(FPCAMTOOL_MODE_MASKED,               maskedMode);
     65        MODECASE(FPCAMTOOL_MODE_UNBLOCK,              unblockMode);
    8166        default:
    8267            psAbort("invalid option (this should not happen)");
    … …  
    10489    PS_ASSERT_PTR_NON_NULL(config, NULL);
    10590   
    106     psMetadata *where = psMetadataAlloc();
    107     pxcamGetSearchArgs (config, where);
    108     pxAddLabelSearchArgs (config, where, "-chip-label", "chipRun.label", "=="); // define using chipRun label
    109     pxAddLabelSearchArgs (config, where, "-cam-label", "camRun.label", "=="); // define using chipRun label
    110     PXOPT_COPY_S64(config->args, where, "-cam_id",     "camRun.cam_id", "==");
    111     PXOPT_COPY_STR(config->args, where, "-reduction",  "chipRun.reduction", "=="); // use camRun here?
    112     PXOPT_COPY_STR(config->args, where, "-data_group", "chipRun.data_group", "=="); // use camRun here?
    113     PXOPT_COPY_STR(config->args, where, "-obs_mode",   "rawExp.obs_mode", "==");
     91    psMetadata *whereChp = psMetadataAlloc();
     92    psMetadata *whereCam = psMetadataAlloc();
     93
     94    // The user can specify the chipRun and camRun independently
     95
     96    // selections for the relevant chip-stage
     97    pxfpcamGetSearchArgs (config, whereChp);
     98    pxAddLabelSearchArgs (config, whereChp, "-chip_label",      "chipRun.label",      "==");
     99    PXOPT_COPY_S64(config->args,  whereChp, "-chip_id",         "chipRun.chip_id",    "==");
     100    PXOPT_COPY_STR(config->args,  whereChp, "-chip_reduction",  "chipRun.reduction",  "==");
     101    PXOPT_COPY_STR(config->args,  whereChp, "-chip_data_group", "chipRun.data_group", "==");
    114102   
    115     // pxcam provides rawExp constraints to select the exposures
    116     // It also adds chip_id => chipRun.chip_id
    117     // The user can specify the chipRun and camRun independently
    118 
    119     if (!psListLength(where->list) &&
    120         !psMetadataLookupBool(NULL, config->args, "-all")) {
    121         psFree(where);
    122         psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     103    // selections for the relevant cam-stage
     104    pxfpcamGetSearchArgs (config, whereCam);
     105    pxAddLabelSearchArgs (config, whereCam, "-cam_label",      "camRun.label",      "==");
     106    PXOPT_COPY_S64(config->args,  whereCam, "-cam_id",         "camRun.cam_id",     "==");
     107    PXOPT_COPY_STR(config->args,  whereCam, "-cam_reduction",  "camRun.reduction",  "==");
     108    PXOPT_COPY_STR(config->args,  whereCam, "-cam_data_group", "camRun.data_group", "==");
     109
     110    // pxfpcam provides rawExp constraints to select the exposures
     111
     112    if (!psListLength(whereCam->list)) {
     113        psFree(whereCam);
     114        psFree(whereChp);
     115        psError(PXTOOLS_ERR_CONFIG, false, "search parameters (at least for camRun) are required");
    123116        return false;
    124117    }
    125118   
    126     PXOPT_LOOKUP_STR(workdir, config->args, "-set_workdir", false, false);
    127     PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
     119    PXOPT_LOOKUP_STR(workdir,    config->args, "-set_workdir",    false, false);
     120    PXOPT_LOOKUP_STR(label,      config->args, "-set_label",      false, false);
    128121    PXOPT_LOOKUP_STR(data_group, config->args, "-set_data_group", false, false);
    129122    PXOPT_LOOKUP_STR(dist_group, config->args, "-set_dist_group", false, false);
    130     PXOPT_LOOKUP_STR(reduction, config->args, "-set_reduction", false, false);
    131     PXOPT_LOOKUP_STR(dvodb, config->args, "-set_dvodb", false, false);
    132     PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
     123    PXOPT_LOOKUP_STR(reduction,  config->args, "-set_reduction", false, false);
     124    PXOPT_LOOKUP_STR(dvodb,      config->args, "-set_dvodb",      false, false);
     125    PXOPT_LOOKUP_STR(note,       config->args, "-set_note",      false, false);
    133126
    134127    // default
    135128    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
    136     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     129    PXOPT_LOOKUP_BOOL(simple,  config->args, "-simple", false);
    137130
    138131    // find the exp_id of all the exposures that we want to queue up.
    139     psString query = pxDataGet("fpcamtool_find_cam_and_chip_id.sql");
    140     if (!query) {
    141         psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    142         psFree(where);
    143         return false;
    144     }
    145 
    146     if (psListLength(where->list)) {
    147         psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    148         psStringAppend(&query, " AND %s", whereClause);
    149         psFree(whereClause);
    150     }
    151     psFree(where);
    152 
    153     if (!p_psDBRunQuery(config->dbh, query)) {
    154         psError(PS_ERR_UNKNOWN, false, "database error");
    155         psFree(query);
    156         return false;
    157     }
    158     psFree(query);
     132
     133    if (psListLength(whereChp->list)) {
     134        // if selections are set for chip (and cam), use query set for both where strings
     135        psString query = pxDataGet("fpcamtool_find_cam_and_chip_id.sql");
     136        if (!query) {
     137            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     138            psFree(whereChp);
     139            psFree(whereCam);
     140            return false;
     141        }
     142        psString whereChpStr = psDBGenerateWhereConditionSQL(whereChp, NULL);
     143        psString whereCamStr = psDBGenerateWhereConditionSQL(whereCam, NULL);
     144
     145        // XXX add limits to the chip & cam queries?
     146        if (!p_psDBRunQueryF(config->dbh, query, whereChpStr, whereCamStr)) {
     147            psError(PS_ERR_UNKNOWN, false, "database error");
     148            psFree(query);
     149            psFree(whereChp);
     150            psFree(whereCam);
     151            psFree(whereChpStr);
     152            psFree(whereCamStr);
     153            return false;
     154        }
     155        psFree(query);
     156        psFree(whereChp);
     157        psFree(whereCam);
     158        psFree(whereChpStr);
     159        psFree(whereCamStr);
     160    } else {
     161        // if we are not selecting the chipRun explicitly, use the camRun selection for both
     162        psString query = pxDataGet("fpcamtool_find_cam_id.sql");
     163        if (!query) {
     164            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     165            psFree(whereChp);
     166            psFree(whereCam);
     167            return false;
     168        }
     169        psString whereCamStr = psDBGenerateWhereConditionSQL(whereCam, NULL);
     170
     171        // XXX add limits to the chip & cam queries?
     172        if (!p_psDBRunQueryF(config->dbh, query, whereCamStr)) {
     173            psError(PS_ERR_UNKNOWN, false, "database error");
     174            psFree(query);
     175            psFree(whereChp);
     176            psFree(whereCam);
     177            psFree(whereCamStr);
     178            return false;
     179        }
     180        psFree(query);
     181        psFree(whereChp);
     182        psFree(whereCam);
     183        psFree(whereCamStr);
     184    }
    159185
    160186    psArray *output = p_psDBFetchResult(config->dbh);
    … …  
    171197    if (pretend) {
    172198        // negative simple so the default is true
    173         if (!ippdbPrintMetadatas(stdout, output, "chipRun", !simple)) {
     199        if (!ippdbPrintMetadatas(stdout, output, "fpcamRun", !simple)) {
    174200            psError(PS_ERR_UNKNOWN, false, "failed to print array");
    175201            psFree(output);
    … …  
    188214    }
    189215
    190     // would could do this "all in the database" if we didn't want the option
    191     // of changing the label/reduction/expgroup/dvodb/etc.  So we're pulling the
    192     // data out so we have the option of changing these values or leaving the
    193     // old values in place (i.e., passing the values through).
    194 
    195     // loop over our list of chipRun rows
     216    // loop over our list of fpcamRun rows
    196217    for (long i = 0; i < psArrayLength(output); i++) {
    197218        psMetadata *md = output->data[i];
    198219
    199         chipRunRow *row = chipRunObjectFromMetadata(md);
     220        fpcamInsertRow *row = fpcamInsertObjectFromMetadata(md);
    200221        if (!row) {
    201             psError(PS_ERR_UNKNOWN, false, "failed to convert metadata into chipRun");
     222            psError(PS_ERR_UNKNOWN, false, "failed to convert metadata into fpcamInsert object");
    202223            psFree(output);
    203224            return false;
    … …  
    205226
    206227        // queue the exp
    207         if (!pxcamQueueByChipID(config,
     228        if (!pxfpcamQueueByCamAndChipID(config,
    208229                    row->chip_id,
     230                    row->cam_id,
    209231                    workdir     ? workdir   : row->workdir,
    210232                    label       ? label     : row->label,
    … …  
    212234                    dist_group  ? dist_group: row->dist_group,
    213235                    reduction   ? reduction : row->reduction,
    214                     expgroup    ? expgroup  : row->expgroup,
    215236                    dvodb       ? dvodb     : row->dvodb,
    216                     tess_id     ? tess_id   : row->tess_id,
    217                     end_stage   ? end_stage : row->end_stage,
    218                     row->magicked,
    219237                    note
    220238        )) {
    … …  
    223241            }
    224242            psError(PS_ERR_UNKNOWN, false,
    225                     "failed to trying to queue chip_id: %" PRId64, row->chip_id);
     243                    "failed to trying to queue cam_id: %lld, chip_id: %lld", (long long) row->cam_id, (long long) row->chip_id);
    226244            psFree(row);
    227245            psFree(output);
    … …  
    240258}
    241259
    242 
    243260static bool updaterunMode(pxConfig *config)
    244261{
    … …  
    246263
    247264    psMetadata *where = psMetadataAlloc();
    248     pxcamGetSearchArgs (config, where);
    249     PXOPT_COPY_S64(config->args, where, "-cam_id",    "camRun.cam_id", "==");
    250     PXOPT_COPY_STR(config->args, where, "-label",     "camRun.label", "==");
    251     PXOPT_COPY_STR(config->args, where, "-data_group","camRun.data_group", "==");
    252     PXOPT_COPY_STR(config->args, where, "-state",     "camRun.state", "==");
    253     PXOPT_COPY_STR(config->args, where, "-reduction", "camRun.reduction", "==");
     265    pxfpcamGetSearchArgs (config, where);
     266    PXOPT_COPY_S64(config->args, where, "-fpcam_id",  "fpcamRun.fpcam_id", "==");
     267    PXOPT_COPY_S64(config->args, where, "-cam_id",    "fpcamRun.cam_id", "==");
     268    PXOPT_COPY_S64(config->args, where, "-chip_id",   "fpcamRun.chip_id", "==");
     269    PXOPT_COPY_STR(config->args, where, "-label",     "fpcamRun.label", "==");
     270    PXOPT_COPY_STR(config->args, where, "-data_group","fpcamRun.data_group", "==");
     271    PXOPT_COPY_STR(config->args, where, "-state",     "fpcamRun.state", "==");
     272    PXOPT_COPY_STR(config->args, where, "-reduction", "fpcamRun.reduction", "==");
    254273
    255274    if (!psListLength(where->list)) {
    … …  
    258277        return false;
    259278    }
    260     psString query = psStringCopy("UPDATE camRun JOIN chipRun USING(chip_id) JOIN rawExp USING(exp_id)");
     279    psString query = psStringCopy("UPDATE fpcamRun JOIN camRun USING(cam_id) JOIN chipRun ON(chipRun.chip_id = camRun.chip_id) JOIN rawExp USING(exp_id)");
    261280
    262281    // pxUpdateRun gets parameters from config->args and updates
    263     bool result = pxUpdateRun(config, where, &query, "camRun", "cam_id", "camProcessedExp", true, true);
     282    bool result = pxUpdateRun(config, where, &query, "fpcamRun", "fpcam_id", "fpcamProcessedExp", true, false);
    264283    if (!result) {
    265284        psError(psErrorCodeLast(), false, "pxUpdateRun failed");
    … …  
    271290    return result;
    272291}
    273 
    274292
    275293static bool pendingexpMode(pxConfig *config)
    … …  
    282300
    283301    psMetadata *where = psMetadataAlloc();
    284     pxcamGetSearchArgs (config, where);
    285     PXOPT_COPY_S64(config->args, where, "-cam_id",    "camRun.cam_id", "==");
    286     pxAddLabelSearchArgs (config, where, "-label", "camRun.label", "==");
    287     PXOPT_COPY_STR(config->args, where, "-reduction", "camRun.reduction", "==");
    288 
    289     psString query = pxDataGet("camtool_pendingexp.sql");
     302    pxfpcamGetSearchArgs (config, where);
     303    pxAddLabelSearchArgs (config, where, "-label",    "fpcamRun.label", "==");
     304    PXOPT_COPY_S64(config->args, where, "-fpcam_id",  "fpcamRun.fpcam_id", "==");
     305    PXOPT_COPY_S64(config->args, where, "-cam_id",    "fpcamRun.cam_id", "==");
     306    PXOPT_COPY_S64(config->args, where, "-chip_id",   "fpcamRun.chip_id", "==");
     307    PXOPT_COPY_STR(config->args, where, "-reduction", "fpcamRun.reduction", "==");
     308
     309    psString query = pxDataGet("fpcamtool_pendingexp.sql");
    290310    if (!query) {
    291311        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    … …  
    306326    psFree(where);
    307327
    308     psStringAppend(&query, "\nORDER BY priority DESC, cam_id");
     328    psStringAppend(&query, "\nORDER BY priority DESC, fpcam_id");
    309329
    310330    // treat limit == 0 as "no limit"
    … …  
    328348    }
    329349    if (!psArrayLength(output)) {
    330         psTrace("camtool", PS_LOG_INFO, "no rows found");
     350        psTrace("fpcamtool", PS_LOG_INFO, "no rows found");
    331351        psFree(output);
    332352        return true;
    … …  
    334354
    335355    // negate simple so the default is true
    336     if (!ippdbPrintMetadatas(stdout, output, "camPendingExp", !simple)) {
     356    if (!ippdbPrintMetadatas(stdout, output, "fpcamPendingExp", !simple)) {
    337357        psError(PS_ERR_UNKNOWN, false, "failed to print array");
    338358        psFree(output);
    … …  
    345365}
    346366
    347 static bool pendingimfileMode(pxConfig *config)
    348 {
    349     PS_ASSERT_PTR_NON_NULL(config, false);
    350 
    351     psMetadata *where = psMetadataAlloc();
    352     pxcamGetSearchArgs (config, where);
    353     PXOPT_COPY_S64(config->args, where, "-cam_id",    "camRun.cam_id",                "==");
    354     pxAddLabelSearchArgs (config, where, "-label",    "camRun.label",                 "==");
    355     PXOPT_COPY_STR(config->args, where, "-reduction", "camRun.reduction",             "==");
    356     PXOPT_COPY_S64(config->args, where, "-chip_id",   "camRun.chip_id",              "==");
    357     PXOPT_COPY_STR(config->args, where, "-class_id",  "camProcessedExp.class_id", "==");
    358 
    359     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    360     PXOPT_LOOKUP_BOOL(all, config->args, "-all", false);
    361 
    362     psString query = pxDataGet("camtool_find_pendingimfile.sql");
    363     if (!query) {
    364         psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    365         return false;
    366     }
    367 
    368     // use psDBGenerateWhereSQL because the SQL yields an intermediate table
    369     if (psListLength(where->list)) {
    370         psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    371         psStringAppend(&query, " AND %s", whereClause);
    372         psFree(whereClause);
    373     } else {
    374       if (!all) {
    375         psError(PXTOOLS_ERR_SYS, false, "unrestricted query not allowed (try -all)");
    376         return false;
    377       }
    378     }
    379     psFree(where);
    380 
    381     if (!p_psDBRunQuery(config->dbh, query)) {
    382         psError(PS_ERR_UNKNOWN, false, "database error");
    383         psFree(query);
    384         return false;
    385     }
    386     psFree(query);
    387 
    388     psArray *output = p_psDBFetchResult(config->dbh);
    389     if (!output) {
    390         psError(PS_ERR_UNKNOWN, false, "database error");
    391         return false;
    392     }
    393     if (!psArrayLength(output)) {
    394         psTrace("camtool", PS_LOG_INFO, "no rows found");
    395         psFree(output);
    396         return true;
    397     }
    398 
    399     // negate simple so the default is true
    400     if (!ippdbPrintMetadatas(stdout, output, "camProcessedExp", !simple)) {
    401         psError(PS_ERR_UNKNOWN, false, "failed to print array");
    402         psFree(output);
    403         return false;
    404     }
    405 
    406     psFree(output);
    407 
    408     return true;
    409 }
    410 
    411367static bool addprocessedexpMode(pxConfig *config)
    412368{
    … …  
    414370
    415371    // required
    416     PXOPT_LOOKUP_S64(cam_id, config->args, "-cam_id", true, false);
    417     PXOPT_LOOKUP_STR(uri, config->args, "-uri", true, false);
     372    PXOPT_LOOKUP_S64(fpcam_id, config->args,      "-fpcam_id", true, false);
     373    PXOPT_LOOKUP_STR(path_base, config->args,     "-path_base", true, false);
    418374
    419375    // optional
    420     PXOPT_LOOKUP_F32(bg, config->args, "-bg", false, false);
    421     PXOPT_LOOKUP_F32(bg_stdev, config->args, "-bg_stdev", false, false);
    422     PXOPT_LOOKUP_F32(bg_mean_stdev, config->args, "-bg_mean_stdev", false, false);
    423     PXOPT_LOOKUP_F32(bias, config->args,           "-bias", false, false);
    424     PXOPT_LOOKUP_F32(bias_stdev, config->args,     "-bias_stdev", false, false);
    425     PXOPT_LOOKUP_F32(fringe_0, config->args,       "-fringe_0", false, false);
    426     PXOPT_LOOKUP_F32(fringe_1, config->args,       "-fringe_1", false, false);
    427     PXOPT_LOOKUP_F32(fringe_2, config->args,       "-fringe_2", false, false);
    428     PXOPT_LOOKUP_F32(sigma_ra, config->args, "-sigma_ra", false, false);
    429     PXOPT_LOOKUP_F32(sigma_dec, config->args, "-sigma_dec", false, false);
    430     PXOPT_LOOKUP_F32(ap_resid, config->args,       "-ap_resid", false, false);
    431     PXOPT_LOOKUP_F32(ap_resid_stdev, config->args, "-ap_resid_stdev", false, false);
    432 
    433376    PXOPT_LOOKUP_F32(zpt_obs, config->args,       "-zpt_obs", false, false);
    434377    PXOPT_LOOKUP_F32(zpt_err, config->args,       "-zpt_err", false, false);
    … …  
    436379    PXOPT_LOOKUP_F32(zpt_lq,  config->args,       "-zpt_lq", false, false);
    437380
    438     PXOPT_LOOKUP_F32(fwhm_major, config->args,     "-fwhm_major", false, false);
    439     PXOPT_LOOKUP_F32(fwhm_major_lq, config->args,     "-fwhm_major_lq", false, false);
    440     PXOPT_LOOKUP_F32(fwhm_major_uq, config->args,     "-fwhm_major_uq", false, false);
    441 
    442     PXOPT_LOOKUP_F32(fwhm_minor,    config->args,     "-fwhm_minor", false, false);
    443     PXOPT_LOOKUP_F32(fwhm_minor_lq, config->args,     "-fwhm_minor_lq", false, false);
    444     PXOPT_LOOKUP_F32(fwhm_minor_uq, config->args,     "-fwhm_minor_uq", false, false);
    445 
    446     PXOPT_LOOKUP_F32(iq_fwhm_major,     config->args,      "-iq_fwhm_major",     false, false);
    447     PXOPT_LOOKUP_F32(iq_fwhm_major_err, config->args,      "-iq_fwhm_major_err",     false, false);
    448     PXOPT_LOOKUP_F32(iq_fwhm_minor,     config->args,      "-iq_fwhm_minor",     false, false);
    449     PXOPT_LOOKUP_F32(iq_fwhm_minor_err, config->args,      "-iq_fwhm_minor_err",     false, false);
    450 
    451     PXOPT_LOOKUP_F32(iq_m2,     config->args,      "-iq_m2",     false, false);
    452     PXOPT_LOOKUP_F32(iq_m2_err, config->args,      "-iq_m2_err", false, false);
    453     PXOPT_LOOKUP_F32(iq_m2_uq,  config->args,      "-iq_m2_uq",  false, false);
    454     PXOPT_LOOKUP_F32(iq_m2_lq,  config->args,      "-iq_m2_lq",  false, false);
    455 
    456     PXOPT_LOOKUP_F32(iq_m2c,     config->args,     "-iq_m2c",     false, false);
    457     PXOPT_LOOKUP_F32(iq_m2c_err, config->args,     "-iq_m2c_err", false, false);
    458     PXOPT_LOOKUP_F32(iq_m2c_uq,  config->args,     "-iq_m2c_uq",  false, false);
    459     PXOPT_LOOKUP_F32(iq_m2c_lq,  config->args,     "-iq_m2c_lq",  false, false);
    460 
    461     PXOPT_LOOKUP_F32(iq_m2s,     config->args,     "-iq_m2s",     false, false);
    462     PXOPT_LOOKUP_F32(iq_m2s_err, config->args,     "-iq_m2s_err", false, false);
    463     PXOPT_LOOKUP_F32(iq_m2s_uq,  config->args,     "-iq_m2s_uq",  false, false);
    464     PXOPT_LOOKUP_F32(iq_m2s_lq,  config->args,     "-iq_m2s_lq",  false, false);
    465 
    466     PXOPT_LOOKUP_F32(iq_m3,     config->args,      "-iq_m3",     false, false);
    467     PXOPT_LOOKUP_F32(iq_m3_err, config->args,      "-iq_m3_err", false, false);
    468     PXOPT_LOOKUP_F32(iq_m3_uq,  config->args,      "-iq_m3_uq",  false, false);
    469     PXOPT_LOOKUP_F32(iq_m3_lq,  config->args,      "-iq_m3_lq",  false, false);
    470 
    471     PXOPT_LOOKUP_F32(iq_m4,     config->args,      "-iq_m4",     false, false);
    472     PXOPT_LOOKUP_F32(iq_m4_err, config->args,      "-iq_m4_err", false, false);
    473     PXOPT_LOOKUP_F32(iq_m4_uq,  config->args,      "-iq_m4_uq",  false, false);
    474     PXOPT_LOOKUP_F32(iq_m4_lq,  config->args,      "-iq_m4_lq",  false, false);
    475 
    476381    PXOPT_LOOKUP_F32(dtime_script, config->args,   "-dtime_script", false, false);
    477     PXOPT_LOOKUP_F32(dtime_astrom, config->args,   "-dtime_astrom", false, false);
    478     PXOPT_LOOKUP_F32(dtime_addstar, config->args,  "-dtime_addstar", false, false);
    479 
    480382    PXOPT_LOOKUP_STR(hostname, config->args,       "-hostname", false, false);
    481383    PXOPT_LOOKUP_S32(n_stars, config->args,        "-n_stars", false, false);
    482     PXOPT_LOOKUP_S32(n_psfstars, config->args,        "-n_psfstars", false, false);
    483     PXOPT_LOOKUP_S32(n_iqstars, config->args,        "-n_iqstars", false, false);
    484     PXOPT_LOOKUP_S32(n_extended, config->args,     "-n_extended", false, false);
    485     PXOPT_LOOKUP_S32(n_cr, config->args,           "-n_cr", false, false);
    486     PXOPT_LOOKUP_S32(n_astrom, config->args,       "-n_astrom", false, false);
    487 
    488     PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", false, false);
    489     PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
    490     PXOPT_LOOKUP_S16(quality, config->args, "-quality", false, false);
    491     PXOPT_LOOKUP_S16(background_model, config->args, "-background_model", false, false);
    492     PXOPT_LOOKUP_S64(astrom_chips, config->args, "-astrom_chips", false, false);
    493 
    494    
    495     PXOPT_LOOKUP_STR(ver_pslib, config->args, "-ver_pslib", false, false);
    496     PXOPT_LOOKUP_STR(ver_psmodules, config->args, "-ver_psmodules", false, false);
    497     PXOPT_LOOKUP_STR(ver_psphot, config->args, "-ver_psphot", false, false);
    498     PXOPT_LOOKUP_STR(ver_psastro, config->args, "-ver_psastro", false, false);
    499     PXOPT_LOOKUP_STR(ver_ppstats, config->args, "-ver_ppstats", false, false);
    500     PXOPT_LOOKUP_STR(ver_ppimage, config->args, "-ver_ppimage", false, false);
    501     PXOPT_LOOKUP_STR(ver_streaks, config->args, "-ver_streaks", false, false);
    502 
    503     PXOPT_LOOKUP_S32(maskfrac_ref_npix, config->args, "-maskfrac_ref_npix", false, false);
    504     PXOPT_LOOKUP_F32(maskfrac_ref_static, config->args, "-maskfrac_ref_static", false, false);
    505     PXOPT_LOOKUP_F32(maskfrac_ref_dynamic, config->args, "-maskfrac_ref_dynamic", false, false);
    506     PXOPT_LOOKUP_F32(maskfrac_ref_magic, config->args, "-maskfrac_ref_magic", false, false);
    507     PXOPT_LOOKUP_F32(maskfrac_ref_advisory, config->args, "-maskfrac_ref_advisory", false, false);
    508 
    509     PXOPT_LOOKUP_S32(maskfrac_max_npix, config->args, "-maskfrac_max_npix", false, false);
    510     PXOPT_LOOKUP_F32(maskfrac_max_static, config->args, "-maskfrac_max_static", false, false);
    511     PXOPT_LOOKUP_F32(maskfrac_max_dynamic, config->args, "-maskfrac_max_dynamic", false, false);
    512     PXOPT_LOOKUP_F32(maskfrac_max_magic, config->args, "-maskfrac_max_magic", false, false);
    513     PXOPT_LOOKUP_F32(maskfrac_max_advisory, config->args, "-maskfrac_max_advisory", false, false);
    514    
    515     PXOPT_LOOKUP_F32(ast_r0, config->args, "-ast_r0", false, false);
    516     PXOPT_LOOKUP_F32(ast_d0, config->args, "-ast_d0", false, false);
    517     PXOPT_LOOKUP_F32(ast_t0, config->args, "-ast_t0", false, false);
    518     PXOPT_LOOKUP_F32(ast_s0, config->args, "-ast_s0", false, false);
    519     PXOPT_LOOKUP_F32(ast_rs, config->args, "-ast_rs", false, false);
    520     PXOPT_LOOKUP_F32(ast_ds, config->args, "-ast_ds", false, false);
     384 
     385    PXOPT_LOOKUP_S16(fault, config->args,          "-fault", false, false);
     386    PXOPT_LOOKUP_S16(quality, config->args,        "-quality", false, false);
    521387
    522388    // we store actual detection efficiency by adding in zpt_obs
    523     PXOPT_LOOKUP_F32(deteff_inst, config->args, "-deteff_inst", false, false);
     389    PXOPT_LOOKUP_F32(deteff_inst, config->args,    "-deteff_inst", false, false);
    524390    PXOPT_LOOKUP_F32(deteff_inst_lq, config->args, "-deteff_inst_lq", false, false);
    525391    PXOPT_LOOKUP_F32(deteff_inst_uq, config->args, "-deteff_inst_uq", false, false);
    526     // error is dd
    527     PXOPT_LOOKUP_F32(deteff_err, config->args, "-deteff_inst_err", false, false);
     392    PXOPT_LOOKUP_F32(deteff_err, config->args,     "-deteff_inst_err", false, false);
     393
    528394    psF32 deteff = NAN;
    529395    psF32 deteff_uq = NAN;
    … …  
    541407    }
    542408
    543     psString software_ver = NULL;
    544     if ((ver_pslib)&&(ver_psmodules)) {
    545       software_ver = pxMergeCodeVersions(ver_pslib,ver_psmodules);
    546     }
    547     if (ver_psphot) {
    548       software_ver = pxMergeCodeVersions(software_ver,ver_psphot);
    549     }
    550     if (ver_psastro) {
    551       software_ver = pxMergeCodeVersions(software_ver,ver_psastro);
    552     }
    553     if (ver_ppstats) {
    554       software_ver = pxMergeCodeVersions(software_ver,ver_ppstats);
    555     }
    556     if (ver_ppimage) {
    557       software_ver = pxMergeCodeVersions(software_ver,ver_ppimage);
    558     }
    559     if (ver_streaks) {
    560       software_ver = pxMergeCodeVersions(software_ver,ver_streaks);
    561     }
    562 
    563 //    Get this from the chipRun
    564 //    PXOPT_LOOKUP_S64(magicked, config->args, "-magicked", false, false);
     409    PXOPT_LOOKUP_STR(ver_pslib,     config->args, "-ver_pslib",     false, false);
     410    PXOPT_LOOKUP_STR(ver_psmodules, config->args, "-ver_psmodules", false, false);
     411    PXOPT_LOOKUP_STR(ver_psphot,    config->args, "-ver_psphot",    false, false);
     412    PXOPT_LOOKUP_STR(ver_ppstats,   config->args, "-ver_ppstats",   false, false);
     413    PXOPT_LOOKUP_STR(ver_fpcamera,  config->args, "-ver_fpcamera",  false, false);
     414
     415    psString software_ver = pxMergeCodeVersions(ver_pslib,ver_psmodules);
     416    software_ver = pxMergeCodeVersions(software_ver,ver_psphot);
     417    software_ver = pxMergeCodeVersions(software_ver,ver_ppstats);
     418    software_ver = pxMergeCodeVersions(software_ver,ver_fpcamera);
    565419
    566420    // generate restrictions
    567     psMetadata *where = psMetadataAlloc();
    568     PXOPT_COPY_S64(config->args, where, "-cam_id",   "camRun.cam_id",   "==");
    569 
    570     psString query = pxDataGet("camtool_addprocessedexp.sql");
    571     if (!query) {
    572         psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    573         return false;
    574     }
    575 
    576     // use psDBGenerateWhereSQL because the SQL yields an intermediate table
    577     if (psListLength(where->list)) {
    578         psString whereClaus = psDBGenerateWhereConditionSQL(where, NULL);
    579         psStringAppend(&query, " AND %s", whereClaus);
    580         psFree(whereClaus);
    581     }
    582     psFree(where);
    583 
    584     if (!p_psDBRunQuery(config->dbh, query)) {
    585         psError(PS_ERR_UNKNOWN, false, "database error");
    586         psFree(query);
    587         return false;
    588     }
    589     psFree(query);
    590 
    591     psArray *output = p_psDBFetchResult(config->dbh);
    592     if (!output) {
    593         psError(PS_ERR_UNKNOWN, false, "database error");
    594         return false;
    595     }
    596     if (!psArrayLength(output)) {
    597         psTrace("camtool", PS_LOG_INFO, "no rows found");
    598         psFree(output);
    599         return false;
    600     }
    601 
    602421    if (!psDBTransaction(config->dbh)) {
    603422        psError(PS_ERR_UNKNOWN, false, "database error");
    604         psFree(output);
    605         return false;
    606     }
    607 
    608     bool status;
    609     psS64 chip_magicked = psMetadataLookupS64(&status, output->data[0], "chip_magicked");
    610 
    611     camRunRow *pendingRow = camRunObjectFromMetadata(output->data[0]);
    612     psFree(output);
    613     camProcessedExpRow *row = camProcessedExpRowAlloc(
    614         pendingRow->cam_id,
    615         uri,
    616         bg,
    617         bg_stdev,
    618         bg_mean_stdev,
    619         bias,
    620         bias_stdev,
    621         fringe_0,
    622         fringe_1,
    623         fringe_2,
    624         sigma_ra,
    625         sigma_dec,
    626         ap_resid,
    627         ap_resid_stdev,
     423        return false;
     424    }
     425
     426    fpcamProcessedExpRow *row = fpcamProcessedExpRowAlloc(
     427        fpcam_id,
     428        path_base,
    628429        zpt_obs,
    629430        zpt_err,
    630431        zpt_lq,
    631432        zpt_uq,
    632         fwhm_major,
    633         fwhm_major_lq,
    634         fwhm_major_uq,
    635         fwhm_minor,
    636         fwhm_minor_lq,
    637         fwhm_minor_uq,
    638 
    639         iq_fwhm_major,
    640         iq_fwhm_major_err,
    641         iq_fwhm_minor,
    642         iq_fwhm_minor_err,
    643 
    644         iq_m2,
    645         iq_m2_err,
    646         iq_m2_lq,
    647         iq_m2_uq,
    648         iq_m2c,
    649         iq_m2c_err,
    650         iq_m2c_lq,
    651         iq_m2c_uq,
    652         iq_m2s,
    653         iq_m2s_err,
    654         iq_m2s_lq,
    655         iq_m2s_uq,
    656         iq_m3,
    657         iq_m3_err,
    658         iq_m3_lq,
    659         iq_m3_uq,
    660         iq_m4,
    661         iq_m4_err,
    662         iq_m4_lq,
    663         iq_m4_uq,
    664433        dtime_script,
    665         dtime_astrom,
    666         dtime_addstar,
    667434        hostname,
    668435        n_stars,
    669         n_psfstars,
    670         n_iqstars,
    671         n_extended,
    672         n_cr,
    673         n_astrom,
    674         path_base,
    675436        fault,
     437        NULL, // XXX : this should be epoch
    676438        software_ver,
    677         maskfrac_ref_npix,
    678         maskfrac_ref_static,
    679         maskfrac_ref_dynamic,
    680         maskfrac_ref_magic,
    681         maskfrac_ref_advisory,
    682         maskfrac_max_npix,
    683         maskfrac_max_static,
    684         maskfrac_max_dynamic,
    685         maskfrac_max_magic,
    686         maskfrac_max_advisory,
    687439        deteff,
    688440        deteff_err,
    689441        deteff_lq,
    690442        deteff_uq,
    691         quality,
    692         background_model,
    693         astrom_chips,
    694 
    695         ast_r0,
    696         ast_d0,
    697         ast_t0,
    698         ast_s0,
    699         ast_rs,
    700         ast_ds
     443        quality
    701444        );
    702445
    703     if (!camProcessedExpInsertObject(config->dbh, row)) {
     446    if (!fpcamProcessedExpInsertObject(config->dbh, row)) {
    704447        // rollback
    705448        if (!psDBRollback(config->dbh)) {
    … …  
    708451        psError(PS_ERR_UNKNOWN, false, "database error");
    709452        psFree(row);
    710         psFree(pendingRow);
    711453        return false;
    712454    }
    … …  
    714456    if (fault) {
    715457        psFree(row);
    716         psFree(pendingRow);
    717458        if (!psDBCommit(config->dbh)) {
    718459            psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    723464    // else continue on...
    724465
    725 
    726     // Set camRun.software_ver to the appropriate value
    727     if (!pxSetRunSoftware(config, "camRun", "cam_id", cam_id, software_ver)) {
    728       if (!psDBRollback(config->dbh)) {
    729         psError(PS_ERR_UNKNOWN, false, "database error");
    730       }
    731       psError(PS_ERR_UNKNOWN, false, "failed to set camRun.software_ver for cam_id: %" PRId64,
    732               cam_id);
    733       psFree(output);
    734       return(false);
    735     }
    736     // Set chipRun.maskfrac* to the appropriate values.
    737     if (maskfrac_ref_npix) {
    738       if (!pxCamSetRunMaskfrac(config, "camRun", "cam_id",cam_id,
    739                                (float) maskfrac_ref_npix, maskfrac_ref_static,
    740                                maskfrac_ref_dynamic, maskfrac_ref_magic, maskfrac_ref_advisory,
    741                                (float) maskfrac_max_npix, maskfrac_max_static,
    742                                maskfrac_max_dynamic, maskfrac_max_magic, maskfrac_max_advisory)) {
    743         if (!psDBRollback(config->dbh)) {
    744           psError(PS_ERR_UNKNOWN, false, "database error");
    745         }
    746         psError(PS_ERR_UNKNOWN, false, "failed to set camRun.maskstats for cam_id: %" PRId64,
    747                 cam_id);
    748         psFree(output);
    749         return(false);
    750       }
    751     }
    752 
    753466    // since there is only one exp per 'new' set camRun.state = 'full'
    754     // propagate magicked state from chipRun
    755     if (!pxcamRunSetState(config, row->cam_id, "full", chip_magicked)) {
    756         psError(PS_ERR_UNKNOWN, false, "failed to change camRun.state for cam_id: %" PRId64, row->cam_id);
     467    if (!pxfpcamRunSetState(config, row->fpcam_id, "full")) {
     468        psError(PS_ERR_UNKNOWN, false, "failed to change fpcamRun.state for fpcam_id: %" PRId64, row->fpcam_id);
    757469        psFree(row);
    758         psFree(pendingRow);
    759470        return false;
    760471    }
    … …  
    762473    psFree(row);
    763474
    764     // EAM:  NULL for end_stage means go as far as possible
    765     // Also, we can run fake even if tess_id is not defined
    766     // but stop if quality is non-zero.
    767     if ((quality > 0) || (pendingRow->end_stage && psStrcasestr(pendingRow->end_stage, "cam"))) {
    768         psFree(pendingRow);
    769         if (!psDBCommit(config->dbh)) {
    770             psError(PS_ERR_UNKNOWN, false, "database error");
    771             return false;
    772         }
    773         return true;
    774     }
    775 
    776     if (!pxfakeQueueByCamID(config,
    777             pendingRow->cam_id,
    778             pendingRow->workdir,
    779             pendingRow->label,
    780             pendingRow->data_group,
    781             pendingRow->dist_group,
    782             pendingRow->reduction,
    783             pendingRow->expgroup,
    784             pendingRow->dvodb,
    785             pendingRow->tess_id,
    786             pendingRow->end_stage,
    787             NULL    // note does not propagate
    788     )) {
    789         // rollback
    790         if (!psDBRollback(config->dbh)) {
    791             psError(PS_ERR_UNKNOWN, false, "database error");
    792         }
    793         psError(PS_ERR_UNKNOWN, false, "failed to queue new fakeRun");
    794         psFree(pendingRow);
    795         return false;
    796     }
    797 
    798     psFree(pendingRow);
     475    // fpcam is a stand-alone stage: it does not trigger another stage to follow
    799476
    800477    if (!psDBCommit(config->dbh)) {
    … …  
    802479        return false;
    803480    }
    804 
    805     return true;
    806 }
    807 
     481    return true;
     482}
    808483
    809484static bool processedexpMode(pxConfig *config)
    … …  
    811486    PS_ASSERT_PTR_NON_NULL(config, false);
    812487
     488    // some options
    813489    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    814490    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    815491    PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    816     PXOPT_LOOKUP_BOOL(pstamp_order, config->args, "-pstamp_order", false);
    817492
    818493    // generate restrictions
    819494    psMetadata *where = psMetadataAlloc();
    820     pxcamGetSearchArgs (config, where);
    821     PXOPT_COPY_S64(config->args, where, "-cam_id",    "camRun.cam_id",    "==");
    822     pxAddLabelSearchArgs (config, where, "-label",    "camRun.label",     "==");
    823     pxAddLabelSearchArgs (config, where, "-data_group", "camRun.data_group",     "LIKE");
    824     PXOPT_COPY_STR(config->args, where, "-reduction", "camRun.reduction", "==");
    825     PXOPT_COPY_S16(config->args, where, "-background_model", "camProcessedExp.background_model", "==");
     495    pxfpcamGetSearchArgs (config, where);
     496    PXOPT_COPY_S64(config->args,  where, "-fpcam_id",    "fpcamRun.fpcam_id", "==");
     497    PXOPT_COPY_S64(config->args,  where, "-cam_id",      "fpcamRun.cam_id", "==");
     498    PXOPT_COPY_S64(config->args,  where, "-chip_id",     "fpcamRun.chip_id", "==");
     499    pxAddLabelSearchArgs (config, where, "-label",       "fpcamRun.label",     "==");
     500    pxAddLabelSearchArgs (config, where, "-data_group",  "fpcamRun.data_group",     "LIKE");
     501    PXOPT_COPY_STR(config->args,  where, "-reduction",   "fpcamRun.reduction", "==");
    826502   
    827503    psString where2 = NULL;
    … …  
    830506        return false;
    831507    }
    832     if (!pxmagicAddWhere(config, &where2, "chipRun")) {
    833         psError(psErrorCodeLast(), false, "pxSpaceAddWhere failed");
    834         return false;
    835     }
    836     if (!psListLength(where->list) && !where2 &&
    837         !psMetadataLookupBool(NULL, config->args, "-all")) {
     508    if (!psListLength(where->list) && !where2) {
    838509        psFree(where);
    839         psError(PXTOOLS_ERR_CONFIG, false, "search parameters (or -all) are required");
    840         return false;
    841     }
    842 
    843     psString query = pxDataGet("camtool_find_processedexp.sql");
     510        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     511        return false;
     512    }
     513
     514    psString query = pxDataGet("fpcamtool_find_processedexp.sql");
    844515    if (!query) {
    845516        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    … …  
    856527    if (where->list && faulted) {
    857528        // list only faulted rows
    858         psStringAppend(&query, " %s", " AND camProcessedExp.fault != 0");
     529        psStringAppend(&query, " %s", " AND fpcamProcessedExp.fault != 0");
    859530    }
    860531    if (where->list && !faulted) {
    861532        // don't list faulted rows
    862         psStringAppend(&query, " %s", " AND camProcessedExp.fault = 0");
     533        psStringAppend(&query, " %s", " AND fpcamProcessedExp.fault = 0");
    863534    }
    864535    if (!where->list && faulted) {
    865536        // list only faulted rows
    866         psStringAppend(&query, " %s", " WHERE camProcessedExp.fault != 0");
     537        psStringAppend(&query, " %s", " WHERE fpcamProcessedExp.fault != 0");
    867538    }
    868539    if (!where->list && !faulted) {
    869540        // don't list faulted rows
    870         psStringAppend(&query, " %s", " WHERE camProcessedExp.fault = 0");
     541        psStringAppend(&query, " %s", " WHERE fpcamProcessedExp.fault = 0");
    871542    }
    872543    psFree(where);
    … …  
    874545        psStringAppend(&query, " %s", where2);
    875546        psFree(where2);
    876     }
    877 
    878 
    879     if (pstamp_order) {
    880         // put runs in order of exposure id with newest chip Runs first
    881         // The postage stamp parser depends on this behavior
    882         psStringAppend(&query, " ORDER BY exp_id, cam_id DESC");
    883547    }
    884548
    … …  
    903567    }
    904568    if (!psArrayLength(output)) {
    905         psTrace("camtool", PS_LOG_INFO, "no rows found");
     569        psTrace("fpcamtool", PS_LOG_INFO, "no rows found");
    906570        psFree(output);
    907571        return true;
    … …  
    909573
    910574    // negate simple so the default is true
    911     if (!ippdbPrintMetadatas(stdout, output, "camProcessedExp", !simple)) {
     575    if (!ippdbPrintMetadatas(stdout, output, "fpcamProcessedExp", !simple)) {
    912576        psError(PS_ERR_UNKNOWN, false, "failed to print array");
    913577        psFree(output);
    … …  
    926590
    927591    psMetadata *where = psMetadataAlloc();
    928     pxcamGetSearchArgs (config, where);
    929     PXOPT_COPY_S64(config->args, where, "-cam_id",    "camRun.cam_id",         "==");
    930     pxAddLabelSearchArgs (config, where, "-label",    "camRun.label",     "==");
    931     PXOPT_COPY_STR(config->args, where, "-reduction", "camRun.reduction",      "==");
    932     PXOPT_COPY_S16(config->args, where, "-fault", "camProcessedExp.fault", "==");
    933 
    934     if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
     592    pxfpcamGetSearchArgs (config, where);
     593
     594    PXOPT_COPY_S64(config->args,  where, "-fpcam_id",    "fpcamRun.fpcam_id", "==");
     595    PXOPT_COPY_S64(config->args,  where, "-cam_id",      "fpcamRun.cam_id", "==");
     596    PXOPT_COPY_S64(config->args,  where, "-chip_id",     "fpcamRun.chip_id", "==");
     597    PXOPT_COPY_STR(config->args,  where, "-reduction",   "fpcamRun.reduction", "==");
     598    PXOPT_COPY_S16(config->args, where,  "-fault",       "fpcamProcessedExp.fault", "==");
     599
     600    pxAddLabelSearchArgs (config, where, "-label",       "fpcamRun.label",     "==");
     601    pxAddLabelSearchArgs (config, where, "-data_group",  "fpcamRun.data_group",     "LIKE");
     602
     603    if (!psListLength(where->list)) {
    935604        psFree(where);
    936605        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    … …  
    946615    psString whereClause = NULL;
    947616    {
    948         psString query = pxDataGet("camtool_revertprocessedexp.sql");
     617        psString query = pxDataGet("fpcamtool_revertprocessedexp.sql");
    949618        if (!query) {
    950619            // rollback
    … …  
    982651        return false;
    983652    }
    984     psLogMsg("camtool", PS_LOG_INFO, "Deleted %d camProcessedExps", numDeleted);
     653    psLogMsg("fpcamtool", PS_LOG_INFO, "Deleted %d fpcamProcessedExps", numDeleted);
    985654
    986655    {
    987         psString query = pxDataGet("camtool_revertupdatedexp.sql");
     656        psString query = pxDataGet("fpcamtool_revertupdatedexp.sql");
    988657        if (!query) {
    989658            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    … …  
    1004673    }
    1005674    int numUpdated = psDBAffectedRows(config->dbh);
    1006     psLogMsg("camtool", PS_LOG_INFO, "Updated %d camProcessedExps", numUpdated);
     675    psLogMsg("fpcamtool", PS_LOG_INFO, "Updated %d fpcamProcessedExps", numUpdated);
    1007676
    1008677    return true;
    … …  
    1016685    PXOPT_LOOKUP_S16(fault, config->args, "-fault", true, false);
    1017686    PXOPT_LOOKUP_S16(quality, config->args, "-set_quality", false, false);
    1018     PXOPT_LOOKUP_S16(background_model, config->args, "-set_background_model", false, false);
    1019     if (background_model) {
    1020       // CZW Copied from warptool.c
    1021       psMetadata *where = psMetadataAlloc();
    1022       psMetadata *values = psMetadataAlloc();
    1023       PXOPT_COPY_S64(config->args, where, "-cam_id", "cam_id", "==");
    1024       PXOPT_COPY_S16(config->args, values, "-set_background_model", "background_model", "==");
    1025       long rows = psDBUpdateRows(config->dbh, "camProcessedExp", where, values);
    1026       psFree(values);
    1027       psFree(where);
    1028       if (!rows) {
    1029         psError(PS_ERR_UNKNOWN, true, "no rows changed");
    1030       }
    1031     }
    1032     else {
    1033       psMetadata *where = psMetadataAlloc();
    1034       PXOPT_COPY_S64(config->args, where, "-cam_id",   "cam_id",   "==");
    1035       PXOPT_COPY_S64(config->args, where, "-chip_id",  "chip_id",  "==");
    1036       PXOPT_COPY_STR(config->args, where, "-class",    "class",    "==");
    1037       PXOPT_COPY_STR(config->args, where, "-class_id", "class_id", "==");
    1038      
    1039       if (!pxSetFaultCode(config->dbh, "camProcessedExp", where, fault, quality)) {
    1040         psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag");
     687
     688    psMetadata *where = psMetadataAlloc();
     689    PXOPT_COPY_S64(config->args, where, "-fpcam_id", "fpcam_id", "==");
     690    PXOPT_COPY_S64(config->args, where, "-cam_id",   "cam_id",   "==");
     691    PXOPT_COPY_S64(config->args, where, "-chip_id",  "chip_id",  "==");
     692
     693    if (!pxSetFaultCode(config->dbh, "fpcamProcessedExp", where, fault, quality)) {
     694        psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag");
    1041695        psFree (where);
    1042696        return false;
    1043       }
    1044       psFree (where);
    1045     }
    1046     return true;
    1047 }
    1048 
     697    }
     698    psFree (where);
     699    return true;
     700}
    1049701
    1050702static bool blockMode(pxConfig *config)
    … …  
    1054706    PXOPT_LOOKUP_STR(label, config->args, "-label", true, false);
    1055707
    1056     if (!camMaskInsert(config->dbh, label)) {
    1057         psError(PS_ERR_UNKNOWN, false, "database error");
    1058         return false;
    1059     }
    1060 
    1061     return true;
    1062 }
    1063 
     708    if (!fpcamMaskInsert(config->dbh, label)) {
     709        psError(PS_ERR_UNKNOWN, false, "database error");
     710        return false;
     711    }
     712    return true;
     713}
    1064714
    1065715static bool maskedMode(pxConfig *config)
    … …  
    1069719    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    1070720
    1071     psString query = psStringCopy("SELECT * FROM camMask");
     721    psString query = psStringCopy("SELECT * FROM fpcamMask");
    1072722
    1073723    if (!p_psDBRunQuery(config->dbh, query)) {
    … …  
    1084734    }
    1085735    if (!psArrayLength(output)) {
    1086         psTrace("camtool", PS_LOG_INFO, "no rows found");
     736        psTrace("fpcamtool", PS_LOG_INFO, "no rows found");
    1087737        psFree(output);
    1088738        return true;
    … …  
    1090740
    1091741    // negative simple so the default is true
    1092     if (!ippdbPrintMetadatas(stdout, output, "camMask", !simple)) {
     742    if (!ippdbPrintMetadatas(stdout, output, "fpcamMask", !simple)) {
    1093743        psError(PS_ERR_UNKNOWN, false, "failed to print array");
    1094744        psFree(output);
    … …  
    1097747
    1098748    psFree(output);
    1099 
    1100     return true;
    1101 }
    1102 
     749    return true;
     750}
    1103751
    1104752static bool unblockMode(pxConfig *config)
    … …  
    1108756    PXOPT_LOOKUP_STR(label, config->args, "-label", true, false);
    1109757
    1110     char *query = "DELETE FROM camMask WHERE label = '%s'";
     758    char *query = "DELETE FROM fpcamMask WHERE label = '%s'";
    1111759
    1112760    if (!p_psDBRunQueryF(config->dbh, query, label)) {
    … …  
    1118766}
    1119767
    1120 static bool pendingcleanuprunMode(pxConfig *config)
    1121 {
    1122     PS_ASSERT_PTR_NON_NULL(config, NULL);
    1123 
    1124     PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    1125     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    1126     PXOPT_LOOKUP_BOOL(all, config->args, "-all", false);
    1127 
    1128     psMetadata *where = psMetadataAlloc();
    1129     pxAddLabelSearchArgs (config, where, "-label", "camRun.label", "==");
    1130 
    1131     psString query = pxDataGet("camtool_pendingcleanuprun.sql");
    1132     if (!query) {
    1133         psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    1134         return false;
    1135     }
    1136 
    1137     if (psListLength(where->list)) {
    1138         psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    1139         psStringAppend(&query, " AND %s", whereClause);
    1140         psFree(whereClause);
    1141     } else {
    1142       if (!all) {
    1143         psError(PXTOOLS_ERR_SYS, false, "unrestricted query not allowed (try -all)");
    1144         return false;
    1145       }
    1146     }
    1147     psFree(where);
    1148 
    1149     // treat limit == 0 as "no limit"
    1150     if (limit) {
    1151         psString limitString = psDBGenerateLimitSQL(limit);
    1152         psStringAppend(&query, " %s", limitString);
    1153         psFree(limitString);
    1154     }
    1155 
    1156     if (!p_psDBRunQuery(config->dbh, query)) {
    1157         psError(PS_ERR_UNKNOWN, false, "database error");
    1158         psFree(query);
    1159         return false;
    1160     }
    1161     psFree(query);
    1162 
    1163     psArray *output = p_psDBFetchResult(config->dbh);
    1164     if (!output) {
    1165         psError(PS_ERR_UNKNOWN, false, "database error");
    1166         return false;
    1167     }
    1168     if (!psArrayLength(output)) {
    1169         psTrace("camtool", PS_LOG_INFO, "no rows found");
    1170         psFree(output);
    1171         return true;
    1172     }
    1173 
    1174     // negative simple so the default is true
    1175     if (!ippdbPrintMetadatas(stdout, output, "camPendingCleanupRun", !simple)) {
    1176         psError(PS_ERR_UNKNOWN, false, "failed to print array");
    1177         psFree(output);
    1178         return false;
    1179     }
    1180 
    1181     psFree(output);
    1182 
    1183     return true;
    1184 }
    1185 
    1186 
    1187 static bool pendingcleanupexpMode(pxConfig *config)
    1188 {
    1189     PS_ASSERT_PTR_NON_NULL(config, NULL);
    1190 
    1191     PXOPT_LOOKUP_S64(cam_id, config->args, "-cam_id", false, false);
    1192     PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    1193     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    1194     PXOPT_LOOKUP_BOOL(all, config->args, "-all", false);
    1195 
    1196     psMetadata *where = psMetadataAlloc();
    1197     if (cam_id) {
    1198         PXOPT_COPY_S64(config->args, where, "-cam_id", "cam_id", "==");
    1199     }
    1200     pxAddLabelSearchArgs (config, where, "-label", "label", "==");
    1201 
    1202     psString query = pxDataGet("camtool_pendingcleanupexp.sql");
    1203     if (!query) {
    1204         psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    1205         return false;
    1206     }
    1207 
    1208     if (psListLength(where->list)) {
    1209         psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    1210         psStringAppend(&query, " AND %s", whereClause);
    1211         psFree(whereClause);
    1212     } else {
    1213       if (!all) {
    1214         psError(PXTOOLS_ERR_SYS, false, "unrestricted query not allowed (try -all)");
    1215         return false;
    1216       }
    1217     }
    1218     psFree(where);
    1219 
    1220     // treat limit == 0 as "no limit"
    1221     if (limit) {
    1222         psString limitString = psDBGenerateLimitSQL(limit);
    1223         psStringAppend(&query, " %s", limitString);
    1224         psFree(limitString);
    1225     }
    1226 
    1227     if (!p_psDBRunQuery(config->dbh, query)) {
    1228         psError(PS_ERR_UNKNOWN, false, "database error");
    1229         psFree(query);
    1230         return false;
    1231     }
    1232     psFree(query);
    1233 
    1234     psArray *output = p_psDBFetchResult(config->dbh);
    1235     if (!output) {
    1236         psError(PS_ERR_UNKNOWN, false, "database error");
    1237         return false;
    1238     }
    1239     if (!psArrayLength(output)) {
    1240         psTrace("chiptool", PS_LOG_INFO, "no rows found");
    1241         psFree(output);
    1242         return true;
    1243     }
    1244 
    1245     // negative simple so the default is true
    1246     if (!ippdbPrintMetadatas(stdout, output, "camPendingCleanupExp", !simple)) {
    1247         psError(PS_ERR_UNKNOWN, false, "failed to print array");
    1248         psFree(output);
    1249         return false;
    1250     }
    1251 
    1252     psFree(output);
    1253 
    1254     return true;
    1255 }
    1256 
    1257 
    1258 static bool donecleanupMode(pxConfig *config)
    1259 {
    1260     PS_ASSERT_PTR_NON_NULL(config, NULL);
    1261 
    1262     PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    1263     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    1264 
    1265     psMetadata *where = psMetadataAlloc();
    1266     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
    1267 
    1268     psString query = pxDataGet("camtool_donecleanup.sql");
    1269     if (!query) {
    1270         psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    1271         return false;
    1272     }
    1273 
    1274     if (where && psListLength(where->list)) {
    1275         psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    1276         psStringAppend(&query, " AND %s", whereClause);
    1277         psFree(whereClause);
    1278     }
    1279     psFree(where);
    1280 
    1281     // treat limit == 0 as "no limit"
    1282     if (limit) {
    1283         psString limitString = psDBGenerateLimitSQL(limit);
    1284         psStringAppend(&query, " %s", limitString);
    1285         psFree(limitString);
    1286     }
    1287 
    1288     if (!p_psDBRunQuery(config->dbh, query)) {
    1289         psError(PS_ERR_UNKNOWN, false, "database error");
    1290         psFree(query);
    1291         return false;
    1292     }
    1293     psFree(query);
    1294 
    1295     psArray *output = p_psDBFetchResult(config->dbh);
    1296     if (!output) {
    1297         psError(PS_ERR_UNKNOWN, false, "database error");
    1298         return false;
    1299     }
    1300     if (!psArrayLength(output)) {
    1301         psTrace("camtool", PS_LOG_INFO, "no rows found");
    1302         psFree(output);
    1303         return true;
    1304     }
    1305 
    1306     // negative simple so the default is true
    1307     if (!ippdbPrintMetadatas(stdout, output, "camDoneCleanup", !simple)) {
    1308         psError(PS_ERR_UNKNOWN, false, "failed to print array");
    1309         psFree(output);
    1310         return false;
    1311     }
    1312 
    1313     psFree(output);
    1314 
    1315     return true;
    1316 }
    1317 
    1318 bool exportrunMode(pxConfig *config)
    1319 {
    1320   typedef struct ExportTable {
    1321     char tableName[80];
    1322     char sqlFilename[80];
    1323   } ExportTable;
    1324 
    1325   int numExportTables = 2;
    1326 
    1327   PS_ASSERT_PTR_NON_NULL(config, NULL);
    1328 
    1329   // PXOPT_LOOKUP_S64(det_id, config->args, "-cam_id", true,  false);
    1330   PXOPT_LOOKUP_STR(outfile, config->args, "-outfile", true,  false);
    1331   PXOPT_LOOKUP_U64(limit,   config->args, "-limit",   false, false);
    1332   PXOPT_LOOKUP_BOOL(clean, config->args, "-clean", false);
    1333 
    1334   FILE *f = fopen (outfile, "w");
    1335   if (f == NULL) {
    1336     psError(PS_ERR_UNKNOWN, false, "failed to open output file");
    1337     return false;
    1338   }
    1339 
    1340   if (!pxExportVersion(config, f)) {
    1341     psError(PS_ERR_UNKNOWN, false, "failed to write dbversion output file");
    1342     return false;
    1343   }
    1344 
    1345   psMetadata *where = psMetadataAlloc();
    1346   PXOPT_COPY_S64(config->args, where, "-cam_id", "cam_id", "==");
    1347 
    1348   ExportTable tables [] = {
    1349     {"camRun", "camtool_export_run.sql"},
    1350     {"camProcessedExp", "camtool_export_processed_exp.sql"},
    1351   };
    1352 
    1353   for (int i=0; i < numExportTables; i++) {
    1354     psString query = pxDataGet(tables[i].sqlFilename);
    1355     if (!query) {
    1356       psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    1357       return false;
    1358     }
    1359 
    1360     if (where && psListLength(where->list)) {
    1361       psString whereClause = psDBGenerateWhereSQL(where, NULL);
    1362       psStringAppend(&query, " %s", whereClause);
    1363       psFree(whereClause);
    1364     }
    1365 
    1366     // treat limit == 0 as "no limit"
    1367     if (limit) {
    1368       psString limitString = psDBGenerateLimitSQL(limit);
    1369       psStringAppend(&query, " %s", limitString);
    1370       psFree(limitString);
    1371     }
    1372 
    1373     if (!p_psDBRunQuery(config->dbh, query)) {
    1374       psError(PS_ERR_UNKNOWN, false, "database error");
    1375       psFree(query);
    1376       return false;
    1377     }
    1378     psFree(query);
    1379 
    1380     psArray *output = p_psDBFetchResult(config->dbh);
    1381     if (!output) {
    1382       psError(PS_ERR_UNKNOWN, false, "database error");
    1383       return false;
    1384     }
    1385     if (!psArrayLength(output)) {
    1386       psError(PS_ERR_UNKNOWN, true, "no rows found");
    1387       psFree(output);
    1388       return false;
    1389     }
    1390 
    1391     if (clean) {
    1392         if (!strcmp(tables[i].tableName, "camRun")) {
    1393             if (!pxSetStateCleaned("camRun", "state", output)) {
    1394                 psFree(output);
    1395                 psError(PS_ERR_UNKNOWN, false, "pxSetStateClean failed for table %s",  tables[i].tableName);
    1396                 return false;
    1397             }
    1398         }
    1399     }
    1400 
    1401     // we must write the export table in non-simple (true) format
    1402     if (!ippdbPrintMetadatas(f, output, tables[i].tableName, true)) {
    1403       psError(PS_ERR_UNKNOWN, false, "failed to print array");
    1404       psFree(output);
    1405       return false;
    1406     }
    1407     psFree(output);
    1408   }
    1409 
    1410   fclose (f);
    1411 
    1412   return true;
    1413 }
    1414 
    1415 bool importrunMode(pxConfig *config)
    1416 {
    1417   unsigned int nFail;
    1418 
    1419   PS_ASSERT_PTR_NON_NULL(config, NULL);
    1420 
    1421   PXOPT_LOOKUP_STR(infile, config->args, "-infile", true,  false);
    1422 
    1423   psMetadata *input = psMetadataConfigRead (NULL, &nFail, infile, false);
    1424 
    1425 #ifdef notdef
    1426   fprintf (stderr, "---- input ----\n");
    1427   psMetadataPrint (stderr, input, 1);
    1428 #endif
    1429 
    1430   if (!pxCheckImportVersion(config, input)) {
    1431       psError(PS_ERR_UNKNOWN, false, "pxCheckImportVersion failed");
    1432       return false;
    1433   }
    1434 
    1435   psMetadataItem *item = psMetadataLookup (input, "camRun");
    1436   psAssert (item, "entry not in input?");
    1437   psAssert (item->type == PS_DATA_METADATA_MULTI, "entry not multi?");
    1438 
    1439   psMetadataItem *entry = psListGet (item->data.list, 0);
    1440   assert (entry);
    1441   assert (entry->type == PS_DATA_METADATA);
    1442   camRunRow *camRun = camRunObjectFromMetadata (entry->data.md);
    1443   camRunInsertObject (config->dbh, camRun);
    1444 
    1445   // fprintf (stdout, "---- cam run ----\n");
    1446   // psMetadataPrint (stderr, entry->data.md, 1);
    1447 
    1448   item = psMetadataLookup (input, "camProcessedExp");
    1449   psAssert (item, "entry not in input?");
    1450   psAssert (item->type == PS_DATA_METADATA_MULTI, "entry not multi?");
    1451 
    1452   for (int i = 0; i < item->data.list->n; i++) {
    1453     psMetadataItem *entry = psListGet (item->data.list, i);
    1454     assert (entry);
    1455     assert (entry->type == PS_DATA_METADATA);
    1456     camProcessedExpRow *camProcessedExp = camProcessedExpObjectFromMetadata (entry->data.md);
    1457     camProcessedExpInsertObject (config->dbh, camProcessedExp);
    1458 
    1459     // fprintf (stdout, "---- row %d ----\n", i);
    1460     // psMetadataPrint (stderr, entry->data.md, 1);
    1461   }
    1462 
    1463   return true;
    1464 }

  • branches/eam_branches/ipp-20220316/ippTools/src/fpcamtoolConfig.c

    r42195 r42197  
    11/*
    2  * camtoolConfig.c
     2 * fpcamtoolConfig.c
    33 *
    44 * Copyright (C) 2006  Joshua Hoblitt
    … …  
    2828
    2929#include "pxtools.h"
    30 #include "pxcam.h"
    31 #include "camtool.h"
    32 
    33 pxConfig *camtoolConfig(pxConfig *config, int argc, char **argv)
     30#include "pxfpcam.h"
     31#include "fpcamtool.h"
     32
     33pxConfig *fpcamtoolConfig(pxConfig *config, int argc, char **argv)
    3434{
    3535    if (!config) {
    … …  
    4848
    4949    // -definebyquery
    50     // XXX need to allow multiple chip_ids
    51     // XXX need to allow multiple exp_ids
    5250    psMetadata *definebyqueryArgs = psMetadataAlloc();
    53     pxcamSetSearchArgs(definebyqueryArgs);
    54     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by chipRun label", NULL);
    55     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-reduction",          0, "search by chipRun reduction class", NULL);
    56     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-data_group",         0, "search by chipRun data_group", NULL);
    57     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-obs_mode",           0, "search by rawExp obs_mode", NULL);
    58 
     51    pxfpcamSetSearchArgs(definebyqueryArgs);
     52    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-chip_label", PS_META_DUPLICATE_OK, "search by chipRun label", NULL);
     53    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-chip_reduction",          0, "search by chipRun reduction class", NULL);
     54    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-chip_data_group",         0, "search by chipRun data_group", NULL);
     55    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-cam_label", PS_META_DUPLICATE_OK, "search by camRun label", NULL);
     56    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-cam_reduction",          0, "search by camRun reduction class", NULL);
     57    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-cam_data_group",         0, "search by camRun data_group", NULL);
    5958    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_workdir",        0, "define workdir", NULL);
    6059    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_label",          0, "define label", NULL);
    61     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_reduction",      0, "define reduction class", NULL);
    62     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_expgroup",       0, "define exposure group", NULL);
    63     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_dvodb",          0, "define DVO db", NULL);
    64     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_tess_id",        0, "define tess ID", NULL);
    65     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_end_stage",      0, "define end stage", NULL);
    6660    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_data_group",     0, "define data group", NULL);
    6761    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_dist_group",     0, "define dist group", NULL);
     62    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_reduction",      0, "define reduction class", NULL);
     63    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_dvodb",          0, "define DVO db", NULL);
    6864    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_note",           0, "define note", NULL);
    6965    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-pretend",           0, "do not actual modify the database", false);
    … …  
    7167
    7268    // -updaterun
    73     // XXX need to allow multiple cam_ids
    74     // XXX need to allow multiple chip_ids
    75     // XXX need to allow multiple exp_ids
    7669    psMetadata *updaterunArgs = psMetadataAlloc();
    77     pxcamSetSearchArgs(updaterunArgs);
    78     psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-cam_id",             0, "search by cam_id", 0);
    79     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label",              0, "search by camRun label", NULL);
    80     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-data_group",         0, "search by camRun data_group", NULL);
    81     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state",              0, "search by camRun state", NULL);
    82     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-reduction",          0, "search by camRun reduction class", NULL);
    83     psMetadataAddBool(updaterunArgs, PS_LIST_TAIL, "-all",               0, "allow everything to be queued without search terms", false);
     70    pxfpcamSetSearchArgs(updaterunArgs);
     71    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-fpcam_id",           0, "search by fpcam_id", 0);
     72    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state",              0, "search by fpcamRun state", NULL);
     73    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label",              0, "search by fpcamRun label", NULL);
     74    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-data_group",         0, "search by fpcamRun data_group", NULL);
     75    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-dist_group",         0, "search by fpcamRun dist_group", NULL);
     76    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-reduction",          0, "search by fpcamRun reduction class", NULL);
    8477    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_state",          0, "set state", NULL);
    8578    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_label",          0, "set label", NULL);
    86     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_data_group", 0,   "define new data_group", NULL);
    87     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_dist_group", 0,   "define new dist_group", NULL);
    88     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_note", 0,         "define new note", NULL);
    89     pxmagicAddArguments(updaterunArgs);
     79    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_data_group",     0,   "define new data_group", NULL);
     80    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_dist_group",     0,   "define new dist_group", NULL);
     81    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_note",           0,         "define new note", NULL);
    9082
    9183    // -pendingexp
    9284    psMetadata *pendingexpArgs = psMetadataAlloc();
    93     pxcamSetSearchArgs(pendingexpArgs);
    94     psMetadataAddS64(pendingexpArgs, PS_LIST_TAIL, "-cam_id",            0, "search by cam_id", 0);
    95     psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by camRun label", NULL);
    96     psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-reduction",         0, "search by camRun reduction class", NULL);
     85    pxfpcamSetSearchArgs(pendingexpArgs);
     86    psMetadataAddS64(pendingexpArgs, PS_LIST_TAIL, "-fpcam_id",            0, "search by fpcam_id", 0);
     87    psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by fpcamRun label", NULL);
     88    psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-reduction",         0, "search by fpcamRun reduction class", NULL);
    9789    psMetadataAddU64(pendingexpArgs, PS_LIST_TAIL, "-limit",             0, "limit result set to N items", 0);
    9890    psMetadataAddBool(pendingexpArgs, PS_LIST_TAIL, "-simple",           0, "use the simple output format", false);
    9991    psMetadataAddBool(pendingexpArgs, PS_LIST_TAIL, "-all",               0, "allow everything to be queued without search terms", false);
    10092
    101     // -pendingimfile
    102     psMetadata *pendingimfileArgs = psMetadataAlloc();
    103     pxcamSetSearchArgs(pendingimfileArgs);
    104     psMetadataAddS64(pendingimfileArgs, PS_LIST_TAIL, "-cam_id",   0,            "search by camtool ID", 0);
    105     psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by camRun label", NULL);
    106     psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-reduction",0,            "search by camRun reduction class", NULL);
    107     psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-class_id", 0,            "search by class ID", NULL);
    108     psMetadataAddBool(pendingimfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    109     psMetadataAddBool(pendingimfileArgs, PS_LIST_TAIL, "-all",     0,            "allow everything to be queued without search terms", false);
    110 
    111     // XXX is this used? psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-class",    0,            "search by class", NULL);
    112 
    11393    // -addprocessedexp
    11494    psMetadata *addprocessedexpArgs = psMetadataAlloc();
    115     psMetadataAddS64(addprocessedexpArgs, PS_LIST_TAIL, "-cam_id", 0,            "define camtool ID (required)", 0);
    116     psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-uri", 0,            "define URI (required)", NULL);
    117     psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-bg", 0,            "define exposure background", NAN);
    118     psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-bg_stdev", 0,            "define exposure background stdev", NAN);
    119     psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-bg_mean_stdev", 0,            "define exposure background mean stdev", NAN);
    120     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-bias",  0,            "define bias", NAN);
    121     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-bias_stdev",  0,            "define bias stdev", NAN);
    122     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-fringe_0",  0,            "define fringe term 0", NAN);
    123     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-fringe_1",  0,            "define fringe term 1", NAN);
    124     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-fringe_2",  0,            "define fringe term 2", NAN);
    125     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-sigma_ra", 0,            "define exposure E ra", NAN);
    126     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-sigma_dec", 0,            "define exposure E dec", NAN);
    127     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-ap_resid",  0,            "define aperture residual", NAN);
    128     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-ap_resid_stdev",  0,            "define aperture residual stdev", NAN);
     95    psMetadataAddS64(addprocessedexpArgs, PS_LIST_TAIL, "-fpcam_id", 0,        "define fpcamtool ID (required)", 0);
     96    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-path_base", 0,            "define base output location", NULL);
    12997
    13098    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-zpt_obs", 0,   "define observed zero point", 0);
    … …  
    133101    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-zpt_lq", 0,   "define observed zero point lower quartile", 0);
    134102
    135     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-fwhm_major",  0,            "define fwhm (major axis; arcsec)", NAN);
    136     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-fwhm_major_lq",  0,            "define fwhm (major axis; arcsec)", NAN);
    137     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-fwhm_major_uq",  0,            "define fwhm (major axis; arcsec)", NAN);
    138     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-fwhm_minor",  0,            "define fwhm (minor axis; arcsec)", NAN);
    139     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-fwhm_minor_lq",  0,            "define fwhm (minor axis; arcsec)", NAN);
    140     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-fwhm_minor_uq",  0,            "define fwhm (minor axis; arcsec)", NAN);
    141     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-iq_fwhm_major",     0,  "define moment value m2 mean", NAN);
    142     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-iq_fwhm_major_err",     0,  "define moment value m2 mean", NAN);
    143     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-iq_fwhm_minor",     0,  "define moment value m2 mean", NAN);
    144     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-iq_fwhm_minor_err",     0,  "define moment value m2 mean", NAN);
    145 
    146     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-iq_m2",     0,  "define moment value m2 mean", NAN);
    147     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-iq_m2_err", 0,  "define moment value m2 stdev", NAN);
    148     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-iq_m2_lq",  0,  "define moment value m2 lower quartile", NAN);
    149     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-iq_m2_uq",  0,  "define moment value m2 upper quartile", NAN);
    150     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-iq_m2c",     0,  "define moment value m2c mean", NAN);
    151     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-iq_m2c_err", 0,  "define moment value m2c stdev", NAN);
    152     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-iq_m2c_lq",  0,  "define moment value m2c lower quartile", NAN);
    153     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-iq_m2c_uq",  0,  "define moment value m2c upper quartile", NAN);
    154     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-iq_m2s",     0,  "define moment value m2s mean", NAN);
    155     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-iq_m2s_err", 0,  "define moment value m2s stdev", NAN);
    156     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-iq_m2s_lq",  0,  "define moment value m2s lower quartile", NAN);
    157     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-iq_m2s_uq",  0,  "define moment value m2s upper quartile", NAN);
    158     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-iq_m3",     0,  "define moment value m3 mean", NAN);
    159     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-iq_m3_err", 0,  "define moment value m3 stdev", NAN);
    160     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-iq_m3_lq",  0,  "define moment value m3 lower quartile", NAN);
    161     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-iq_m3_uq",  0,  "define moment value m3 upper quartile", NAN);
    162     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-iq_m4",     0,  "define moment value m4 mean", NAN);
    163     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-iq_m4_err", 0,  "define moment value m4 stdev", NAN);
    164     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-iq_m4_lq",  0,  "define moment value m4 lower quartile", NAN);
    165     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-iq_m4_uq",  0,  "define moment value m4 upper quartile", NAN);
    166 
    167103    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-dtime_script", 0, "define elapsed time in script (seconds)", NAN);
    168     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-dtime_astrom", 0, "define elapsed time for astrometry (seconds)", NAN);
    169     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-dtime_addstar", 0, "define elapsed time for DVO insertion (seconds)", NAN);
    170104    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-hostname", 0,            "define hostname", NULL);
    171105    psMetadataAddS32(addprocessedexpArgs, PS_LIST_TAIL, "-n_stars", 0,            "define number of stars", 0);
    172     psMetadataAddS32(addprocessedexpArgs, PS_LIST_TAIL, "-n_psfstars", 0,            "define number of PSF stars", 0);
    173     psMetadataAddS32(addprocessedexpArgs, PS_LIST_TAIL, "-n_iqstars", 0,            "define number of IQ stars", 0);
    174     psMetadataAddS32(addprocessedexpArgs, PS_LIST_TAIL, "-n_extended", 0,            "define number of extended objects", 0);
    175     psMetadataAddS32(addprocessedexpArgs, PS_LIST_TAIL, "-n_cr", 0,            "define number of cosmic rays", 0);
    176     psMetadataAddS32(addprocessedexpArgs, PS_LIST_TAIL, "-n_astrom", 0,            "define number of astrometry reference objects", 0);
    177 
    178     psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-path_base", 0,            "define base output location", NULL);
     106
    179107    psMetadataAddS16(addprocessedexpArgs, PS_LIST_TAIL, "-fault",  0,            "set fault code", 0);
    180108    psMetadataAddS16(addprocessedexpArgs, PS_LIST_TAIL, "-quality",  0,            "set quality", 0);
    181     psMetadataAddBool(addprocessedexpArgs, PS_LIST_TAIL, "-faulted",  0,            "only return imfiles with a fault status set", false);
    182     psMetadataAddS64(addprocessedexpArgs, PS_LIST_TAIL, "-magicked",   0,         "set magicked", 0);
    183 
    184     psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-ver_pslib", 0, "define psLib version", NULL);
    185     psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-ver_psmodules", 0, "define psModules version", NULL);
    186     psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-ver_psphot", 0, "define psphot version", NULL);
    187     psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-ver_psastro", 0, "define psastro version", NULL);
    188     psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-ver_ppstats", 0, "define ppStats version", NULL);
    189     psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-ver_ppimage", 0, "define ppImage version", NULL);
    190     psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-ver_streaks", 0, "define streaksremove version", NULL);
    191 
    192     psMetadataAddS32(addprocessedexpArgs, PS_LIST_TAIL, "-maskfrac_ref_npix", 0, "define number of pixels used for maskstats", 0);
    193     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-maskfrac_ref_static", 0, "define static mask fraction", NAN);
    194     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-maskfrac_ref_dynamic", 0, "define dynamic mask fraction", NAN);
    195     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-maskfrac_ref_magic", 0, "define magic mask fraction", NAN);
    196     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-maskfrac_ref_advisory", 0, "define advisory mask fraction", NAN);
    197 
    198     psMetadataAddS32(addprocessedexpArgs, PS_LIST_TAIL, "-maskfrac_max_npix", 0, "define number of pixels used for maskstats", 0);
    199     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-maskfrac_max_static", 0, "define static mask fraction", NAN);
    200     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-maskfrac_max_dynamic", 0, "define dynamic mask fraction", NAN);
    201     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-maskfrac_max_magic", 0, "define magic mask fraction", NAN);
    202     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-maskfrac_max_advisory", 0, "define advisory mask fraction", NAN);
    203109
    204110    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-deteff_inst", 0, "define deteff", NAN);
    … …  
    206112    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-deteff_inst_lq", 0, "define deteff_lq", NAN);
    207113    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-deteff_inst_uq", 0, "define deteff_uq", NAN);
    208     psMetadataAddS16(addprocessedexpArgs, PS_LIST_TAIL, "-background_model", 0, "set background_model value", 0);
    209     psMetadataAddS64(addprocessedexpArgs, PS_LIST_TAIL, "-astrom_chips", 0, "chips with successful astrom", 0);
    210 
    211     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-ast_r0", 0,   "define boresite offset in RA", NAN);
    212     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-ast_d0", 0,   "define boresite offset in DEC", NAN);
    213     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-ast_t0", 0,   "define boresite angle", NAN);
    214     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-ast_s0", 0,   "define bosite scale", NAN);
    215     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-ast_rs", 0,   "define bosite scatter in RA", NAN);
    216     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-ast_ds", 0,   "define bosite scatter in DEC", NAN);
     114
     115    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-ver_pslib", 0, "define psLib version", NULL);
     116    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-ver_psmodules", 0, "define psModules version", NULL);
     117    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-ver_psphot", 0, "define psphot version", NULL);
     118    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-ver_ppstats", 0, "define ppStats version", NULL);
     119    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-ver_fpcamera", 0, "define ppImage version", NULL);
    217120
    218121    // -processedexp
    219122    psMetadata *processedexpArgs = psMetadataAlloc();
    220     pxcamSetSearchArgs(processedexpArgs);
    221     psMetadataAddS64(processedexpArgs, PS_LIST_TAIL, "-cam_id",   0,            "search by cam_id", 0);
    222     psMetadataAddStr(processedexpArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by camRun label", NULL);
    223     psMetadataAddStr(processedexpArgs, PS_LIST_TAIL, "-data_group", PS_META_DUPLICATE_OK, "search by camRun data_group (LIKE comparison)", NULL);
    224     psMetadataAddStr(processedexpArgs, PS_LIST_TAIL, "-reduction",0,            "search by camRun reduction class", NULL);
     123    pxfpcamSetSearchArgs(processedexpArgs);
     124    psMetadataAddS64(processedexpArgs, PS_LIST_TAIL, "-fpcam_id",   0,            "search by fpcam_id", 0);
     125    psMetadataAddStr(processedexpArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by fpcamRun label", NULL);
     126    psMetadataAddStr(processedexpArgs, PS_LIST_TAIL, "-data_group", PS_META_DUPLICATE_OK, "search by fpcamRun data_group (LIKE comparison)", NULL);
     127    psMetadataAddStr(processedexpArgs, PS_LIST_TAIL, "-reduction",0,            "search by fpcamRun reduction class", NULL);
    225128    pxspaceAddArguments(processedexpArgs);
    226     pxmagicAddArguments(processedexpArgs);
    227 
    228     psMetadataAddBool(processedexpArgs, PS_LIST_TAIL, "-pstamp_order",  0,      "order the results for the postage stamp server", false);
    229129
    230130    psMetadataAddU64(processedexpArgs, PS_LIST_TAIL, "-limit",    0,            "limit result set to N items", 0);
    231     psMetadataAddBool(processedexpArgs, PS_LIST_TAIL, "-all",     0,            "list everything without restriction", false);
    232131    psMetadataAddBool(processedexpArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    233132    psMetadataAddBool(processedexpArgs, PS_LIST_TAIL, "-faulted", 0,            "only return imfiles with a fault status set", false);
    234     psMetadataAddS16(processedexpArgs, PS_LIST_TAIL, "-background_model", 0, "search by background_model value", 0);
    235133
    236134    // -revertprocessedexp
    237     // XXX need to allow multiple cam_ids
    238     // XXX need to allow multiple chip_ids
    239     // XXX need to allow multiple exp_ids
    240135    psMetadata *revertprocessedexpArgs = psMetadataAlloc();
    241     pxcamSetSearchArgs(revertprocessedexpArgs);
     136    pxfpcamSetSearchArgs(revertprocessedexpArgs);
    242137    psMetadataAddS64(revertprocessedexpArgs, PS_LIST_TAIL, "-cam_id",   0,            "search by cam_id", 0);
    243     psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-label",    PS_META_DUPLICATE_OK, "search by camRun label", NULL);
    244     psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-reduction",0,            "search by camRun reduction class", NULL);
     138    psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-label",    PS_META_DUPLICATE_OK, "search by fpcamRun label", NULL);
     139    psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-reduction",0,            "search by fpcamRun reduction class", NULL);
    245140    psMetadataAddS16(revertprocessedexpArgs, PS_LIST_TAIL, "-code",     0,            "search by fault code", 0);
    246141
    … …  
    249144
    250145    // -updateprocessedexp
    251     // XXX allow full search options?
    252146    psMetadata *updateprocessedexpArgs = psMetadataAlloc();
    253     psMetadataAddS64(updateprocessedexpArgs, PS_LIST_TAIL, "-cam_id", 0,            "search by camtool ID", 0);
    254     psMetadataAddS64(updateprocessedexpArgs, PS_LIST_TAIL, "-chip_id",  0,            "search by chiptool ID", 0);
    255     psMetadataAddStr(updateprocessedexpArgs, PS_LIST_TAIL, "-class",  0,            "search by class", NULL);
    256     psMetadataAddStr(updateprocessedexpArgs, PS_LIST_TAIL, "-class_id",  0,            "search by class ID", NULL);
     147    psMetadataAddS64(updateprocessedexpArgs, PS_LIST_TAIL, "-fpcam_id", 0,            "search by fpcamRun ID", 0);
     148    psMetadataAddS64(updateprocessedexpArgs, PS_LIST_TAIL, "-cam_id", 0,            "search by camRun ID", 0);
     149    psMetadataAddS64(updateprocessedexpArgs, PS_LIST_TAIL, "-chip_id",  0,            "search by chipRun ID", 0);
    257150    psMetadataAddS16(updateprocessedexpArgs, PS_LIST_TAIL, "-fault",  0,            "set fault code (required)", INT16_MAX);
    258151    psMetadataAddS16(updateprocessedexpArgs, PS_LIST_TAIL, "-set_quality",  0,            "set quality", 0);
    259     psMetadataAddS16(updateprocessedexpArgs, PS_LIST_TAIL, "-set_background_model", 0, "set background_model value", 0);
    260152
    261153    // -block
    … …  
    271163    psMetadataAddStr(unblockArgs, PS_LIST_TAIL, "-label",  0,            "name of a label to unmask (required)", NULL);
    272164
    273     // -pendingcleanuprun
    274     // XXX allow full search options?
    275     psMetadata *pendingcleanuprunArgs = psMetadataAlloc();
    276     psMetadataAddStr(pendingcleanuprunArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "list blocks for specified label", NULL);
    277     psMetadataAddBool(pendingcleanuprunArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    278     psMetadataAddU64(pendingcleanuprunArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    279     psMetadataAddBool(pendingcleanuprunArgs, PS_LIST_TAIL, "-all",  0,            "allow everything to be queued without search terms", false);
    280 
    281     // -pendingcleanupexp
    282     // XXX allow full search options?
    283     psMetadata *pendingcleanupexpArgs = psMetadataAlloc();
    284     psMetadataAddStr(pendingcleanupexpArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "list blocks for specified label", NULL);
    285     psMetadataAddS64(pendingcleanupexpArgs, PS_LIST_TAIL, "-cam_id", 0,            "search by camera ID", 0);
    286     psMetadataAddStr(pendingcleanupexpArgs, PS_LIST_TAIL, "-exp_id",                 0,            "search by exp_id", NULL);
    287     psMetadataAddBool(pendingcleanupexpArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    288     psMetadataAddU64(pendingcleanupexpArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    289     psMetadataAddBool(pendingcleanupexpArgs, PS_LIST_TAIL, "-all",  0,            "allow everything to be queued without search terms", false);
    290 
    291     // -donecleanup
    292     psMetadata *donecleanupArgs = psMetadataAlloc();
    293     psMetadataAddStr(donecleanupArgs, PS_LIST_TAIL, "-label",  0,            "list blocks for specified label", NULL);
    294     psMetadataAddBool(donecleanupArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    295     psMetadataAddU64(donecleanupArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    296 
    297     // -exportrun
    298     psMetadata *exportrunArgs = psMetadataAlloc();
    299     psMetadataAddS64(exportrunArgs, PS_LIST_TAIL, "-cam_id", 0,          "export this camera ID (required)", 0);
    300     psMetadataAddStr(exportrunArgs, PS_LIST_TAIL, "-outfile", 0,          "export to this file (required)", NULL);
    301     psMetadataAddU64(exportrunArgs, PS_LIST_TAIL, "-limit",   0,          "limit result set to N items", 0);
    302     psMetadataAddBool(exportrunArgs, PS_LIST_TAIL, "-clean",  0,          "export tables as cleaned", false);
    303 
    304     // -importrun
    305     psMetadata *importrunArgs = psMetadataAlloc();
    306     psMetadataAddStr(importrunArgs, PS_LIST_TAIL, "-infile",  0,          "import from this file (required)", NULL);
    307 
     165    /* cleanup and export stages ignored for now.
     166       see camtool.c & camtoolConfig.c for examples
     167    */
    308168
    309169    psMetadata *argSets = psMetadataAlloc();
    310170    psMetadata *modes = psMetadataAlloc();
    311171
    312     PXOPT_ADD_MODE("-definebyquery",        "create runs from chip stage",          CAMTOOL_MODE_DEFINEBYQUERY, definebyqueryArgs);
    313     PXOPT_ADD_MODE("-updaterun",            "change cam run properties",            CAMTOOL_MODE_UPDATERUN,      updaterunArgs);
    314     PXOPT_ADD_MODE("-pendingexp",           "show pending exposures",               CAMTOOL_MODE_PENDINGEXP,    pendingexpArgs);
    315     PXOPT_ADD_MODE("-pendingimfile",        "show pending imfiles",                 CAMTOOL_MODE_PENDINGIMFILE, pendingimfileArgs);
    316     PXOPT_ADD_MODE("-addprocessedexp",      "add a processed exposure",             CAMTOOL_MODE_ADDPROCESSEDEXP, addprocessedexpArgs);
    317     PXOPT_ADD_MODE("-processedexp",         "show processed exposures",             CAMTOOL_MODE_PROCESSEDEXP,  processedexpArgs);
    318     PXOPT_ADD_MODE("-revertprocessedexp",   "undo a processed exposure",       CAMTOOL_MODE_REVERTPROCESSEDEXP,  revertprocessedexpArgs);
    319     PXOPT_ADD_MODE("-updateprocessedexp",   "changed processed exp properties",            CAMTOOL_MODE_UPDATEPROCESSEDEXP,updateprocessedexpArgs);
    320     PXOPT_ADD_MODE("-block",                "set a label block",                    CAMTOOL_MODE_BLOCK,         blockArgs);
    321     PXOPT_ADD_MODE("-masked",               "show blocked labels",                  CAMTOOL_MODE_MASKED,        maskedArgs);
    322     PXOPT_ADD_MODE("-unblock",              "remove a label block",                 CAMTOOL_MODE_UNBLOCK,       unblockArgs);
    323     PXOPT_ADD_MODE("-pendingcleanuprun",    "show runs that need to be cleaned up", CAMTOOL_MODE_PENDINGCLEANUPRUN, pendingcleanuprunArgs);
    324     PXOPT_ADD_MODE("-pendingcleanupexp",    "show exposures for cleanup runs",      CAMTOOL_MODE_PENDINGCLEANUPEXP, pendingcleanupexpArgs);
    325     PXOPT_ADD_MODE("-donecleanup",          "show runs that have been cleaned",     CAMTOOL_MODE_DONECLEANUP,       donecleanupArgs);
    326    PXOPT_ADD_MODE("-exportrun",            "export run for import on other database", CAMTOOL_MODE_EXPORTRUN, exportrunArgs);
    327     PXOPT_ADD_MODE("-importrun",            "import run from metadata file",           CAMTOOL_MODE_IMPORTRUN, importrunArgs);
     172    PXOPT_ADD_MODE("-definebyquery",        "create runs from chip stage",          FPCAMTOOL_MODE_DEFINEBYQUERY, definebyqueryArgs);
     173    PXOPT_ADD_MODE("-updaterun",            "change cam run properties",            FPCAMTOOL_MODE_UPDATERUN,      updaterunArgs);
     174    PXOPT_ADD_MODE("-pendingexp",           "show pending exposures",               FPCAMTOOL_MODE_PENDINGEXP,    pendingexpArgs);
     175    PXOPT_ADD_MODE("-addprocessedexp",      "add a processed exposure",             FPCAMTOOL_MODE_ADDPROCESSEDEXP, addprocessedexpArgs);
     176    PXOPT_ADD_MODE("-processedexp",         "show processed exposures",             FPCAMTOOL_MODE_PROCESSEDEXP,  processedexpArgs);
     177    PXOPT_ADD_MODE("-revertprocessedexp",   "undo a processed exposure",            FPCAMTOOL_MODE_REVERTPROCESSEDEXP,  revertprocessedexpArgs);
     178    PXOPT_ADD_MODE("-updateprocessedexp",   "changed processed exp properties",     FPCAMTOOL_MODE_UPDATEPROCESSEDEXP,updateprocessedexpArgs);
     179    PXOPT_ADD_MODE("-block",                "set a label block",                    FPCAMTOOL_MODE_BLOCK,         blockArgs);
     180    PXOPT_ADD_MODE("-masked",               "show blocked labels",                  FPCAMTOOL_MODE_MASKED,        maskedArgs);
     181    PXOPT_ADD_MODE("-unblock",              "remove a label block",                 FPCAMTOOL_MODE_UNBLOCK,       unblockArgs);
    328182
    329183    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {
Note: See TracChangeset for help on using the changeset viewer.