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)

File:
1 edited

Legend:

Unmodified
Added
Removed

  • 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 }
Note: See TracChangeset for help on using the changeset viewer.