IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 19325


Ignore:
Timestamp:
Sep 2, 2008, 9:37:06 AM (18 years ago)
Author:
eugene
Message:

substantial work on flatcorr; reworked the sequence somewhat

Location:
trunk/ippTools
Files:
2 added
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/ippTools/share/Makefile.am

    r19249 r19325  
    8888     faketool_revertprocessedimfile.sql \
    8989     faketool_unmasked.sql \
    90      flatcorr_completely_processed_chiprun.sql \
    91      flatcorr_create_tmp_chiprundone.sql \
    92      flatcorr_find_completed_floatcorruns.sql \
    93      flatcorr_find_processedimfiles.sql \
    94      flatcorr_pending.sql \
     90     flatcorr_chiprundone.sql \
     91     flatcorr_pendingprocess.sql \
    9592     magictool_addmask.sql \
    9693     magictool_create_tmp_warpcomplete.sql \

  • trunk/ippTools/share/pxadmin_create_tables.sql

    r19219 r19325  
    976976) ENGINE=innodb DEFAULT CHARSET=latin1;
    977977
    978 CREATE TABLE flatcorrExp (
     978-- XXX deprecate this table
     979-- CREATE TABLE flatcorrExp (
     980--         corr_id BIGINT,
     981--         chip_id BIGINT,
     982--         PRIMARY KEY(corr_id, chip_id),
     983--         FOREIGN KEY (corr_id)  REFERENCES  flatcorrRun(corr_id),
     984--         FOREIGN KEY (chip_id)  REFERENCES  chipRun(chip_id)
     985-- ) ENGINE=innodb DEFAULT CHARSET=latin1;
     986
     987-- these two tables link the flatcorrRun to the associated chip and camera runs
     988CREATE TABLE flatcorrChipLink (
    979989        corr_id BIGINT,
    980990        chip_id BIGINT,
    … …  
    982992        FOREIGN KEY (corr_id)  REFERENCES  flatcorrRun(corr_id),
    983993        FOREIGN KEY (chip_id)  REFERENCES  chipRun(chip_id)
     994) ENGINE=innodb DEFAULT CHARSET=latin1;
     995
     996CREATE TABLE flatcorrCamLink (
     997        corr_id BIGINT,
     998        cam_id BIGINT,
     999        PRIMARY KEY(corr_id, cam_id),
     1000        FOREIGN KEY (corr_id)  REFERENCES  flatcorrRun(corr_id),
     1001        FOREIGN KEY (cam_id)  REFERENCES  camRun(cam_id)
    9841002) ENGINE=innodb DEFAULT CHARSET=latin1;
    9851003

  • trunk/ippTools/src/flatcorr.c

    r18561 r19325  
    33 *
    44 * Copyright (C) 2006-2007  Joshua Hoblitt
     5 * Copyright (C) 2008  Eugene Magnier
    56 *
    67 * This program is free software; you can redistribute it and/or modify it
    … …  
    3132
    3233#include "pxtools.h"
     34#include "pxchip.h"
    3335#include "flatcorr.h"
    3436
    35 static bool newrunMode(pxConfig *config);
    36 static bool addexpMode(pxConfig *config);
    37 static bool pendingMode(pxConfig *config);
    38 static bool flatcorrimfileMode(pxConfig *config);
    39 static bool doneMode(pxConfig *config);
     37static bool definebyqueryMode(pxConfig *config);
     38static bool definerunMode(pxConfig *config);
     39static bool addchipMode(pxConfig *config);
     40static bool addcameraMode(pxConfig *config);
     41static bool pendingprocessMode(pxConfig *config);
     42static bool addprocessMode(pxConfig *config);
    4043static bool updaterunMode(pxConfig *config);
     44static bool inputexpMode(pxConfig *config);
     45static bool inputimfileMode(pxConfig *config);
    4146
    4247static bool setflatcorrRunState(pxConfig *config, psS64 corr_id, const char *state);
    … …  
    6065
    6166    switch (config->mode) {
    62         MODECASE(FLATCORR_MODE_NEWRUN,      newrunMode);
    63         MODECASE(FLATCORR_MODE_ADDEXP,      addexpMode);
    64         MODECASE(FLATCORR_MODE_PENDING,     pendingMode);
    65         MODECASE(FLATCORR_MODE_FLATCORRIMFILE, flatcorrimfileMode);
    66         MODECASE(FLATCORR_MODE_DONE,        doneMode);
    67         MODECASE(FLATCORR_MODE_UPDATERUN,   updaterunMode);
     67        MODECASE(FLATCORR_MODE_DEFINEBYQUERY,  definebyqueryMode);
     68        MODECASE(FLATCORR_MODE_DEFINERUN,      definerunMode);
     69        MODECASE(FLATCORR_MODE_ADDCHIP,        addchipMode);
     70        MODECASE(FLATCORR_MODE_ADDCAMERA,      addcameraMode);
     71        MODECASE(FLATCORR_MODE_PENDINGPROCESS, pendingprocessMode);
     72        MODECASE(FLATCORR_MODE_ADDPROCESS,     addprocessMode);
     73        MODECASE(FLATCORR_MODE_UPDATERUN,      updaterunMode);
     74        MODECASE(FLATCORR_MODE_INPUTEXP,       inputexpMode);
     75        MODECASE(FLATCORR_MODE_INPUTIMFILE,    inputimfileMode);
    6876        default:
    6977            psAbort("invalid option (this should not happen)");
    … …  
    8896
    8997
    90 static bool newrunMode(pxConfig *config)
     98static bool definebyqueryMode(pxConfig *config)
    9199{
    92100    PS_ASSERT_PTR_NON_NULL(config, false);
    93101
    94102    psMetadata *where = psMetadataAlloc();
    95 
    96     PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
    97     PXOPT_COPY_STR(config->args, where, "-exp_name", "exp_name", "==");
    98     PXOPT_COPY_STR(config->args, where, "-inst", "camera", "==");
    99     PXOPT_COPY_STR(config->args, where, "-telescope", "telescope", "==");
    100     PXOPT_COPY_TIME(config->args, where, "-dateobs_begin", "dateobs", ">=");
    101     PXOPT_COPY_TIME(config->args, where, "-dateobs_end", "dateobs", "<=");
    102     PXOPT_COPY_STR(config->args, where, "-exp_tag", "exp_tag", "==");
    103     PXOPT_COPY_STR(config->args, where, "-exp_type", "exp_type", "==");
    104     PXOPT_COPY_STR(config->args, where, "-filelevel", "filelvel", "==");
    105     PXOPT_COPY_STR(config->args, where, "-reduction", "reduction", "==");
    106     PXOPT_COPY_STR(config->args, where, "-filter", "filter", "==");
    107     PXOPT_COPY_F32(config->args, where, "-airmass_min", "airmass", ">=");
    108     PXOPT_COPY_F32(config->args, where, "-airmass_max", "airmass", "<");
    109     PXOPT_COPY_F64(config->args, where, "-ra_min", "ra", ">=");
    110     PXOPT_COPY_F64(config->args, where, "-ra_max", "ra", "<");
    111     PXOPT_COPY_F64(config->args, where, "-decl_min", "decl", ">=");
    112     PXOPT_COPY_F64(config->args, where, "-decl_max", "decl", "<");
    113     PXOPT_COPY_F32(config->args, where, "-exp_time_min", "exp_time", ">=");
    114     PXOPT_COPY_F32(config->args, where, "-exp_time_max", "exp_time", "<");
    115     PXOPT_COPY_F32(config->args, where, "-sat_pixel_frac_min", "sat_pixel_frac", ">=");
    116     PXOPT_COPY_F32(config->args, where, "-sat_pixel_frac_max", "sat_pixel_frac", "<");
    117     PXOPT_COPY_F64(config->args, where, "-bg_min", "bt", ">=");
    118     PXOPT_COPY_F64(config->args, where, "-bg_max", "bt", "<");
    119     PXOPT_COPY_F64(config->args, where, "-bg_stdev_min", "bg_stdev", ">=");
    120     PXOPT_COPY_F64(config->args, where, "-bg_stdev_max", "bg_stdev", "<");
    121     PXOPT_COPY_F64(config->args, where, "-bg_mean_stdev_min", "bg_mean_stdev", ">=");
    122     PXOPT_COPY_F64(config->args, where, "-bg_mean_stdev_max", "bg_mean_stdev", "<");
    123     PXOPT_COPY_F64(config->args, where, "-alt_min", "alt", ">=");
    124     PXOPT_COPY_F64(config->args, where, "-alt_max", "alt", "<");
    125     PXOPT_COPY_F64(config->args, where, "-az_min", "az", ">=");
    126     PXOPT_COPY_F64(config->args, where, "-az_max", "az", "<");
    127     PXOPT_COPY_F32(config->args, where, "-ccd_temp_min", "ccd_temp", ">=");
    128     PXOPT_COPY_F32(config->args, where, "-ccd_temp_max", "ccd_temp", "<");
    129     PXOPT_COPY_F64(config->args, where, "-posang_min", "posang", ">=");
    130     PXOPT_COPY_F64(config->args, where, "-posang_max", "posang", "<");
    131     PXOPT_COPY_STR(config->args, where, "-object", "object", "==");
    132     PXOPT_COPY_F32(config->args, where, "-solang_min", "solang", ">=");
    133     PXOPT_COPY_F32(config->args, where, "-solang_max", "solang", "<");
    134 
    135     if (where->list->n < 1) {
     103    pxchipGetSearchArgs (config, where);
     104
     105    if (!psListLength(where->list)) {
    136106        psFree(where);
    137107        psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
    … …  
    146116    PXOPT_LOOKUP_STR(filter, config->args, "-set_filter", false, false);
    147117    PXOPT_LOOKUP_STR(tess_id, config->args, "-set_tess_id", false, false);
    148     PXOPT_LOOKUP_STR(end_stage, config->args, "-set_end_stage", false, false);
    149118    PXOPT_LOOKUP_STR(region, config->args, "-set_region", false, false);
     119    // XXX probably should make the region in -set_region match ra_min, ra_max, etc
    150120
    151121    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
    … …  
    156126    if (!query) {
    157127        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    158         return false;
    159     }
    160 
    161     if (where) {
     128        psFree(where);
     129        return false;
     130    }
     131
     132    if (where && psListLength(where->list)) {
    162133        psString whereClause = psDBGenerateWhereConditionSQL(where, "rawExp");
    163         psFree(where);
    164134        psStringAppend(&query, " AND %s", whereClause);
    165135        psFree(whereClause);
    166136    }
     137    psFree(where);
    167138
    168139    if (!p_psDBRunQuery(config->dbh, query)) {
    … …  
    179150    }
    180151    if (!psArrayLength(output)) {
    181         psTrace("chiptool", PS_LOG_INFO, "no rows found");
     152        psTrace("flatcorr", PS_LOG_INFO, "no rows found");
    182153        psFree(output);
    183154        return true;
    … …  
    185156
    186157    if (pretend) {
    187         // negative simple so the default is true
    188     for (int i = 0; i < output->n; i++) {
    189         psMetadata *md = output->data[i];
    190         psMetadataConfigPrint (stdout, md);
    191     }
    192 //        if (!rawExpPrintObjects(stdout, output, !simple)) {
    193 //            psError(PS_ERR_UNKNOWN, false, "failed to print array");
    194 //            psFree(output);
    195 //            return false;
    196 //        }
     158        for (long i = 0; i < psArrayLength(output); i++) {
     159            // negative simple so the default is true
     160            if (!ippdbPrintMetadataRaw(stdout, output->data[i], !simple)) {
     161                psError(PS_ERR_UNKNOWN, false, "failed to print array");
     162                psFree(output);
     163                return false;
     164            }
     165        }
    197166        psFree(output);
    198167        return true;
    … …  
    216185            label,
    217186            NULL,   // stats
     187            reduction,
    218188            region
    219189        )) {
    … …  
    243213        }
    244214
    245         // queue the exp
    246         psS64 chip_id = pxchipQueueByExpTag(config, exp_id, workdir, label, reduction, expgroup, dvodb, tess_id, end_stage);
     215        // queue the exp : force this to stop at the chip stage
     216        psS64 chip_id = pxchipQueueByExpTag(config, exp_id, workdir, label, reduction, expgroup, dvodb, tess_id, "chip");
    247217        if (!chip_id) {
    248218            if (!psDBRollback(config->dbh)) {
    … …  
    255225        }
    256226
    257         // add a flatcorrExp to the flatcorr Run we just created
    258         if (!flatcorrExpInsert(config->dbh,
    259                 corr_id,
    260                 chip_id
    261             )) {
     227        // add a flatcorrChipLink to the flatcorr Run we just created
     228        if (!flatcorrChipLinkInsert(config->dbh, corr_id, chip_id)) {
    262229            if (!psDBRollback(config->dbh)) {
    263230                psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    270237    psFree(output);
    271238
    272     // set the flatcorrRun to a state of 'run'
    273     if (!setflatcorrRunState(config, corr_id, "run")) {
     239    // set the flatcorrRun to a state of 'new'
     240    if (!setflatcorrRunState(config, corr_id, "new")) {
    274241        if (!psDBRollback(config->dbh)) {
    275242            psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    287254}
    288255
    289 
    290 static bool addexpMode(pxConfig *config)
     256static bool definerunMode(pxConfig *config)
     257{
     258    PS_ASSERT_PTR_NON_NULL(config, false);
     259
     260    PXOPT_LOOKUP_STR(workdir, config->args, "-set_workdir", false, false);
     261    PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
     262    PXOPT_LOOKUP_STR(reduction, config->args, "-set_reduction", false, false);
     263    PXOPT_LOOKUP_STR(expgroup, config->args, "-set_expgroup", false, false);
     264    PXOPT_LOOKUP_STR(dvodb, config->args, "-set_dvodb", false, false);
     265    PXOPT_LOOKUP_STR(filter, config->args, "-set_filter", false, false);
     266    PXOPT_LOOKUP_STR(tess_id, config->args, "-set_tess_id", false, false);
     267    PXOPT_LOOKUP_STR(region, config->args, "-set_region", false, false);
     268    // XXX probably should make the region in -set_region match ra_min, ra_max, etc
     269
     270    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     271
     272    // start a transaction so we don't end up with an exp without any associted
     273    // imfiles
     274    if (!psDBTransaction(config->dbh)) {
     275        psError(PS_ERR_UNKNOWN, false, "database error");
     276        return false;
     277    }
     278
     279    // create a new flatcorrRun
     280    flatcorrRunRow *row = flatcorrRunRowAlloc(
     281        0,      // corr_id
     282        dvodb,
     283        filter,
     284        "reg",  // state
     285        workdir,
     286        label,
     287        NULL,   // stats
     288        reduction,
     289        region
     290        );
     291
     292    // create a new flatcorrRun
     293    if (!flatcorrRunInsertObject(config->dbh,row)) {
     294        if (!psDBRollback(config->dbh)) {
     295            psError(PS_ERR_UNKNOWN, false, "database error");
     296        }
     297        psError(PS_ERR_UNKNOWN, false, "database error");
     298        return false;
     299    }
     300   
     301    // figure out the ID of the flatcorrRun we just created
     302    psS64 corr_id = psDBLastInsertID(config->dbh);
     303    row->corr_id = corr_id;
     304
     305    flatcorrRunPrintObject (stdout, row, !simple);
     306    return true;
     307}
     308
     309static bool addchipMode(pxConfig *config)
    291310{
    292311    PS_ASSERT_PTR_NON_NULL(config, false);
    293312
    294313    // required
    295     PXOPT_LOOKUP_STR(corr_id, config->args, "-corr_id", true, false);
    296     PXOPT_LOOKUP_STR(chip_id, config->args, "-chip_id", true, false);
    297 
    298     if (!flatcorrExpInsert(config->dbh,
    299             (psS64)atoll(corr_id),
    300             (psS64)atoll(chip_id)
    301         )) {
    302         psError(PS_ERR_UNKNOWN, false, "database error");
    303         return false;
    304     }
    305 
    306     return true;
    307 }
    308 
    309 
    310 static bool pendingMode(pxConfig *config)
    311 {
    312     PS_ASSERT_PTR_NON_NULL(config, false);
    313 
    314     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    315     PXOPT_LOOKUP_BOOL(limit, config->args, "-limit", false);
    316 
    317     // create a temp table to hold completely processed chipRuns
    318     {
    319         psString query = pxDataGet("flatcorr_create_tmp_chiprundone.sql");
    320         if (!query) {
    321             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    322             return false;
    323         }
    324 
    325         if (!p_psDBRunQuery(config->dbh, query)) {
    326             psError(PS_ERR_UNKNOWN, false, "database error");
    327             psFree(query);
    328             return false;
    329         }
    330 
    331         psFree(query);
    332     }
    333    
    334     // find all completed chipRuns
    335     {
    336         psString query = pxDataGet("flatcorr_completely_processed_chiprun.sql");
    337         if (!query) {
    338             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    339             return false;
    340         }
    341 
    342         if (!p_psDBRunQuery(config->dbh, query)) {
    343             psError(PS_ERR_UNKNOWN, false, "database error");
    344             psFree(query);
    345             return false;
    346         }
    347 
    348         psFree(query);
    349     }
    350 
    351     // find flatcorrRun's that have had all of their chipRun's completed by
    352     // comparing against the temp table
    353     psString query = pxDataGet("flatcorr_find_completed_floatcorruns.sql");
     314    PXOPT_LOOKUP_S64(corr_id, config->args, "-corr_id", true, false);
     315    PXOPT_LOOKUP_S64(chip_id, config->args, "-chip_id", true, false);
     316
     317    if (!flatcorrChipLinkInsert(config->dbh, corr_id, chip_id)) {
     318        psError(PS_ERR_UNKNOWN, false, "database error");
     319        return false;
     320    }
     321
     322    return true;
     323}
     324
     325// select the flatcorr chip runs that have completed and for which there is no camera entry
     326// queue a new camera run for them
     327static bool addcameraMode(pxConfig *config)
     328{
     329    PS_ASSERT_PTR_NON_NULL(config, false);
     330
     331    PXOPT_LOOKUP_BOOL(simple,  config->args, "-simple",  false);
     332    PXOPT_LOOKUP_BOOL(limit,   config->args, "-limit",   false);
     333    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
     334
     335    psString query = pxDataGet("flatcorr_chiprundone.sql");
    354336    if (!query) {
    355         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    356         return false;
     337        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     338        return false;
    357339    }
    358340
    … …  
    372354    psArray *output = p_psDBFetchResult(config->dbh);
    373355    if (!output) {
    374         psErrorCode err = psErrorCodeLast();
    375         switch (err) {
    376           case PS_ERR_DB_CLIENT:
    377             psError(PXTOOLS_ERR_SYS, false, "database error");
    378           case PS_ERR_DB_SERVER:
    379             psError(PXTOOLS_ERR_PROG, false, "database error");
    380           default:
    381             psError(PXTOOLS_ERR_PROG, false, "unknown error");
    382         }
    383 
     356        psError(PS_ERR_UNKNOWN, false, "database error");
    384357        return false;
    385358    }
    386359    if (!psArrayLength(output)) {
    387         psTrace("regtool", PS_LOG_INFO, "no rows found");
     360        psTrace("flatcorr", PS_LOG_INFO, "no rows found");
    388361        psFree(output);
    389362        return true;
    390363    }
    391364
    392     if (psArrayLength(output)) {
     365    if (pretend) {
    393366        // negative simple so the default is true
    394         if (!ippdbPrintMetadatas(stdout, output, "flatcorrPending", !simple)) {
     367        if (!ippdbPrintMetadatas(stdout, output, "flatcorr_addcamera", !simple)) {
    395368            psError(PS_ERR_UNKNOWN, false, "failed to print array");
    396369            psFree(output);
    … …  
    399372    }
    400373
     374    // start a transaction so we don't end up with an exp without any associted
     375    // imfiles
     376    if (!psDBTransaction(config->dbh)) {
     377        psError(PS_ERR_UNKNOWN, false, "database error");
     378        psFree(output);
     379        return false;
     380    }
     381
     382    // loop over our list of chipRun rows
     383    for (long i = 0; i < psArrayLength(output); i++) {
     384        psMetadata *md = output->data[i];
     385
     386        bool status;
     387        psS64 corr_id = psMetadataLookupS64(&status, md, "corr_id");
     388        if (!status) {
     389            if (!psDBRollback(config->dbh)) {
     390                psError(PS_ERR_UNKNOWN, false, "database error");
     391            }
     392            psError(PS_ERR_UNKNOWN, false, "failed to lookup value for corr_id");
     393            psFree(output);
     394            return false;
     395        }
     396
     397        chipRunRow *row = chipRunObjectFromMetadata(md);
     398        if (!row) {
     399            psError(PS_ERR_UNKNOWN, false, "failed to convert metadata into chipRun");
     400            psFree(output);
     401            return false;
     402        }
     403
     404        // queue the exp
     405        if (!pxcamQueueByChipID(
     406                config,
     407                row->chip_id,
     408                row->workdir,
     409                row->label,
     410                row->reduction,
     411                row->expgroup,
     412                row->dvodb,
     413                row->tess_id,
     414                "camera")) {
     415            if (!psDBRollback(config->dbh)) {
     416                psError(PS_ERR_UNKNOWN, false, "database error");
     417            }
     418            psError(PS_ERR_UNKNOWN, false,
     419                    "failed to trying to queue chip_id: %" PRId64, row->chip_id);
     420            psFree(row);
     421            psFree(output);
     422            return false;
     423        }
     424
     425        // figure out the ID of the flatcorrRun we just created
     426        psS64 cam_id = psDBLastInsertID(config->dbh);
     427
     428        // add the camRun entry to the flatcorrCamLink table:
     429        if (!flatcorrCamLinkInsert(config->dbh, corr_id, row->chip_id, cam_id)) {
     430            if (!psDBRollback(config->dbh)) {
     431                psError(PS_ERR_UNKNOWN, false, "database error");
     432            }
     433            psError(PS_ERR_UNKNOWN, false, "database error");
     434            return false;
     435        }
     436       
     437        psFree(row);
     438    }
    401439    psFree(output);
    402440
     441    if (!psDBCommit(config->dbh)) {
     442        psError(PS_ERR_UNKNOWN, false, "database error");
     443        return false;
     444    }
     445
    403446    return false;
    404447}
    405448
    406 
    407 static bool flatcorrimfileMode(pxConfig *config)
    408 {
    409     PS_ASSERT_PTR_NON_NULL(config, false);
    410 
    411     psMetadata *where = psMetadataAlloc();
    412     PXOPT_COPY_S64(config->args, where, "-corr_id", "corr_id", "==");
    413 
    414     PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    415     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    416 
    417     // find all rawImfiles matching the default query
    418     psString query = pxDataGet("flatcorr_find_processedimfiles.sql");
     449// select the flatcorr chip runs that have completed and for which there is no camera entry
     450// queue a new camera run for them
     451static bool pendingprocessMode(pxConfig *config)
     452{
     453    PS_ASSERT_PTR_NON_NULL(config, false);
     454
     455    PXOPT_LOOKUP_BOOL(simple,  config->args, "-simple",  false);
     456    PXOPT_LOOKUP_BOOL(limit,   config->args, "-limit",   false);
     457
     458    psString query = pxDataGet("flatcorr_pendingprocess.sql");
    419459    if (!query) {
    420         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    421         return false;
    422     }
    423 
    424     if (psListLength(where->list)) {
    425         psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    426         psStringAppend(&query, " AND %s", whereClause);
    427         psFree(whereClause);
    428     }
    429     psFree(where);
     460        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     461        return false;
     462    }
    430463
    431464    // treat limit == 0 as "no limit"
    432465    if (limit) {
    433         psString limitString = psDBGenerateLimitSQL(limit);
    434         psStringAppend(&query, " %s", limitString);
    435         psFree(limitString);
     466        psString limitString = psDBGenerateLimitSQL(limit);
     467        psStringAppend(&query, " %s", limitString);
     468        psFree(limitString);
    436469    }
    437470
    … …  
    441474        return false;
    442475    }
    443     psFree(query);
    444    
     476
    445477    psArray *output = p_psDBFetchResult(config->dbh);
    446478    if (!output) {
    447         psErrorCode err = psErrorCodeLast();
    448         switch (err) {
    449             case PS_ERR_DB_CLIENT:
    450                 psError(PXTOOLS_ERR_SYS, false, "database error");
    451             case PS_ERR_DB_SERVER:
    452                 psError(PXTOOLS_ERR_PROG, false, "database error");
    453             default:
    454                 psError(PXTOOLS_ERR_PROG, false, "unknown error");
    455         }
    456    
     479        psError(PS_ERR_UNKNOWN, false, "database error");
    457480        return false;
    458481    }
    459482    if (!psArrayLength(output)) {
    460         psTrace("warptool", PS_LOG_INFO, "no rows found");
    461         psFree(output);
    462         return true;
    463     }
    464 
    465     if (psArrayLength(output)) {
    466         // negative simple so the default is true
    467         if (!ippdbPrintMetadatas(stdout, output, "chipProcessedImfile", !simple)) {
    468             psError(PS_ERR_UNKNOWN, false, "failed to print array");
    469             psFree(output);
    470             return false;
    471         }
    472     }
    473 
    474     psFree(output);
    475 
    476     return true;
    477 }
    478 
    479 
    480 static bool doneMode(pxConfig *config)
    481 {
    482     PS_ASSERT_PTR_NON_NULL(config, false);
    483 
    484     PXOPT_LOOKUP_STR(corr_id, config->args, "-corr_id", true, false);
    485     PXOPT_LOOKUP_STR(stats, config->args, "-stats", true, false);
    486 
    487     if (!psDBTransaction(config->dbh)) {
    488         psError(PS_ERR_UNKNOWN, false, "database error");
    489         return false;
    490     }
    491 
    492     if (!setflatcorrRunState(config, (psS64)atoll(corr_id), "stop")) {
     483        psTrace("flatcorr", PS_LOG_INFO, "no rows found");
     484        psFree(output);
     485        return true;
     486    }
     487
     488    if (!ippdbPrintMetadatas(stdout, output, "flatcorrPending", !simple)) {
     489        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     490        psFree(output);
     491        return false;
     492    }
     493
     494    return true;
     495}
     496
     497// select the flatcorr chip runs that have completed and for which there is no camera entry
     498// queue a new camera run for them
     499static bool inputexpMode(pxConfig *config)
     500{
     501    PS_ASSERT_PTR_NON_NULL(config, false);
     502
     503    PXOPT_LOOKUP_S64(corr_id, config->args, "-corr_id", true, false);
     504    PXOPT_LOOKUP_BOOL(simple,  config->args, "-simple",  false);
     505    PXOPT_LOOKUP_BOOL(limit,   config->args, "-limit",   false);
     506
     507    char *query = psStringCopy ("SELECT * FROM flatcorrChipLink WHERE corr_id = %" PRId64);
     508
     509    // treat limit == 0 as "no limit"
     510    if (limit) {
     511        psString limitString = psDBGenerateLimitSQL(limit);
     512        psStringAppend(&query, " %s", limitString);
     513        psFree(limitString);
     514    }
     515
     516    if (!p_psDBRunQuery(config->dbh, query, corr_id)) {
     517        psError(PS_ERR_UNKNOWN, false, "database error");
     518        psFree(query);
     519        return false;
     520    }
     521
     522    psArray *output = p_psDBFetchResult(config->dbh);
     523    if (!output) {
     524        psError(PS_ERR_UNKNOWN, false, "database error");
     525        return false;
     526    }
     527    if (!psArrayLength(output)) {
     528        psTrace("flatcorr", PS_LOG_INFO, "no rows found");
     529        psFree(output);
     530        return true;
     531    }
     532
     533    if (!ippdbPrintMetadatas(stdout, output, "flatcorrPending", !simple)) {
     534        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     535        psFree(output);
     536        return false;
     537    }
     538
     539    return true;
     540}
     541
     542// select the flatcorr chip runs that have completed and for which there is no camera entry
     543// queue a new camera run for them
     544static bool inputimfileMode(pxConfig *config)
     545{
     546    PS_ASSERT_PTR_NON_NULL(config, false);
     547
     548    PXOPT_LOOKUP_S64(chip_id, config->args, "-chip_id", true, false);
     549    PXOPT_LOOKUP_BOOL(simple,  config->args, "-simple",  false);
     550    PXOPT_LOOKUP_BOOL(limit,   config->args, "-limit",   false);
     551
     552    char *query = psStringCopy ("SELECT * FROM chipProcessedImfile WHERE chip_id = %" PRId64);
     553
     554    // treat limit == 0 as "no limit"
     555    if (limit) {
     556        psString limitString = psDBGenerateLimitSQL(limit);
     557        psStringAppend(&query, " %s", limitString);
     558        psFree(limitString);
     559    }
     560
     561    if (!p_psDBRunQuery(config->dbh, query, chip_id)) {
     562        psError(PS_ERR_UNKNOWN, false, "database error");
     563        psFree(query);
     564        return false;
     565    }
     566
     567    psArray *output = p_psDBFetchResult(config->dbh);
     568    if (!output) {
     569        psError(PS_ERR_UNKNOWN, false, "database error");
     570        return false;
     571    }
     572    if (!psArrayLength(output)) {
     573        psTrace("flatcorr", PS_LOG_INFO, "no rows found");
     574        psFree(output);
     575        return true;
     576    }
     577
     578    if (!ippdbPrintMetadatas(stdout, output, "flatcorrPending", !simple)) {
     579        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     580        psFree(output);
     581        return false;
     582    }
     583
     584    return true;
     585}
     586
     587// XXX need a fault state
     588static bool addprocessMode(pxConfig *config)
     589{
     590    PS_ASSERT_PTR_NON_NULL(config, false);
     591
     592    PXOPT_LOOKUP_S64(corr_id, config->args, "-corr_id", true, false);
     593
     594    if (!setflatcorrRunState(config, corr_id, "full")) {
    493595        if (!psDBRollback(config->dbh)) {
    494596            psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    498600    }
    499601
    500     char *query = "UPDATE flatcorrRun SET stats = '%s' WHERE corr_id = %" PRId64;
    501     if (!p_psDBRunQuery(config->dbh, query, stats, (psS64)atoll(corr_id))) {
    502         psError(PS_ERR_UNKNOWN, false,
    503                 "failed to change state for corr_id %" PRId64, (psS64)atoll(corr_id));
    504         return false;
    505     }
    506 
    507     if (!psDBCommit(config->dbh)) {
    508         psError(PS_ERR_UNKNOWN, false, "database error");
    509         return false;
    510     }
    511 
    512     return false;
    513 }
    514 
     602    return true;
     603}
     604
     605static bool updaterunMode(pxConfig *config)
     606{
     607    PS_ASSERT_PTR_NON_NULL(config, false);
     608
     609    PXOPT_LOOKUP_S64(corr_id, config->args, "-corr_id", true, false);
     610    PXOPT_LOOKUP_STR(state, config->args, "-state", true, false);
     611
     612    if (!setflatcorrRunState(config, corr_id, state)) {
     613        if (!psDBRollback(config->dbh)) {
     614            psError(PS_ERR_UNKNOWN, false, "database error");
     615        }
     616        psError(PS_ERR_UNKNOWN, false, "failed to set run state");
     617        return false;
     618    }
     619
     620    return true;
     621}
    515622
    516623static bool setflatcorrRunState(pxConfig *config, psS64 corr_id, const char *state)
    … …  
    520627
    521628    // check that state is a valid string value
    522     if (!(
    523             (strncmp(state, "run", 4) == 0)
    524             || (strncmp(state, "stop", 5) == 0)
    525             || (strncmp(state, "reg", 4) == 0)
    526         )
    527     ) {
     629    if (!strcmp(state, "reg") &&
     630        !strcmp(state, "new") &&
     631        !strcmp(state, "full"))
     632    {
    528633        psError(PS_ERR_UNKNOWN, false, "invalid state: %s", state);
    529634        return false;
    … …  
    541646
    542647
    543 static bool updaterunMode(pxConfig *config)
    544 {
    545     PS_ASSERT_PTR_NON_NULL(config, false);
    546 
    547     PXOPT_LOOKUP_STR(corr_id, config->args, "-corr_id", true, false);
    548     PXOPT_LOOKUP_STR(state, config->args, "-state", true, false);
    549 
    550     if (state) {
    551         // set detRun.state to state
    552         return setflatcorrRunState(config, (psS64)atoll(corr_id), state);
    553     }
    554 
    555     return true;
    556 }

  • trunk/ippTools/src/flatcorr.h

    r16662 r19325  
    2525typedef enum {
    2626    FLATCORR_MODE_NONE           = PXTOOL_MODE_NONE,
    27     FLATCORR_MODE_NEWRUN,
    28     FLATCORR_MODE_ADDEXP,
    29     FLATCORR_MODE_PENDING,
    30     FLATCORR_MODE_FLATCORRIMFILE,
    31     FLATCORR_MODE_DONE,
    32     FLATCORR_MODE_UPDATERUN
     27    FLATCORR_MODE_DEFINEBYQUERY,
     28    FLATCORR_MODE_DEFINERUN,
     29    FLATCORR_MODE_ADDCHIP,
     30    FLATCORR_MODE_ADDCAMERA,
     31    FLATCORR_MODE_PENDINGPROCESS,
     32    FLATCORR_MODE_ADDPROCESS,
     33    FLATCORR_MODE_UPDATERUN,
     34    FLATCORR_MODE_INPUTEXP,
     35    FLATCORR_MODE_INPUTIMFILE
    3336} flatcorrMode;
    3437

  • trunk/ippTools/src/flatcorrConfig.c

    r18561 r19325  
    4545    psTime *now = psTimeGetNow(PS_TIME_TAI);
    4646
    47     // -newrun
    48     psMetadata *newrunArgs = psMetadataAlloc();
     47    // -definebyquery
     48    psMetadata *definebyqueryArgs = psMetadataAlloc();
    4949    // XXX need to allow multiple exp_ids
    50     psMetadataAddS64(newrunArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exp_id", 0);
    51     psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-exp_name",  0,            "search by exp_name", NULL);
    52     psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-inst",  0,            "search for camera", NULL);
    53     psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-telescope",  0,            "search for telescope", NULL);
    54     psMetadataAddTime(newrunArgs, PS_LIST_TAIL, "-dateobs_begin", 0,               "search for exposures by time (>=)", NULL);
    55     psMetadataAddTime(newrunArgs, PS_LIST_TAIL, "-dateobs_end", 0,            "search for exposures by time (<)", NULL);
    56     psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-exp_tag",  0,            "search by exp_tag", NULL);
    57     psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-exp_type",  0,            "search by exp_type", "object");
    58     psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-filelevel",  0,            "search by filelevel", NULL);
    59     psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-reduction",  0,            "search by reduction class", NULL);
    60     psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-filter",  0,            "search for filter", NULL);
    61     psMetadataAddF32(newrunArgs, PS_LIST_TAIL, "-airmass_min",  0,            "define min airmass", NAN);
    62     psMetadataAddF32(newrunArgs, PS_LIST_TAIL, "-airmass_max",  0,            "define max airmass", NAN);
    63     psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-ra_min",  0,            "define min", NAN);
    64     psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-ra_max",  0,            "define max", NAN);
    65     psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-decl_min",  0,            "define min", NAN);
    66     psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-decl_max",  0,            "define max", NAN);
    67     psMetadataAddF32(newrunArgs, PS_LIST_TAIL, "-exp_time_min",  0,            "define min", NAN);
    68     psMetadataAddF32(newrunArgs, PS_LIST_TAIL, "-exp_time_max",  0,            "define max", NAN);
    69     psMetadataAddF32(newrunArgs, PS_LIST_TAIL, "-sat_pixel_frac_min",  0,            "define max fraction of saturated pixels", NAN);
    70     psMetadataAddF32(newrunArgs, PS_LIST_TAIL, "-sat_pixel_frac_max",  0,            "define min fraction of saturated pixels", NAN);
    71     psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-bg_min",  0,            "define max", NAN);
    72     psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-bg_max",  0,            "define max", NAN);
    73     psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-bg_stdev_min",  0,            "define max", NAN);
    74     psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-bg_stdev_max",  0,            "define max", NAN);
    75     psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-bg_mean_stdev_min",  0,            "define max", NAN);
    76     psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-bg_mean_stdev_max",  0,            "define max", NAN);
    77     psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-alt_min",  0,            "define min", NAN);
    78     psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-alt_max",  0,            "define max", NAN);
    79     psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-az_min",  0,            "define min", NAN);
    80     psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-az_max",  0,            "define max", NAN);
    81     psMetadataAddF32(newrunArgs, PS_LIST_TAIL, "-ccd_temp_min",  0,               "define min ccd tempature", NAN);
    82     psMetadataAddF32(newrunArgs, PS_LIST_TAIL, "-ccd_temp_max",  0,            "define max ccd tempature", NAN);
    83     psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-posang_min",  0,            "define min rotator position angle", NAN);
    84     psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-posang_max",  0,            "define max rotator position angle", NAN);
    85     psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-object",  0,            "search by exposure object", NULL);
    86     psMetadataAddF32(newrunArgs, PS_LIST_TAIL, "-solang_min",  0,            "define min solar angle", NAN);
    87     psMetadataAddF32(newrunArgs, PS_LIST_TAIL, "-solang_max",  0,            "define max solar angle", NAN);
     50    pxchipSetSearchArgs (definebyqueryArgs);
    8851
    89     psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-set_workdir",  0,            "define workdir", NULL);
    90     psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-set_label",  0,            "define label", NULL);
    91     psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-set_reduction",  0,            "define reduction class", NULL);
    92     psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-set_expgroup",  0,            "define exposure group", NULL);
    93     psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-set_dvodb",  0,            "define DVO db", NULL);
    94     psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-set_filter",  0,            "define filter", NULL);
    95     psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-set_tess_id",  0,            "define tessalation", NULL);
    96     psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-set_end_stage",  0,            "define processing end stage", NULL);
    97     psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-set_region",  0,            "define region", NULL);
     52    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_workdir",  0,            "define workdir", NULL);
     53    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_label",    0,            "define label", NULL);
     54    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_reduction",0,            "define reduction class", NULL);
     55    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_expgroup", 0,            "define exposure group", NULL);
     56    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_dvodb",    0,            "define DVO db", NULL);
     57    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_filter",   0,            "define filter", NULL);
     58    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_tess_id",  0,            "define tessalation", NULL);
     59    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_region",   0,            "define region", NULL);
    9860
    99     psMetadataAddBool(newrunArgs, PS_LIST_TAIL, "-pretend",  0,            "print the exposures that would be included in the detrend run and exit", false);
    100     psMetadataAddBool(newrunArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
     61    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-pretend",  0,            "print the exposures that would be included in the detrend run and exit", false);
     62    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
    10163
    102     // -addexp
    103     psMetadata *addexpArgs = psMetadataAlloc();
    104     psMetadataAddStr(addexpArgs, PS_LIST_TAIL, "-corr_id", 0,            "define Flat Correction ID (required)", NULL);
    105     psMetadataAddStr(addexpArgs, PS_LIST_TAIL, "-chip_id", 0,            "define Chip ID (required)", NULL);
     64    // -definerun
     65    psMetadata *definerunArgs = psMetadataAlloc();
     66    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_workdir",  0,            "define workdir", NULL);
     67    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_label",  0,            "define label", NULL);
     68    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_reduction",  0,            "define reduction class", NULL);
     69    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_expgroup",  0,            "define exposure group", NULL);
     70    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_dvodb",  0,            "define DVO db", NULL);
     71    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_filter",  0,            "define filter", NULL);
     72    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_tess_id",  0,            "define tessalation", NULL);
     73    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_region",  0,            "define region", NULL);
     74    psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
    10675
    107     // -pending
    108     psMetadata *pendingArgs = psMetadataAlloc();
    109     psMetadataAddU64(pendingArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    110     psMetadataAddBool(pendingArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
     76    // -addchip
     77    psMetadata *addchipArgs = psMetadataAlloc();
     78    psMetadataAddS64(addchipArgs, PS_LIST_TAIL, "-corr_id", 0,            "define Flat Correction ID (required)", 0);
     79    psMetadataAddS64(addchipArgs, PS_LIST_TAIL, "-chip_id", 0,            "define Chip ID (required)", 0);
    11180
    112     // -flatcorrimfile
    113     psMetadata *flatcorrimfileArgs = psMetadataAlloc();
    114     psMetadataAddStr(flatcorrimfileArgs, PS_LIST_TAIL, "-corr_id",  0,            "search by flat correction ID (required)", NULL);
    115     psMetadataAddU64(flatcorrimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    116     psMetadataAddBool(flatcorrimfileArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
     81    // -addcamera
     82    psMetadata *addcameraArgs = psMetadataAlloc();
     83    psMetadataAddU64 (addcameraArgs, PS_LIST_TAIL, "-limit",   0, "limit result set to N items", 0);
     84    psMetadataAddBool(addcameraArgs, PS_LIST_TAIL, "-simple",  0, "use the simple output format", false);
     85    psMetadataAddBool(addcameraArgs, PS_LIST_TAIL, "-pretend", 0, "use the simple output format", false);
    11786
    118     // -done
    119     psMetadata *doneArgs = psMetadataAlloc();
    120     psMetadataAddStr(doneArgs, PS_LIST_TAIL, "-corr_id",  0,            "define correction id (required)", NULL);
    121     psMetadataAddStr(doneArgs, PS_LIST_TAIL, "-stats",  0,            "define stats (required)", NULL);
     87    // -pendingprocess
     88    psMetadata *pendingprocessArgs = psMetadataAlloc();
     89    psMetadataAddU64 (pendingprocessArgs, PS_LIST_TAIL, "-limit",  0, "limit result set to N items", 0);
     90    psMetadataAddBool(pendingprocessArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
     91
     92    // -addprocess (XXX need to add fault and stats)
     93    psMetadata *addprocessArgs = psMetadataAlloc();
     94    psMetadataAddS64 (addprocessArgs, PS_LIST_TAIL, "-corr_id", 0, "add complete run for specified corr_id (required)", 0);
    12295
    12396    // -updaterun
    12497    psMetadata *updaterunArgs = psMetadataAlloc();
    125     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-corr_id",  0,            "define correction id (required)", NULL);
    126     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,            "set state (required)", NULL);
     98    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-corr_id", 0, "define correction id (required)", 0);
     99    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state",   0, "set state (required)", NULL);
     100
     101    // -inputexp
     102    psMetadata *inputexpArgs = psMetadataAlloc();
     103    psMetadataAddS64(inputexpArgs, PS_LIST_TAIL, "-corr_id", 0, "define correction id (required)", 0);
     104    psMetadataAddBool(inputexpArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
     105    psMetadataAddU64(inputexpArgs, PS_LIST_TAIL, "-limit",   0, "limit result set to N items", 0);
     106
     107    // -inputimfile
     108    psMetadata *inputimfileArgs = psMetadataAlloc();
     109    psMetadataAddS64(inputimfileArgs, PS_LIST_TAIL, "-chip_id", 0, "define chip id (required)", 0);
     110    psMetadataAddBool(inputimfileArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
     111    psMetadataAddU64(inputimfileArgs, PS_LIST_TAIL, "-limit",   0, "limit result set to N items", 0);
    127112
    128113    psFree(now);
    … …  
    131116    psMetadata *modes = psMetadataAlloc();
    132117
    133     PXOPT_ADD_MODE("-newrun",  "start a new flat correction run",        FLATCORR_MODE_NEWRUN,       newrunArgs);
    134     PXOPT_ADD_MODE("-addexp",  "add an exp to a flat correction run",        FLATCORR_MODE_ADDEXP,       addexpArgs);
    135     PXOPT_ADD_MODE("-pending", "show flat correction runs needing to be processed",        FLATCORR_MODE_PENDING,      pendingArgs);
    136     PXOPT_ADD_MODE("-flatcorrimfile", "list all the imfiles in a flat correction run",        FLATCORR_MODE_FLATCORRIMFILE, flatcorrimfileArgs);
    137     PXOPT_ADD_MODE("-done",  "change a flat calibration run's state",        FLATCORR_MODE_DONE,         doneArgs);
    138     PXOPT_ADD_MODE("-updaterun",  "change a flat calibration run's state",        FLATCORR_MODE_UPDATERUN,   updaterunArgs);
     118    PXOPT_ADD_MODE("-definebyquery",  "create a new, populated flat correction run",       FLATCORR_MODE_DEFINEBYQUERY,  definebyqueryArgs);
     119    PXOPT_ADD_MODE("-definerun",      "create a new, empty flat correction run",           FLATCORR_MODE_DEFINERUN,      definerunArgs);
     120    PXOPT_ADD_MODE("-addchip",        "add a chip to a flat correction run",               FLATCORR_MODE_ADDCHIP,        addchipArgs);
     121    PXOPT_ADD_MODE("-addcamera",      "migrate completed chips to camera stage analysis",  FLATCORR_MODE_ADDCAMERA,      addcameraArgs);
     122    PXOPT_ADD_MODE("-pendingprocess", "show flat correction runs needing to be processed", FLATCORR_MODE_PENDINGPROCESS, pendingprocessArgs);
     123    PXOPT_ADD_MODE("-addprocess",     "report completed flat correction analysis",         FLATCORR_MODE_ADDPROCESS,     addprocessArgs);
     124    PXOPT_ADD_MODE("-updaterun",      "change a flat calibration run's state",             FLATCORR_MODE_UPDATERUN,      updaterunArgs);
     125    PXOPT_ADD_MODE("-inputexp",       "list exposures for a correction run",               FLATCORR_MODE_INPUTEXP,       inputexpArgs);
     126    PXOPT_ADD_MODE("-inputimfile",    "list imfiles for a chip run",                       FLATCORR_MODE_INPUTIMFILE,    inputimfileArgs);
    139127
    140128    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {
Note: See TracChangeset for help on using the changeset viewer.