IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 11047


Ignore:
Timestamp:
Jan 11, 2007, 3:38:56 PM (19 years ago)
Author:
jhoblitt
Message:

require ippdb 0.0.73
merge rawScienceExp & rawDetrnedExp -> rawExp table
p0tool fault handling refactoring:

rename -updateimfile -> -addprocessedimfile
rename -updatexp -> -addprocessedexp
rename -faultimfile -> -updatedprocessedimfile
rename -faultexp -> -updateprocessedexp
rename -rawifmile -> -processedimfile
add -processedexp
remove newExp.fault & newImfile.fault
add rawImfile.fault & rawExp.fault

remove pxframes.c from the build and the related prototypes from pxtools.h

Location:
trunk/ippTools
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/ippTools/configure.ac

    r11037 r11047  
    1616PKG_CHECK_MODULES([PSLIB], [pslib >= 0.12.99])
    1717PKG_CHECK_MODULES([PSMODULES], [psmodules >= 0.12.0])
    18 PKG_CHECK_MODULES([IPPDB], [ippdb >= 0.0.72])
     18PKG_CHECK_MODULES([IPPDB], [ippdb >= 0.0.73])
    1919
    2020dnl check for PSDB support

  • trunk/ippTools/src/Makefile.am

    r11037 r11047  
    3939        pxconfig.c \
    4040        pxfault.c \
    41         pxframes.c \
    4241        pxtables.c \
    4342        pxtag.c

  • trunk/ippTools/src/dettool.c

    r10741 r11047  
    7777//static psArray *validDetInputClassIds(pxConfig *config, const char *det_id);
    7878//static psArray *searchInputImfiles(pxConfig *config, const char *det_id);
    79 static detInputExpRow *rawDetrenTodetInputExpRow(rawDetrendExpRow *rawExp, psS32 det_id, psS32 iteration);
     79static detInputExpRow *rawDetrenTodetInputExpRow(rawExpRow *rawExp, psS32 det_id, psS32 iteration);
    8080static psArray *searchRawImfiles(pxConfig *config, psMetadata *where);
    8181static psS32 incrementIteration(pxConfig *config, const char *det_id);
    … …  
    161161     psString query = psStringCopy(
    162162        "SELECT"
    163         "   rawDetrendExp.*"
    164         " FROM rawDetrendExp"
     163        "   rawExp.*"
     164        " FROM rawExp"
    165165        " LEFT JOIN detInputExp"
    166         "   ON rawDetrendExp.exp_tag = detInputExp.exp_tag"
     166        "   ON rawExp.exp_tag = detInputExp.exp_tag"
    167167        " WHERE"
    168168        "    detInputExp.exp_tag IS NULL"
    … …  
    170170
    171171    if (config->where) {
    172         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "rawDetrendExp");
     172        psString whereClause = psDBGenerateWhereConditionSQL(config->where, "rawExp");
    173173        psStringAppend(&query, " AND %s", whereClause);
    174174        psFree(whereClause);
    … …  
    189189    if (!psArrayLength(output)) {
    190190        // XXX check psError here
    191         psError(PS_ERR_UNKNOWN, false, "no pending rawDetrendExp rows found");
     191        psError(PS_ERR_UNKNOWN, false, "no pending rawExp rows found");
    192192        psFree(output);
    193193        return true;
    … …  
    205205
    206206    // negative simple so the default is true
    207     if (!ippdbPrintMetadatas(stdout, output, "rawDetrendExp", !simple)) {
     207    if (!ippdbPrintMetadatas(stdout, output, "rawExp", !simple)) {
    208208        psError(PS_ERR_UNKNOWN, false, "failed to print array");
    209209        psFree(output);
    … …  
    390390
    391391    // check that the specified exp_tags actually exist
    392     psArray *detrendExps = rawDetrendExpSelectRowObjects(config->dbh, where, 0);
     392    psArray *detrendExps = rawExpSelectRowObjects(config->dbh, where, 0);
    393393    psFree(where);
    394394    if (!detrendExps) {
    395         psError(PS_ERR_UNKNOWN, false, "no rawDetrendExp rows found");
    396         return false;
    397     }
    398 
    399     // we should have one rawDetrendExp row per exp_tag specified
     395        psError(PS_ERR_UNKNOWN, false, "no rawExp rows found");
     396        return false;
     397    }
     398
     399    // we should have one rawExp row per exp_tag specified
    400400    if (psListLength(item->data.list) != psArrayLength(detrendExps)) {
    401401        psAbort(config->argv[0],
    402     "an -exp_tag matched more then one rawDetrendExp (this should not happen");
     402    "an -exp_tag matched more then one rawExp (this should not happen");
    403403
    404404    }
    … …  
    433433    long det_id = psDBLastInsertID(config->dbh);
    434434
    435     // create new detInputExp row(s) from the rawDetrendExp row(s)
     435    // create new detInputExp row(s) from the rawExp row(s)
    436436    psArray *inputExps = psArrayAllocEmpty(psArrayLength(detrendExps));
    437437    for (long i = 0; i < psArrayLength(detrendExps); i++) {
    … …  
    803803    }
    804804
    805     // search for rawDetrendExps with the specified options
    806     psArray *detrendExps = rawDetrendExpSelectRowObjects(config->dbh, where, 0);
     805    // search for rawExps with the specified options
     806    psArray *detrendExps = rawExpSelectRowObjects(config->dbh, where, 0);
    807807    psFree(where);
    808     // make sure that we found at least one rawDetrendExp
     808    // make sure that we found at least one rawExp
    809809    if (!detrendExps) {
    810810        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    815815    }
    816816    if (!psArrayLength(detrendExps)) {
    817         psError(PS_ERR_UNKNOWN, true, "no rawDetrendExp rows found");
     817        psError(PS_ERR_UNKNOWN, true, "no rawExp rows found");
    818818        psFree(detrendExps);
    819819        psFree(registered);
    … …  
    825825    if (pretend) {
    826826        // negative simple so the default is true
    827         if (!rawDetrendExpPrintObjects(stdout, detrendExps, !simple)) {
     827        if (!rawExpPrintObjects(stdout, detrendExps, !simple)) {
    828828            psError(PS_ERR_UNKNOWN, false, "failed to print array");
    829829            psFree(detrendExps);
    … …  
    874874    long det_id = psDBLastInsertID(config->dbh);
    875875
    876     // create new detInputExp row(s) from the rawDetrendExp row(s)
     876    // create new detInputExp row(s) from the rawExp row(s)
    877877    psArray *inputExps = psArrayAllocEmpty(psArrayLength(detrendExps));
    878878    for (long i = 0; i < psArrayLength(detrendExps); i++) {
    … …  
    12081208        "       detResidExp.accept"
    12091209        "   FROM detResidExp"
    1210         "   JOIN rawDetrendExp"
     1210        "   JOIN rawExp"
    12111211        "       USING(exp_tag)"
    12121212        "   WHERE det_id = %d"
    … …  
    12141214
    12151215    if (time_filter->list->n) {
    1216         psString whereClause = psDBGenerateWhereConditionSQL(time_filter, "rawDetrendExp");
     1216        psString whereClause = psDBGenerateWhereConditionSQL(time_filter, "rawExp");
    12171217        psStringAppend(&query, " AND %s", whereClause);
    12181218        psFree(whereClause);
    … …  
    13251325}
    13261326
    1327 static detInputExpRow *rawDetrenTodetInputExpRow(rawDetrendExpRow *rawExp, psS32 det_id, psS32 iteration)
     1327static detInputExpRow *rawDetrenTodetInputExpRow(rawExpRow *rawExp, psS32 det_id, psS32 iteration)
    13281328{
    13291329    PS_ASSERT_PTR_NON_NULL(rawExp, NULL);
    … …  
    13421342
    13431343    // select detInputExp.*
    1344     // select rawDetrendExp.*
     1344    // select rawExp.*
    13451345    // by:
    13461346    // exp_tag
    … …  
    13491349        "SELECT DISTINCT *"
    13501350        " FROM detInputExp"
    1351         " JOIN rawDetrendExp"
     1351        " JOIN rawExp"
    13521352        " USING(exp_tag)"
    13531353        );
    … …  
    13731373    if (!psArrayLength(output)) {
    13741374        // XXX check psError here
    1375         psError(PS_ERR_UNKNOWN, false, "no pending rawDetrendExp rows found");
     1375        psError(PS_ERR_UNKNOWN, false, "no pending rawExp rows found");
    13761376        psFree(output);
    13771377        return true;
    … …  
    14091409            "   detRun.det_type,"
    14101410            "   rawImfile.*,"
    1411             "   rawDetrendExp.camera"
     1411            "   rawExp.camera"
    14121412            " FROM rawImfile"
    14131413            " JOIN detInputExp"
    14141414            "   USING(exp_tag) "
    1415             " JOIN rawDetrendExp"
     1415            " JOIN rawExp"
    14161416            "   USING(exp_tag) "
    14171417            " JOIN detRun"
    … …  
    14941494            "   detRun.det_type,"
    14951495            "   rawImfile.*,"
    1496             "   rawDetrendExp.camera"
     1496            "   rawExp.camera"
    14971497            " FROM detRun"
    14981498            " JOIN detInputExp"
    14991499            "    USING(det_id, iteration)"
    1500             " JOIN rawDetrendExp"
    1501             "    ON detInputExp.exp_tag = rawDetrendExp.exp_tag"
     1500            " JOIN rawExp"
     1501            "    ON detInputExp.exp_tag = rawExp.exp_tag"
    15021502            " JOIN rawImfile"
    15031503            "    ON detInputExp.exp_tag = rawImfile.exp_tag"
    … …  
    15821582        detInputExpSelectRowObjects(config->dbh, where, 0);
    15831583    if (!detInputExp) {
    1584         psError(PS_ERR_UNKNOWN, false, "no rawDetrendExp rows found");
     1584        psError(PS_ERR_UNKNOWN, false, "no rawExp rows found");
    15851585        return NULL;
    15861586    }
    … …  
    17891789        "    detRun.det_type,"
    17901790        "    detProcessedImfile.exp_tag,"
    1791         "    rawDetrendExp.camera,"
     1791        "    rawExp.camera,"
    17921792        "    detProcessedImfile.class_id,"
    1793         "    rawDetrendExp.imfiles"
     1793        "    rawExp.imfiles"
    17941794        " FROM detRun"
    17951795        " JOIN detInputExp"
    17961796        "   USING(det_id, iteration)"
    1797         " JOIN rawDetrendExp"
    1798         "   ON detInputExp.exp_tag = rawDetrendExp.exp_tag"
     1797        " JOIN rawExp"
     1798        "   ON detInputExp.exp_tag = rawExp.exp_tag"
    17991799        " JOIN rawImfile"
    1800         "   ON rawDetrendExp.exp_tag = rawImfile.exp_tag"
     1800        "   ON rawExp.exp_tag = rawImfile.exp_tag"
    18011801        " LEFT JOIN detProcessedImfile"
    18021802        "   ON detRun.det_id = detProcessedImfile.det_id"
    … …  
    18131813        "   AND detInputExp.include = 1"
    18141814        " GROUP BY"
    1815         "    rawDetrendExp.exp_tag,"
     1815        "    rawExp.exp_tag,"
    18161816        "    detRun.det_id"
    18171817        " HAVING"
    1818         "    COUNT(detProcessedImfile.class_id) = rawDetrendExp.imfiles"
     1818        "    COUNT(detProcessedImfile.class_id) = rawExp.imfiles"
    18191819        " ) AS detProcessedExp"
    18201820        );
    … …  
    18501850    if (!psArrayLength(output)) {
    18511851        // XXX check psError here
    1852         psError(PS_ERR_UNKNOWN, false, "no pending rawDetrendExp rows found");
     1852        psError(PS_ERR_UNKNOWN, false, "no pending rawExp rows found");
    18531853        psFree(output);
    18541854        return true;
    … …  
    19601960        "    ON detRun.det_id = detInputExp.det_id"
    19611961        "    AND detRun.iteration = detInputExp.iteration"
    1962         " JOIN rawDetrendExp"
    1963         "    ON detInputExp.exp_tag = rawDetrendExp.exp_tag"
     1962        " JOIN rawExp"
     1963        "    ON detInputExp.exp_tag = rawExp.exp_tag"
    19641964        " JOIN detProcessedImfile"
    19651965        "    ON detInputExp.det_id = detProcessedImfile.det_id"
    … …  
    20012001    if (!psArrayLength(output)) {
    20022002        // XXX check psError here
    2003         psError(PS_ERR_UNKNOWN, false, "no pending rawDetrendExp rows found");
     2003        psError(PS_ERR_UNKNOWN, false, "no pending rawExp rows found");
    20042004        return true;
    20052005    }
    … …  
    21142114        "    detRun.det_type,"
    21152115        "    detProcessedImfile.class_id,"
    2116         "    rawDetrendExp.camera"
     2116        "    rawExp.camera"
    21172117        " FROM detRun"
    21182118        " JOIN detInputExp"
    21192119        "    ON detRun.det_id = detInputExp.det_id"
    21202120        "    AND detRun.iteration = detInputExp.iteration"
    2121         " JOIN rawDetrendExp"
    2122         "    ON detInputExp.exp_tag = rawDetrendExp.exp_tag"
     2121        " JOIN rawExp"
     2122        "    ON detInputExp.exp_tag = rawExp.exp_tag"
    21232123        " JOIN rawImfile"
    21242124        "    ON detInputExp.exp_tag = rawImfile.exp_tag"
    … …  
    22712271
    22722272    // negative simple so the default is true
    2273     if (!ippdbPrintMetadatas(stdout, output, "rawDetrendImfile", !simple)) {
     2273    if (!ippdbPrintMetadatas(stdout, output, "rawImfile", !simple)) {
    22742274        psError(PS_ERR_UNKNOWN, false, "failed to print array");
    22752275        psFree(output);
    … …  
    24712471
    24722472    // negative simple so the default is true
    2473     if (!ippdbPrintMetadatas(stdout, output, "rawDetrendImfile", !simple)) {
     2473    if (!ippdbPrintMetadatas(stdout, output, "rawImfile", !simple)) {
    24742474        psError(PS_ERR_UNKNOWN, false, "failed to print array");
    24752475        psFree(output);
    … …  
    25172517        "   detRun.det_type,"
    25182518        "   detRun.iteration,"
    2519         "   rawDetrendExp.camera,"
    2520         "   rawDetrendExp.imfiles,"
     2519        "   rawExp.camera,"
     2520        "   rawExp.imfiles,"
    25212521        "   detStackedImfile.class_id"
    25222522        " FROM detRun"
    … …  
    25242524        "   ON detRun.det_id = detInputExp.det_id"
    25252525        "   AND detRun.iteration = detInputExp.iteration"
    2526         " JOIN rawDetrendExp"
    2527         "   ON detInputExp.exp_tag = rawDetrendExp.exp_tag"
     2526        " JOIN rawExp"
     2527        "   ON detInputExp.exp_tag = rawExp.exp_tag"
    25282528        " JOIN detStackedImfile"
    25292529        "   ON detInputExp.det_id = detStackedImfile.det_id"
    … …  
    25402540        "   AND detNormalizedStatImfile.class_id IS NULL"
    25412541        " GROUP BY"
    2542         "   rawDetrendExp.exp_tag,"
     2542        "   rawExp.exp_tag,"
    25432543        "   detRun.iteration,"
    25442544        "   detRun.det_id"
    2545         " HAVING MAX(rawDetrendExp.imfiles) = COUNT(detStackedImfile.class_id)"
     2545        " HAVING MAX(rawExp.imfiles) = COUNT(detStackedImfile.class_id)"
    25462546        ") as tonormalizedstat"
    25472547        );
    … …  
    27342734        "SELECT DISTINCT"
    27352735        "   detRun.det_type,"
    2736         "   rawDetrendExp.camera,"
     2736        "   rawExp.camera,"
    27372737        "   detStackedImfile.uri,"
    27382738        "   detNormalizedStatImfile.*"
    … …  
    27422742        " JOIN detInputExp"
    27432743        "   USING(det_id, iteration)"
    2744         " JOIN rawDetrendExp"
    2745         "   ON detInputExp.exp_tag = rawDetrendExp.exp_tag"
     2744        " JOIN rawExp"
     2745        "   ON detInputExp.exp_tag = rawExp.exp_tag"
    27462746        " JOIN detNormalizedStatImfile"
    27472747        "   ON detStackedImfile.det_id = detNormalizedStatImfile.det_id"
    … …  
    28052805
    28062806    // negative simple so the default is true
    2807     if (!ippdbPrintMetadatas(stdout, output, "rawDetrendImfile", !simple)) {
     2807    if (!ippdbPrintMetadatas(stdout, output, "rawImfile", !simple)) {
    28082808        psError(PS_ERR_UNKNOWN, false, "failed to print array");
    28092809        psFree(output);
    … …  
    30643064        "    detRun.iteration,"
    30653065        "    detRun.det_type,"
    3066         "    rawDetrendExp.camera,"
    3067         "    rawDetrendExp.telescope,"
    3068         "    rawDetrendExp.exp_type,"
    3069         "    rawDetrendExp.imfiles"
     3066        "    rawExp.camera,"
     3067        "    rawExp.telescope,"
     3068        "    rawExp.exp_type,"
     3069        "    rawExp.imfiles"
    30703070        " FROM detRun"
    30713071        " JOIN detInputExp"
    30723072        "    ON detRun.det_id = detInputExp.det_id"
    30733073        "    AND detRun.iteration = detInputExp.iteration"
    3074         " JOIN rawDetrendExp"
    3075         "    ON detInputExp.exp_tag = rawDetrendExp.exp_tag"
     3074        " JOIN rawExp"
     3075        "    ON detInputExp.exp_tag = rawExp.exp_tag"
    30763076        " JOIN detNormalizedImfile"
    30773077        "    ON detInputExp.det_id = detNormalizedImfile.det_id"
    … …  
    32273227        "    detRun.iteration,"
    32283228        "    detRun.det_type,"
    3229         "    rawDetrendExp.camera,"
    3230         "    rawDetrendExp.telescope,"
    3231         "    rawDetrendExp.exp_type,"
    3232         "    rawDetrendExp.imfiles"
     3229        "    rawExp.camera,"
     3230        "    rawExp.telescope,"
     3231        "    rawExp.exp_type,"
     3232        "    rawExp.imfiles"
    32333233        " FROM detRun"
    32343234        " JOIN detInputExp"
    32353235        "    ON detRun.det_id = detInputExp.det_id"
    32363236        "    AND detRun.iteration = detInputExp.iteration"
    3237         " JOIN rawDetrendExp"
    3238         "    ON detInputExp.exp_tag = rawDetrendExp.exp_tag"
     3237        " JOIN rawExp"
     3238        "    ON detInputExp.exp_tag = rawExp.exp_tag"
    32393239        " JOIN detNormalizedImfile"
    32403240        "    ON detInputExp.det_id = detNormalizedImfile.det_id"
    … …  
    34623462        "   detProcessedImfile.uri,\n"
    34633463        "   detNormalizedImfile.uri AS det_uri,\n"
    3464         "   rawDetrendExp.camera\n"
     3464        "   rawExp.camera\n"
    34653465        " FROM detRun\n"
    34663466        " JOIN detInputExp\n"
    34673467        "   USING(det_id, iteration)\n"
    3468         " JOIN rawDetrendExp\n"
    3469         "   ON detInputExp.exp_tag = rawDetrendExp.exp_tag\n"
     3468        " JOIN rawExp\n"
     3469        "   ON detInputExp.exp_tag = rawExp.exp_tag\n"
    34703470        " JOIN detProcessedImfile\n"
    34713471        "   ON detRun.det_id = detProcessedImfile.det_id\n"
    … …  
    34973497        "   rawImfile.uri,\n"
    34983498        "   'NULL' AS det_uri,\n"
    3499         "   rawDetrendExp.camera\n"
     3499        "   rawExp.camera\n"
    35003500        " FROM detRun\n"
    35013501        " JOIN detInputExp\n"
    35023502        "    USING(det_id, iteration)\n"
    3503         " JOIN rawDetrendExp\n"
    3504         "    ON detInputExp.exp_tag = rawDetrendExp.exp_tag\n"
     3503        " JOIN rawExp\n"
     3504        "    ON detInputExp.exp_tag = rawExp.exp_tag\n"
    35053505        " JOIN rawImfile\n"
    35063506        "    ON detInputExp.exp_tag = rawImfile.exp_tag\n"
    … …  
    36893689        " JOIN detInputExp\n"
    36903690        "    USING(det_id, iteration)\n"
    3691         " JOIN rawDetrendExp\n"
    3692         "    ON detInputExp.exp_tag = rawDetrendExp.exp_tag\n"
     3691        " JOIN rawExp\n"
     3692        "    ON detInputExp.exp_tag = rawExp.exp_tag\n"
    36933693        " JOIN rawImfile\n"
    36943694        "    ON detInputExp.exp_tag = rawImfile.exp_tag\n"
    … …  
    40474047        "       detInputExp.exp_tag,\n"
    40484048        "       detInputExp.include,\n"
    4049         "       rawDetrendExp.imfiles,\n"
    4050         "       rawDetrendExp.camera,\n"
     4049        "       rawExp.imfiles,\n"
     4050        "       rawExp.camera,\n"
    40514051        "       detResidImfile.class_id\n"
    40524052        "   FROM detRun\n"
    40534053        "   JOIN detInputExp\n"
    40544054        "       USING(det_id, iteration)\n"
    4055         "   JOIN rawDetrendExp\n"
    4056         "       ON detInputExp.exp_tag = rawDetrendExp.exp_tag\n"
     4055        "   JOIN rawExp\n"
     4056        "       ON detInputExp.exp_tag = rawExp.exp_tag\n"
    40574057        "   JOIN detResidImfile\n"
    40584058        "       ON detRun.det_id = detResidImfile.det_id\n"
    … …  
    40734073        "       detRun.det_id\n"
    40744074        "   HAVING\n"
    4075         "       rawDetrendExp.imfiles = COUNT(detResidImfile.class_id)\n"
     4075        "       rawExp.imfiles = COUNT(detResidImfile.class_id)\n"
    40764076        " ) AS toresidexp\n"
    40774077        );
    … …  
    41714171        "       detInputExp.exp_tag,"
    41724172        "       detInputExp.include,"
    4173         "       rawDetrendExp.imfiles"
     4173        "       rawExp.imfiles"
    41744174        "   FROM detRun"
    41754175        "   JOIN detInputExp"
    41764176        "       USING(det_id, iteration)"
    4177         "   JOIN rawDetrendExp"
    4178         "       ON detInputExp.exp_tag = rawDetrendExp.exp_tag"
     4177        "   JOIN rawExp"
     4178        "       ON detInputExp.exp_tag = rawExp.exp_tag"
    41794179        "   JOIN detResidImfile"
    41804180        "       ON detRun.det_id = detResidImfile.det_id"
    … …  
    41954195        "       detRun.det_id"
    41964196        "   HAVING"
    4197         "       rawDetrendExp.imfiles = COUNT(detResidImfile.class_id)"
     4197        "       rawExp.imfiles = COUNT(detResidImfile.class_id)"
    41984198        " ) AS toresidexp"
    41994199        );
    … …  
    45284528        "       detRun.mode,\n"
    45294529        "       detInputExp.exp_tag,\n"
    4530         "       rawDetrendExp.camera\n"
     4530        "       rawExp.camera\n"
    45314531        "   FROM detRun\n"
    45324532        "   JOIN detInputExp\n"
    45334533        "       USING(det_id, iteration)\n"
    4534         "   JOIN rawDetrendExp\n"
    4535         "       ON detInputExp.exp_tag = rawDetrendExp.exp_tag\n"
     4534        "   JOIN rawExp\n"
     4535        "       ON detInputExp.exp_tag = rawExp.exp_tag\n"
    45364536        "   LEFT JOIN detResidExp\n"
    45374537        "       ON detRun.det_id = detResidExp.det_id\n"
    … …  
    48024802        "       ON detRun.det_id = detInputExp.det_id\n"
    48034803        "       AND detRun.iteration = detInputExp.iteration\n"
    4804         "   LEFT JOIN rawDetrendExp\n"
    4805         "       ON detInputExp.exp_tag = rawDetrendExp.exp_tag\n"
     4804        "   LEFT JOIN rawExp\n"
     4805        "       ON detInputExp.exp_tag = rawExp.exp_tag\n"
    48064806        "   LEFT JOIN detResidExp\n"
    48074807        "       ON detRun.det_id = detResidExp.det_id\n"
    … …  
    53055305    psFree(where);
    53065306    if (!detrendExps) {
    5307         psError(PS_ERR_UNKNOWN, false, "no rawDetrendExp rows found");
     5307        psError(PS_ERR_UNKNOWN, false, "no rawExp rows found");
    53085308        psFree(where);
    53095309        return false;

  • trunk/ippTools/src/pxframes.c

    r10230 r11047  
    5757//PX_FRAME_ALLOC(newFrame, newExp);
    5858//PX_FRAME_ALLOC(rawDetrendFrame, rawDetrendExp);
    59 PX_FRAME_ALLOC(rawScienceFrame, rawScienceExp);
     59//PX_FRAME_ALLOC(rawScienceFrame, rawScienceExp);
    6060//PX_FRAME_ALLOC(p2PendingFrame, p2PendingExp);
    6161
    … …  
    9292
    9393//PX_FRAME_PRINT(newFrame, newImfile);
    94 PX_FRAME_PRINT(rawScienceFrame, rawImfile);
     94//PX_FRAME_PRINT(rawScienceFrame, rawImfile);
    9595//PX_FRAME_PRINT(rawDetrendFrame, rawImfile);
    9696//PX_FRAME_PRINT(p2PendingFrame, p2PendingImfile);
    … …  
    145145//PX_FRAME_SEARCH(newFrame, newExp, newImfile);
    146146//PX_FRAME_SEARCH(rawDetrendFrame, rawDetrendExp, rawImfile, exp_tag);
    147 PX_FRAME_SEARCH(rawScienceFrame, rawScienceExp, rawImfile, exp_tag);
     147//PX_FRAME_SEARCH(rawScienceFrame, rawScienceExp, rawImfile, exp_tag);
    148148//PX_FRAME_SEARCH(p2PendingFrame, p2PendingExp, p2PendingImfile, exp_tag);
    149149

  • trunk/ippTools/src/pxinject.c

    r10971 r11047  
    148148                dateobs,
    149149                exp_type,
    150                 imfiles,
    151                 0           // error flags
     150                imfiles
    152151            )
    153152        ) {
    … …  
    232231
    233232    // insert with error flag state set to 0 (no errors)
    234     if (!newImfileInsert(config->dbh, exp_tag, class, class_id, uri, 0)) {
     233    if (!newImfileInsert(config->dbh, exp_tag, class, class_id, uri)) {
    235234        psError(PS_ERR_UNKNOWN, false, "database error");
    236235        return false;

  • trunk/ippTools/src/pxtables.c

    r10755 r11047  
    5757    CREATE_TABLE(newExpCreateTable);
    5858    CREATE_TABLE(newImfileCreateTable);
    59     CREATE_TABLE(rawScienceExpCreateTable);
     59    CREATE_TABLE(rawExpCreateTable);
    6060    CREATE_TABLE(rawImfileCreateTable);
    61     CREATE_TABLE(rawDetrendExpCreateTable);
    6261    CREATE_TABLE(p1PendingExpCreateTable);
    6362    CREATE_TABLE(p2PendingExpCreateTable);
    … …  
    130129    DROP_TABLE(newExpDropTable);
    131130    DROP_TABLE(newImfileDropTable);
    132     DROP_TABLE(rawScienceExpDropTable);
     131    DROP_TABLE(rawExpDropTable);
    133132    DROP_TABLE(rawImfileDropTable);
    134     DROP_TABLE(rawDetrendExpDropTable);
    135133    DROP_TABLE(p1PendingExpDropTable);
    136134    DROP_TABLE(p2PendingExpDropTable);

  • trunk/ippTools/src/pxtools.h

    r11037 r11047  
    4949bool pxDeleteTables (pxConfig *config);
    5050
    51 typedef struct {
    52     rawScienceExpRow *exposure;
    53     psArray *images;
    54 } rawScienceFrame;
    55 
    56 rawScienceFrame *rawScienceFrameAlloc(
    57     rawScienceExpRow *exposure,
    58     psArray *images
    59 );
    60 
    61 bool rawScienceFramePrint(FILE *stream, pxConfig *config, psArray *frames);
    62 psArray *rawScienceFrameSearch(pxConfig *config);
    63 bool rawScienceFrameInsert(pxConfig *config, rawScienceFrame *frame);
    64 
    6551bool pxSetFaultCode(psDB *dbh, const char *tableName, psMetadata *where, psS8 code);
    6652

  • trunk/ippTools/src/regtool.c

    r11037 r11047  
    2727#include "p0tool.h"
    2828
     29static bool pendingimfileMode(pxConfig *config);
     30static bool addprocessedimfileMode(pxConfig *config);
     31static bool processedimfileMode(pxConfig *config);
     32static bool updateprocessedimfileMode(pxConfig *config);
     33
    2934static bool pendingexpMode(pxConfig *config);
    30 static bool pendingimfileMode(pxConfig *config);
    31 static bool updateexpMode(pxConfig *config);
    32 static bool updateimfileMode(pxConfig *config);
    33 static bool faultexpMode(pxConfig *config);
    34 static bool faultimfileMode(pxConfig *config);
    35 static bool rawimfileMode(pxConfig *config);
     35static bool addprocessedexpMode(pxConfig *config);
     36static bool processedexpMode(pxConfig *config);
     37static bool updateprocessedexpMode(pxConfig *config);
     38
     39
    3640// static p1PendingExpRow *newToP1PendingExp(newExpRow *newExp);
    3741static p2PendingExpRow *newToP2PendingExp(pxConfig *config, newExpRow *newExp);
    3842static p2PendingImfileRow *rawImfileToP2PendingImfile(pxConfig *config, rawImfileRow *rawImfile);
    39 static rawScienceExpRow *newToRawScienceExp(pxConfig *config, newExpRow *exp);
    40 static rawDetrendExpRow *newToRawDetrendExp(pxConfig *config, newExpRow *exp);
     43
     44static rawExpRow *newToRawExp(pxConfig *config, newExpRow *exp);
    4145static rawImfileRow *newToRawImfile(pxConfig *config, newImfileRow *exp);
    4246//static psU32 mapCodeStrToInt(const char *codeStr);
    … …  
    5963
    6064    switch (config->mode) {
    61         MODECASE(P0TOOL_MODE_PENDINGEXP,        pendingexpMode);
    62         MODECASE(P0TOOL_MODE_PENDINGIMFILE,     pendingimfileMode);
    63         MODECASE(P0TOOL_MODE_UPDATEEXP,         updateexpMode);
    64         MODECASE(P0TOOL_MODE_FAULTEXP,          faultexpMode);
    65         MODECASE(P0TOOL_MODE_UPDATEIMFILE,      updateimfileMode);
    66         MODECASE(P0TOOL_MODE_FAULTIMFILE,       faultimfileMode);
    67         MODECASE(P0TOOL_MODE_RAWIMFILE,         rawimfileMode);
     65        MODECASE(P0TOOL_MODE_PENDINGIMFILE,         pendingimfileMode);
     66        MODECASE(P0TOOL_MODE_ADDPROCESSEDIMFILE,    addprocessedimfileMode);
     67        MODECASE(P0TOOL_MODE_PROCESSEDIMFILE,       processedimfileMode);
     68        MODECASE(P0TOOL_MODE_UPDATEPROCESSEDIMFILE, updateprocessedimfileMode);
     69        MODECASE(P0TOOL_MODE_PENDINGEXP,            pendingexpMode);
     70        MODECASE(P0TOOL_MODE_ADDPROCESSEDEXP,       addprocessedexpMode);
     71        MODECASE(P0TOOL_MODE_PROCESSEDEXP,          processedexpMode);
     72        MODECASE(P0TOOL_MODE_UPDATEPROCESSEDEXP,    updateprocessedexpMode);
    6873        default:
    6974            psAbort(argv[0], "invalid option (this should not happen)");
    … …  
    8893}
    8994
    90 static bool pendingexpMode(pxConfig *config)
     95
     96static bool pendingimfileMode(pxConfig *config)
    9197{
    9298    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    99105    }
    100106
     107    // select newImfiles that:
     108    // exp_tag is in newExp
     109    // don't have their exp_tag in rawExp
     110    // XXX having the same exp_tag in newExp and raw*Exp is probably an error
     111    // that should be checked for
     112
     113    psString query = psStringCopy(
     114        "SELECT\n"
     115        "   newImfile.*\n"
     116        " FROM newImfile\n"
     117        " LEFT JOIN newExp\n"
     118        "   USING(exp_tag)\n"
     119        " LEFT JOIN rawExp\n"
     120        "   USING(exp_tag)\n"
     121        " WHERE\n"
     122        "   newExp.exp_tag is NOT NULL\n"
     123        "   AND rawExp.exp_tag IS NULL\n"
     124    );
     125
     126    // treat limit == 0 as "no limit"
     127    if (limit) {
     128        psString limitString = psDBGenerateLimitSQL(limit);
     129        psStringAppend(&query, " %s", limitString);
     130        psFree(limitString);
     131    }
     132
     133    if (!p_psDBRunQuery(config->dbh, query)) {
     134        // XXX PS_EXIT_PROG_ERROR (incorrect SQL) or SYS_ERROR (database comms)
     135        psError(PXTOOLS_ERR_PROG, false, "database error");
     136        psFree(query);
     137        return false;
     138    }
     139    psFree(query);
     140
     141    psArray *output = p_psDBFetchResult(config->dbh);
     142    if (!output) {
     143        // XXX PS_EXIT_PROG_ERROR (incorrect SQL) or SYS_ERROR (database comms)
     144        psError(PXTOOLS_ERR_PROG, false, "database error");
     145        return false;
     146    }
     147    if (!psArrayLength(output)) {
     148        psFree(output);
     149        return true;
     150    }
     151
     152    bool simple = false;
     153    simple = psMetadataLookupBool(&status, config->args, "-simple");
     154    if (!status) {
     155        psError(PXTOOLS_ERR_PROG, false, "failed to lookup value for -simple");
     156        return false;
     157    }
     158
     159    // negate simple so the default is true
     160    if (!ippdbPrintMetadatas(stdout, output, "p0PendingImfile", !simple)) {
     161        psError(PXTOOLS_ERR_PROG, false, "failed to print array");
     162        psFree(output);
     163        return false;
     164    }
     165
     166    psFree(output);
     167
     168    return true;
     169}
     170
     171
     172static bool addprocessedimfileMode(pxConfig *config)
     173{
     174    PS_ASSERT_PTR_NON_NULL(config, false);
     175
     176    // XXX search by the whole frame some imfiles without a newExp don't get
     177    // processed -- this may not be the correct thing to do
     178    psString query = psStringCopy(
     179        "SELECT\n"
     180        "   *\n"
     181        " FROM\n"
     182        "   (SELECT newImfile.* FROM newImfile\n"
     183        "       LEFT JOIN newExp USING(exp_tag)\n"
     184        "       LEFT JOIN rawExp USING(exp_tag)\n"
     185        "       WHERE newExp.exp_tag IS NOT NULL\n"
     186        "       AND rawExp.exp_tag IS NULL) as Foo\n"
     187        ); // WHERE class is generated from exp_tag, class, & class_id
     188
     189    {
     190        // build a query to search by exp_tag, class, class_id
     191        psMetadata *where = psMetadataAlloc();
     192        bool status = false;
     193        psString exp_tag = psMetadataLookupStr(&status, config->args, "-exp_tag");
     194        if (!status) {
     195            psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_tag");
     196            psFree(query);
     197            return false;
     198        }
     199        if (exp_tag) {
     200            if (!psMetadataAddStr(where, PS_LIST_TAIL, "exp_tag", 0, "==", exp_tag)) {
     201                psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
     202                psFree(where);
     203                psFree(query);
     204                return false;
     205            }
     206        }
     207        psString class = psMetadataLookupStr(&status, config->args, "-class");
     208        if (!status) {
     209            psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -class");
     210            psFree(query);
     211            return false;
     212        }
     213        if (class) {
     214            if (!psMetadataAddStr(where, PS_LIST_TAIL, "class", 0, "==", class)) {
     215                psError(PS_ERR_UNKNOWN, false, "failed to add item class");
     216                psFree(where);
     217                psFree(query);
     218                return false;
     219            }
     220        }
     221        psString class_id = psMetadataLookupStr(&status, config->args, "-class_id");
     222        if (!status) {
     223            psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -class_id");
     224            psFree(query);
     225            return false;
     226        }
     227        if (class_id) {
     228            if (!psMetadataAddStr(where, PS_LIST_TAIL, "class_id", 0, "==", class_id)) {
     229                psError(PS_ERR_UNKNOWN, false, "failed to add item class_id");
     230                psFree(where);
     231                psFree(query);
     232                return false;
     233            }
     234        }
     235
     236        // there's not
     237        psString whereClaus = psDBGenerateWhereSQL(where, NULL);
     238        psFree(where);
     239        if (whereClaus) {
     240            psStringAppend(&query, " %s", whereClaus);
     241            psFree(whereClaus);
     242        }
     243    }
     244
     245    if (!p_psDBRunQuery(config->dbh, query)) {
     246        psError(PS_ERR_UNKNOWN, false, "database error");
     247        psFree(query);
     248        return false;
     249    }
     250    psFree(query);
     251
     252    psArray *output = p_psDBFetchResult(config->dbh);
     253    if (!output) {
     254        psError(PS_ERR_UNKNOWN, false, "database error");
     255        return false;
     256    }
     257    if (!psArrayLength(output)) {
     258        // XXX check psError here
     259        psError(PS_ERR_UNKNOWN, false, "no pending newImfile rows found");
     260        psFree(output);
     261        return false;
     262    }
     263
     264    // insert 'newImfile's into rawImfile
     265    if (psArrayLength(output) > 0) {
     266        // start a transaction so we don't end up half of the imfiles we were
     267        // trying to update uninserted
     268        if (!psDBTransaction(config->dbh)) {
     269            psError(PS_ERR_UNKNOWN, false, "database error");
     270            psFree(output);
     271            return false;
     272        }
     273
     274        for (long i = 0; i < psArrayLength(output); i++) {
     275            // convert newImfile metadata -> newImfile object
     276            newImfileRow *object = newImfileObjectFromMetadata(output->data[i]);
     277            // convert newImfile object -> rawImfile object
     278            rawImfileRow *imfile = newToRawImfile(config, object);
     279            if (!imfile) {
     280                // rollback
     281                if (!psDBRollback(config->dbh)) {
     282                    psError(PS_ERR_UNKNOWN, false, "database error");
     283                }
     284                psError(PS_ERR_UNKNOWN, false, "failed to create a new rawImfile row");
     285                psFree(object);
     286                psFree(output);
     287                return false;
     288            }
     289            // insert the rawImfile object into the database
     290            if (!rawImfileInsertObject(config->dbh, imfile)) {
     291                // rollback
     292                if (!psDBRollback(config->dbh)) {
     293                    psError(PS_ERR_UNKNOWN, false, "database error");
     294                }
     295                psError(PS_ERR_UNKNOWN, false, "failed to insert row into the database");
     296                psFree(imfile);
     297                psFree(object);
     298                psFree(output);
     299                return false;
     300            }
     301            psFree(imfile);
     302            // remove the neImfile object from the database
     303            if (!newImfileDeleteObject(config->dbh, object)) {
     304                // rollback
     305                if (!psDBRollback(config->dbh)) {
     306                    psError(PS_ERR_UNKNOWN, false, "database error");
     307                }
     308                psError(PS_ERR_UNKNOWN, false, "failed to delete row from the database");
     309                psFree(object);
     310                psFree(output);
     311                return false;
     312            }
     313            psFree(object);
     314        }
     315
     316        // point of no return for rawImfile
     317        if (!psDBCommit(config->dbh)) {
     318            psError(PS_ERR_UNKNOWN, false, "database error");
     319            psFree(output);
     320            return false;
     321        }
     322    }
     323
     324    psFree(output);
     325
     326    return true;
     327}
     328
     329
     330static bool processedimfileMode(pxConfig *config)
     331{
     332    PS_ASSERT_PTR_NON_NULL(config, false);
     333
     334    bool status = false;
     335    psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
     336    if (!status) {
     337        psError(PXTOOLS_ERR_PROG, false, "failed to lookup value for -limit");
     338        return false;
     339    }
     340
    101341    bool faulted = psMetadataLookupU64(&status, config->args, "-faulted");
    102342    if (!status) {
    … …  
    105345    }
    106346
     347    // find all rawImfiles matching the default query
     348    psString query = psStringCopy(
     349        "SELECT\n"
     350        "   *\n"
     351        " FROM rawImfile\n"
     352        " WHERE rawImfile.exp_tag is NOT NULL\n" //bogus conditional so there is a where clause to append to
     353    );
     354
     355    if (config->where) {
     356        psString whereClause = psDBGenerateWhereConditionSQL(config->where, "rawImfile");
     357        psStringAppend(&query, " AND %s", whereClause);
     358        psFree(whereClause);
     359    }
     360
     361    if (faulted) {
     362        // list only faulted rows
     363        psStringAppend(&query, " %s", "AND rawImfile.fault != 0");
     364    } else {
     365        // don't list faulted rows
     366        psStringAppend(&query, " %s", "AND rawImfile.fault = 0");
     367    }
     368
     369    // treat limit == 0 as "no limit"
     370    if (limit) {
     371        psString limitString = psDBGenerateLimitSQL(limit);
     372        psStringAppend(&query, " %s", limitString);
     373        psFree(limitString);
     374    }
     375
     376    if (!p_psDBRunQuery(config->dbh, query)) {
     377        psError(PS_ERR_UNKNOWN, false, "database error");
     378        psFree(query);
     379        return false;
     380    }
     381    psFree(query);
     382
     383    psArray *output = p_psDBFetchResult(config->dbh);
     384    if (!output) {
     385        psError(PS_ERR_UNKNOWN, false, "database error");
     386        return false;
     387    }
     388    if (!psArrayLength(output)) {
     389        psError(PS_ERR_UNKNOWN, false, "no pending rawImfile rows found");
     390        psFree(output);
     391        return true;
     392    }
     393
     394    bool simple = false;
     395    {
     396        bool status = false;
     397        simple = psMetadataLookupBool(&status, config->args, "-simple");
     398        if (!status) {
     399            psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
     400            return false;
     401        }
     402    }
     403
     404    if (psArrayLength(output)) {
     405        // negative simple so the default is true
     406        if (!ippdbPrintMetadatas(stdout, output, "rawImfile", !simple)) {
     407            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     408            psFree(output);
     409            return false;
     410        }
     411    }
     412
     413    psFree(output);
     414
     415    return true;
     416}
     417
     418
     419static bool updateprocessedimfileMode(pxConfig *config)
     420{
     421    PS_ASSERT_PTR_NON_NULL(config, false);
     422
     423    bool status = false;
     424    psS8 code = psMetadataLookupS8(&status, config->args, "-code");
     425    if (!status) {
     426        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -code");
     427        return false;
     428    }
     429
     430    if (!pxSetFaultCode(config->dbh, "rawImfile", config->where, code)) {
     431        psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag");
     432        return false;
     433    }
     434
     435    return true;
     436}
     437
     438
     439static bool pendingexpMode(pxConfig *config)
     440{
     441    PS_ASSERT_PTR_NON_NULL(config, false);
     442
     443    bool status = false;
     444    psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
     445    if (!status) {
     446        psError(PXTOOLS_ERR_PROG, false, "failed to lookup value for -limit");
     447        return false;
     448    }
     449
    107450    // return only exps that:
    108     // are not in rawScienceExp
    109     // are not in rawDetrendExp
     451    // are not in rawExp
    110452    // have ALL of their imfiles in rawImfile (by count)
    111453    // and have no associated imfiles left in newImfile
    … …  
    117459        " LEFT JOIN newImfile"
    118460        "   USING(exp_tag)"
    119         " LEFT JOIN rawScienceExp"
    120         "   USING(exp_tag)"
    121         " LEFT JOIN rawDetrendExp"
     461        " LEFT JOIN rawExp"
    122462        "   USING(exp_tag)"
    123463        " WHERE"
    124464        "   newImfile.exp_tag IS NULL"
    125         "   AND rawScienceExp.exp_tag IS NULL"
    126         "   AND rawDetrendExp.exp_tag IS NULL"
     465        "   AND rawExp.exp_tag IS NULL"
    127466        "   AND newExp.imfiles ="
    128467        "   (SELECT COUNT(exp_tag) FROM rawImfile"
    129468        "       WHERE rawImfile.exp_tag = newExp.exp_tag)"
    130469    );
    131 
    132     if (faulted) {
    133         // list only faulted rows
    134         psStringAppend(&query, " %s", "AND newExp.fault != 0");
    135     } else {
    136         // don't list faulted rows
    137         psStringAppend(&query, " %s", "AND newExp.fault = 0");
    138     }
    139470
    140471    // treat limit == 0 as "no limit"
    … …  
    183514}
    184515
    185 static bool pendingimfileMode(pxConfig *config)
     516
     517static bool addprocessedexpMode(pxConfig *config)
    186518{
    187519    PS_ASSERT_PTR_NON_NULL(config, false);
    188520
    189     bool status = false;
    190     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    191     if (!status) {
    192         psError(PXTOOLS_ERR_PROG, false, "failed to lookup value for -limit");
    193         return false;
    194     }
    195 
    196     bool faulted = psMetadataLookupU64(&status, config->args, "-faulted");
    197     if (!status) {
    198         psError(PXTOOLS_ERR_PROG, false, "failed to lookup value for -faulted");
    199         return false;
    200     }
    201 
    202     // select newImfiles that:
    203     // exp_tag is in newExp
    204     // don't have their exp_tag in rawScienceExp
    205     // don't have their exp_tag in rawDetrendExp
    206     // XXX having the same exp_tag in newExp and raw*Exp is probably an error
    207     // that should be checked for
    208 
    209     psString query = psStringCopy(
    210         "SELECT newImfile.* FROM newImfile"
    211         " LEFT JOIN newExp USING(exp_tag)"
    212         " LEFT JOIN rawScienceExp USING(exp_tag)"
    213         " LEFT JOIN rawDetrendExp USING (exp_tag)"
    214         " WHERE newExp.exp_tag is NOT NULL"
    215         " AND rawScienceExp.exp_tag IS NULL"
    216         " AND rawDetrendExp.exp_tag IS NULL"
    217     );
    218 
    219     if (faulted) {
    220         // list only faulted rows
    221         psStringAppend(&query, " %s", "AND newImfile.fault != 0");
    222     } else {
    223         // don't list faulted rows
    224         psStringAppend(&query, " %s", "AND newImfile.fault = 0");
    225     }
    226 
    227     // treat limit == 0 as "no limit"
    228     if (limit) {
    229         psString limitString = psDBGenerateLimitSQL(limit);
    230         psStringAppend(&query, " %s", limitString);
    231         psFree(limitString);
    232     }
    233 
    234     if (!p_psDBRunQuery(config->dbh, query)) {
    235         // XXX PS_EXIT_PROG_ERROR (incorrect SQL) or SYS_ERROR (database comms)
    236         psError(PXTOOLS_ERR_PROG, false, "database error");
    237         psFree(query);
    238         return false;
    239     }
    240     psFree(query);
    241 
    242     psArray *output = p_psDBFetchResult(config->dbh);
    243     if (!output) {
    244         // XXX PS_EXIT_PROG_ERROR (incorrect SQL) or SYS_ERROR (database comms)
    245         psError(PXTOOLS_ERR_PROG, false, "database error");
    246         return false;
    247     }
    248     if (!psArrayLength(output)) {
    249         psFree(output);
    250         return true;
    251     }
    252 
    253     bool simple = false;
    254     simple = psMetadataLookupBool(&status, config->args, "-simple");
    255     if (!status) {
    256         psError(PXTOOLS_ERR_PROG, false, "failed to lookup value for -simple");
    257         return false;
    258     }
    259 
    260     // negate simple so the default is true
    261     if (!ippdbPrintMetadatas(stdout, output, "newImfile", !simple)) {
    262         psError(PXTOOLS_ERR_PROG, false, "failed to print array");
    263         psFree(output);
    264         return false;
    265     }
    266 
    267     psFree(output);
    268 
    269     return true;
    270 }
    271 
    272 static bool faultexpMode(pxConfig *config)
    273 {
    274     bool status = false;
    275     psS8 code = psMetadataLookupS8(&status, config->args, "-code");
    276     if (!status) {
    277         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -code");
    278         return false;
    279     }
    280 
    281     if (!pxSetFaultCode(config->dbh, "newExp", config->where, code)) {
    282         psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag");
    283         return false;
    284     }
    285 
    286     return true;
    287 }
    288 
    289 static bool faultimfileMode(pxConfig *config)
    290 {
    291     PS_ASSERT_PTR_NON_NULL(config, false);
    292 
    293     bool status = false;
    294     psS8 code = psMetadataLookupS8(&status, config->args, "-code");
    295     if (!status) {
    296         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -code");
    297         return false;
    298     }
    299 
    300     if (!pxSetFaultCode(config->dbh, "newImfile", config->where, code)) {
    301         psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag");
    302         return false;
    303     }
    304 
    305     return true;
    306 }
    307 
    308 
    309 static bool updateexpMode(pxConfig *config)
    310 {
    311     PS_ASSERT_PTR_NON_NULL(config, false);
    312 
    313521    // make sure that the exp_tag(s) are ready to be updated based on:
    314     // exp_tag is not in rawScienceExp
    315     // exp_tag is not in rawDetrendExp
     522    // exp_tag is not in rawExp
    316523    // exp_tag is not in newImfile
    317524    // that the correct count of imfiles is in rawImfile
    … …  
    340547        " LEFT JOIN newImfile"
    341548        "   USING(exp_tag)"
    342         " LEFT JOIN rawScienceExp"
    343         "   USING(exp_tag)"
    344         " LEFT JOIN rawDetrendExp"
     549        " LEFT JOIN rawExp"
    345550        "   USING(exp_tag)"
    346551        " WHERE"
    347552        "   newExp.exp_tag IS NOT NULL"
    348553        "   AND newImfile.exp_tag IS NULL"
    349         "   AND rawScienceExp.exp_tag IS NULL"
     554        "   AND rawExp.exp_tag IS NULL"
    350555        "   AND newExp.imfiles ="
    351556        "   (SELECT COUNT(exp_tag) FROM rawImfile"
    … …  
    369574    }
    370575
    371 
    372     // start a transaction so we don't end up with an exp in
    373     // rawScience/DetrendExp and in newExp
     576    // start a transaction so we don't end up with an exp in both rawExp &
     577    // newExp
    374578    if (!psDBTransaction(config->dbh)) {
    375579        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    378582    }
    379583
    380     // if it's a detrend exp
    381     if (detrend) {       
    382         for (long i = 0; psArrayLength(output) > i; i++) {
    383             psMetadata *row = output->data[i];
    384             // convert metadata into a newExp object
    385             newExpRow *newExp = newExpObjectFromMetadata(row);
    386             // convert newExp object into a rawDetrendExp object
    387             rawDetrendExpRow *rawExp = newToRawDetrendExp(config, newExp);
    388             if (!rawExp) {
    389                 // rollback
    390                 if (!psDBRollback(config->dbh)) {
    391                     psError(PS_ERR_UNKNOWN, false, "database error");
    392                 }
    393                 psError(PS_ERR_UNKNOWN, false, "failed to convert newExp to rawDetrendExp");
    394                 psFree(newExp);
    395                 psFree(output);
    396                 return false;
    397             }
    398             // insert the rawDetrendExp object into the database
    399             if (!rawDetrendExpInsertObject(config->dbh, rawExp)) {
    400                 // rollback
    401                 if (!psDBRollback(config->dbh)) {
    402                     psError(PS_ERR_UNKNOWN, false, "database error");
    403                 }
    404                 psError(PS_ERR_UNKNOWN, false, "database error");
    405                 psFree(rawExp);
    406                 psFree(newExp);
    407                 psFree(output);
    408                 return false;
    409             }
    410             psFree(rawExp);
    411             // delete the newExp object from the database
    412             if (!newExpDeleteObject(config->dbh, newExp)) {
    413                 // rollback
    414                 if (!psDBRollback(config->dbh)) {
    415                     psError(PS_ERR_UNKNOWN, false, "database error");
    416                 }
    417                 psError(PS_ERR_UNKNOWN, false, "database error");
    418                 psFree(newExp);
    419                 psFree(output);
    420                 return false;
    421             }
    422             psFree(newExp);
    423         }
    424 
    425         psFree(output);
    426 
    427         if (!psDBCommit(config->dbh)) {
    428             psError(PS_ERR_UNKNOWN, false, "database error");
    429             return false;
    430         }
    431 
    432         return true;
    433     }
    434 
    435     // else
    436     // it's a science exp
     584    // insert the exp into rawExp
    437585    for (long i = 0; psArrayLength(output) > i; i++) {
    438586        psMetadata *row = output->data[i];
    439587        // convert metadata into a newExp object
    440588        newExpRow *newExp = newExpObjectFromMetadata(row);
    441         // convert newExp object into a rawDetrendExp object
    442         rawScienceExpRow *rawExp = newToRawScienceExp(config, newExp);
     589        // convert newExp object into a rawExp object
     590        rawExpRow *rawExp = newToRawExp(config, newExp);
    443591        if (!rawExp) {
    444592            // rollback
    … …  
    446594                psError(PS_ERR_UNKNOWN, false, "database error");
    447595            }
    448             psError(PS_ERR_UNKNOWN, false, "failed to convert newExp to rawScienceExp");
     596            psError(PS_ERR_UNKNOWN, false, "failed to convert newExp to rawExp");
    449597            psFree(newExp);
    450598            psFree(output);
    451599            return false;
    452600        }
    453         // insert the rawDetrendExp object into the database
    454         if (!rawScienceExpInsertObject(config->dbh, rawExp)) {
     601
     602        // insert the rawExp object into the database
     603        if (!rawExpInsertObject(config->dbh, rawExp)) {
    455604            // rollback
    456605            if (!psDBRollback(config->dbh)) {
    … …  
    464613        }
    465614        psFree(rawExp);
     615
    466616        // delete the newExp object from the database
    467617        if (!newExpDeleteObject(config->dbh, newExp)) {
    … …  
    475625            return false;
    476626        }
     627
     628        // if this is a detrend image don't put it in the p2 queue (and we're
     629        // done)
     630        if (detrend) {
     631            psFree(newExp);
     632            continue;
     633        }
     634
    477635        // insert an entry into the p2PendingExp table
    478636        p2PendingExpRow *p2PendingExp = newToP2PendingExp(config, newExp);
    … …  
    483641            return false;
    484642        }
     643
    485644        // insert the p2PendingExp object into the database
    486645        if (!p2PendingExpInsertObject(config->dbh, p2PendingExp)) {
    … …  
    496655        }
    497656        psFree(p2PendingExp);
     657
    498658        // find all of the rawImfiles associated with the p2PendingExp object
    499659        psArray *rawImfiles = NULL;
    … …  
    570730}
    571731
    572 static bool updateimfileMode(pxConfig *config)
     732
     733static bool processedexpMode(pxConfig *config)
    573734{
    574735    PS_ASSERT_PTR_NON_NULL(config, false);
    575736
    576     // XXX search by the whole frame some imfiles without a newExp don't get
    577     // processed -- this may not be the correct thing to do
    578     psString query = psStringCopy(
    579         "SELECT * FROM"
    580             " (SELECT newImfile.* FROM newImfile"
    581                 " LEFT JOIN newExp USING(exp_tag)"
    582                 " LEFT JOIN rawScienceExp USING(exp_tag)"
    583                 " LEFT JOIN rawDetrendExp USING (exp_tag)"
    584                 " WHERE newExp.exp_tag IS NOT NULL"
    585                 " AND rawScienceExp.exp_tag IS NULL"
    586                 " AND rawDetrendExp.exp_tag IS NULL) AS foo"
    587         ); // WHERE class is generated from exp_tag, class, & class_id
    588 
    589     {
    590         // build a query to search by exp_tag, class, class_id
    591         psMetadata *where = psMetadataAlloc();
    592         bool status = false;
    593         psString exp_tag = psMetadataLookupStr(&status, config->args, "-exp_tag");
    594         if (!status) {
    595             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_tag");
    596             psFree(query);
    597             return false;
    598         }
    599         if (exp_tag) {
    600             if (!psMetadataAddStr(where, PS_LIST_TAIL, "exp_tag", 0, "==", exp_tag)) {
    601                 psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    602                 psFree(where);
    603                 psFree(query);
    604                 return false;
    605             }
    606         }
    607         psString class = psMetadataLookupStr(&status, config->args, "-class");
    608         if (!status) {
    609             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -class");
    610             psFree(query);
    611             return false;
    612         }
    613         if (class) {
    614             if (!psMetadataAddStr(where, PS_LIST_TAIL, "class", 0, "==", class)) {
    615                 psError(PS_ERR_UNKNOWN, false, "failed to add item class");
    616                 psFree(where);
    617                 psFree(query);
    618                 return false;
    619             }
    620         }
    621         psString class_id = psMetadataLookupStr(&status, config->args, "-class_id");
    622         if (!status) {
    623             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -class_id");
    624             psFree(query);
    625             return false;
    626         }
    627         if (class_id) {
    628             if (!psMetadataAddStr(where, PS_LIST_TAIL, "class_id", 0, "==", class_id)) {
    629                 psError(PS_ERR_UNKNOWN, false, "failed to add item class_id");
    630                 psFree(where);
    631                 psFree(query);
    632                 return false;
    633             }
    634         }
    635 
    636         // there's not
    637         psString whereClaus = psDBGenerateWhereSQL(where, NULL);
    638         psFree(where);
    639         if (whereClaus) {
    640             psStringAppend(&query, " %s", whereClaus);
    641             psFree(whereClaus);
    642         }
     737    bool status = false;
     738    psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
     739    if (!status) {
     740        psError(PXTOOLS_ERR_PROG, false, "failed to lookup value for -limit");
     741        return false;
     742    }
     743
     744    bool faulted = psMetadataLookupU64(&status, config->args, "-faulted");
     745    if (!status) {
     746        psError(PXTOOLS_ERR_PROG, false, "failed to lookup value for -faulted");
     747        return false;
     748    }
     749
     750    // find all rawImfiles matching the default query
     751    psString query = psStringCopy(
     752        "SELECT\n"
     753        "   *\n"
     754        " FROM rawExp\n"
     755        " WHERE\n"
     756        "   rawExp.exp_tag IS NOT NULL\n" // bogus where clause
     757    );
     758
     759    if (config->where) {
     760        psString whereClause = psDBGenerateWhereConditionSQL(config->where, "rawExp");
     761        psStringAppend(&query, " AND %s", whereClause);
     762        psFree(whereClause);
     763    }
     764
     765    if (faulted) {
     766        // list only faulted rows
     767        psStringAppend(&query, " %s", "AND rawExp.fault != 0");
     768    } else {
     769        // don't list faulted rows
     770        psStringAppend(&query, " %s", "AND rawExp.fault = 0");
     771    }
     772
     773    // treat limit == 0 as "no limit"
     774    if (limit) {
     775        psString limitString = psDBGenerateLimitSQL(limit);
     776        psStringAppend(&query, " %s", limitString);
     777        psFree(limitString);
    643778    }
    644779
    645780    if (!p_psDBRunQuery(config->dbh, query)) {
    646781        psError(PS_ERR_UNKNOWN, false, "database error");
    647         psFree(query);
    648782        return false;
    649783    }
    … …  
    656790    }
    657791    if (!psArrayLength(output)) {
    658         // XXX check psError here
    659         psError(PS_ERR_UNKNOWN, false, "no pending newImfile rows found");
     792        psError(PS_ERR_UNKNOWN, false, "no pending rawExp rows found");
    660793        psFree(output);
    661         return false;
    662     }
    663 
    664     // insert 'newImfile's into rawImfile
    665     if (psArrayLength(output) > 0) {
    666         // start a transaction so we don't end up half of the imfiles we were
    667         // trying to update uninserted
    668         if (!psDBTransaction(config->dbh)) {
    669             psError(PS_ERR_UNKNOWN, false, "database error");
    670             psFree(output);
    671             return false;
    672         }
    673 
    674         for (long i = 0; i < psArrayLength(output); i++) {
    675             // convert newImfile metadata -> newImfile object
    676             newImfileRow *object = newImfileObjectFromMetadata(output->data[i]);
    677             // convert newImfile object -> rawImfile object
    678             rawImfileRow *imfile = newToRawImfile(config, object);
    679             if (!imfile) {
    680                 // rollback
    681                 if (!psDBRollback(config->dbh)) {
    682                     psError(PS_ERR_UNKNOWN, false, "database error");
    683                 }
    684                 psError(PS_ERR_UNKNOWN, false, "failed to create a new rawImfile row");
    685                 psFree(object);
    686                 psFree(output);
    687                 return false;
    688             }
    689             // insert the rawImfile object into the database
    690             if (!rawImfileInsertObject(config->dbh, imfile)) {
    691                 // rollback
    692                 if (!psDBRollback(config->dbh)) {
    693                     psError(PS_ERR_UNKNOWN, false, "database error");
    694                 }
    695                 psError(PS_ERR_UNKNOWN, false, "failed to insert row into the database");
    696                 psFree(imfile);
    697                 psFree(object);
    698                 psFree(output);
    699                 return false;
    700             }
    701             psFree(imfile);
    702             // remove the neImfile object from the database
    703             if (!newImfileDeleteObject(config->dbh, object)) {
    704                 // rollback
    705                 if (!psDBRollback(config->dbh)) {
    706                     psError(PS_ERR_UNKNOWN, false, "database error");
    707                 }
    708                 psError(PS_ERR_UNKNOWN, false, "failed to delete row from the database");
    709                 psFree(object);
    710                 psFree(output);
    711                 return false;
    712             }
    713             psFree(object);
    714         }
    715 
    716         // point of no return for rawImfile
    717         if (!psDBCommit(config->dbh)) {
    718             psError(PS_ERR_UNKNOWN, false, "database error");
    719             psFree(output);
    720             return false;
    721         }
    722     }
    723 
    724     psFree(output);
    725 
    726     return true;
    727 }
    728 
    729 static bool rawimfileMode(pxConfig *config)
    730 {
    731     PS_ASSERT_PTR_NON_NULL(config, false);
    732 
    733     // find all rawImfiles matching the default query
    734     psArray *rawImfiles = rawImfileSelectRowObjects(config->dbh, config->where, 0);
    735     if (!rawImfiles) {
    736         psError(PS_ERR_UNKNOWN, false, "no rawImfile rows found");
    737         return false;
    738     }
     794        return true;
     795    }
     796
    739797    bool simple = false;
    740798    {
    … …  
    747805    }
    748806
    749     if (psArrayLength(rawImfiles)) {
     807    if (psArrayLength(output)) {
    750808        // negative simple so the default is true
    751         if (!rawImfilePrintObjects(stdout, rawImfiles, !simple)) {
     809        if (!ippdbPrintMetadatas(stdout, output, "rawExp", !simple)) {
    752810            psError(PS_ERR_UNKNOWN, false, "failed to print array");
    753             psFree(rawImfiles);
    754             return false;
    755         }
    756     }
    757 
    758     psFree(rawImfiles);
     811            psFree(output);
     812            return false;
     813        }
     814    }
     815
     816    psFree(output);
    759817
    760818    return true;
    761819}
     820
     821
     822static bool updateprocessedexpMode(pxConfig *config)
     823{
     824    bool status = false;
     825    psS8 code = psMetadataLookupS8(&status, config->args, "-code");
     826    if (!status) {
     827        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -code");
     828        return false;
     829    }
     830
     831    if (!pxSetFaultCode(config->dbh, "rawExp", config->where, code)) {
     832        psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag");
     833        return false;
     834    }
     835
     836    return true;
     837}
     838
     839
    762840# if 0
    763841static p1PendingExpRow *newToP1PendingExp(newExpRow *newExp)
    … …  
    781859#endif
    782860
     861
    783862static p2PendingExpRow *newToP2PendingExp(pxConfig *config, newExpRow *exp)
    784863{
    … …  
    804883    return p2Exp;
    805884}
     885
    806886
    807887static p2PendingImfileRow *rawImfileToP2PendingImfile(pxConfig *config, rawImfileRow *rawImfile)
    … …  
    817897}
    818898
    819 static rawScienceExpRow *newToRawScienceExp(pxConfig *config, newExpRow *exp)
    820 {
    821     PS_ASSERT_PTR_NON_NULL(config, NULL);
    822     PS_ASSERT_PTR_NON_NULL(exp, NULL);
    823 
    824     // XXX this is dangerous but we should be able to get away with this as
    825     // long rawScienceExp & rawDetrendExp are idetnical
    826     return (rawScienceExpRow *)newToRawDetrendExp(config, exp);
    827 }
    828 
    829 static rawDetrendExpRow *newToRawDetrendExp(pxConfig *config, newExpRow *exp)
     899
     900static rawExpRow *newToRawExp(pxConfig *config, newExpRow *exp)
    830901{
    831902    PS_ASSERT_PTR_NON_NULL(config, NULL);
    … …  
    9321003    }
    9331004
    934     rawDetrendExpRow *raw = rawDetrendExpRowAlloc(
     1005    // default
     1006    psS8 code = psMetadataLookupS8(&status, config->args, "-code");
     1007    if (!status) {
     1008        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -code");
     1009        return false;
     1010    }
     1011
     1012    rawExpRow *raw = rawExpRowAlloc(
    9351013        exp->exp_tag,
    9361014        exp->camera,
    … …  
    9511029        posang,
    9521030        object,
    953         dateobs
     1031        dateobs,
     1032        code
    9541033    );
    9551034
    … …  
    9601039    return raw;
    9611040}
     1041
    9621042
    9631043static rawImfileRow *newToRawImfile(pxConfig *config, newImfileRow *imfile)
    … …  
    10651145            dateobs = NULL;
    10661146        }
     1147    }
     1148
     1149    psS8 code = psMetadataLookupS8(&status, config->args, "-code");
     1150    if (!status) {
     1151        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -code");
     1152        return false;
    10671153    }
    10681154
    … …  
    10861172        posang,
    10871173        object,
    1088         dateobs
     1174        dateobs,
     1175        code
    10891176    );
    10901177

  • trunk/ippTools/src/regtool.h

    r10976 r11047  
    2525typedef enum {
    2626    P0TOOL_MODE_NONE      = 0x0,
     27    P0TOOL_MODE_PENDINGIMFILE,
     28    P0TOOL_MODE_ADDPROCESSEDIMFILE,
     29    P0TOOL_MODE_PROCESSEDIMFILE,
     30    P0TOOL_MODE_UPDATEPROCESSEDIMFILE,
    2731    P0TOOL_MODE_PENDINGEXP,
    28     P0TOOL_MODE_PENDINGIMFILE,
    29     P0TOOL_MODE_UPDATEEXP,
    30     P0TOOL_MODE_FAULTEXP,
    31     P0TOOL_MODE_UPDATEIMFILE,
    32     P0TOOL_MODE_FAULTIMFILE,
    33     P0TOOL_MODE_RAWIMFILE
     32    P0TOOL_MODE_ADDPROCESSEDEXP,
     33    P0TOOL_MODE_PROCESSEDEXP,
     34    P0TOOL_MODE_UPDATEPROCESSEDEXP,
    3435} p0toolMode;
    3536

  • trunk/ippTools/src/regtoolConfig.c

    r10988 r11047  
    4141    }
    4242
     43    // -pendingimfile
     44    psMetadata *pendingimfileArgs = psMetadataAlloc();
     45    psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-exp_tag",  0,
     46        "search by exposure ID", NULL);
     47    psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-class",  0,
     48        "search by class", NULL);
     49    psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-class_id",  0,
     50        "search by class ID", NULL);
     51    psMetadataAddU64(pendingimfileArgs, PS_LIST_TAIL, "-limit",  0,
     52        "limit result set to N items", 0);
     53    psMetadataAddBool(pendingimfileArgs, PS_LIST_TAIL, "-simple",  0,
     54        "use the simple output format", false);
     55
     56    // -addprocessedimfile
     57    psMetadata *addprocessedimfileArgs = psMetadataAlloc();
     58    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-exp_tag",  0,
     59        "search by exposure ID", NULL);
     60    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-class",  0,
     61        "search by class", NULL);
     62    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-class_id",  0,
     63        "search by class ID", NULL);
     64    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-exp_type",  0,
     65        "define exposure type", NULL);
     66    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-filter",  0,
     67        "define filter ", NULL);
     68    psMetadataAddF32(addprocessedimfileArgs, PS_LIST_TAIL, "-airmass",  0,
     69        "define airmass", NAN);
     70    psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-ra",  0,
     71        "define RA", NAN);
     72    psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-decl",  0,
     73        "define DEC", NAN);
     74    psMetadataAddF32(addprocessedimfileArgs, PS_LIST_TAIL, "-exp_time",  0,
     75        "define exposure time", NAN);
     76    psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-bg",  0,
     77        "define exposue background", NAN);
     78    psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-bg_stdev",  0,
     79        "define exposue background stdev", NAN);
     80    psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,
     81        "define exposue background mean stdev", NAN);
     82    psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-alt",  0,
     83        "define altitute", NAN);
     84    psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-az",  0,
     85        "define azimuth", NAN);
     86    psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-ccd_temp",  0,
     87        "define ccd tempature", NAN);
     88    psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-posang",  0,
     89        "define rotator position angle", NAN);
     90    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-object",  0,
     91        "define exposure object", NULL);
     92    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-dateobs",  0,
     93        "define observation time", NULL);
     94    psMetadataAddS8(addprocessedimfileArgs, PS_LIST_TAIL, "-code",  0,
     95        "set fault code (required)", 0);
     96
     97    // -processedimfile
     98    psMetadata *processedimfileArgs = psMetadataAlloc();
     99    psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-exp_tag",  0,
     100        "search by exposure ID", NULL);
     101    psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-class",  0,
     102        "search by class", NULL);
     103    psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-class_id",  0,
     104        "search by class ID", NULL);
     105    psMetadataAddU64(processedimfileArgs, PS_LIST_TAIL, "-limit",  0,
     106        "limit result set to N items", 0);
     107    psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-faulted",  0,
     108        "only return imfiles with a fault status set", false);
     109    psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-simple",  0,
     110        "use the simple output format", false);
     111
     112    // -updateprocessedimfile
     113    psMetadata *updateprocessedimfileArgs = psMetadataAlloc();
     114    psMetadataAddStr(updateprocessedimfileArgs, PS_LIST_TAIL, "-exp_tag",  0,
     115        "search by exposure ID", NULL);
     116    psMetadataAddStr(updateprocessedimfileArgs, PS_LIST_TAIL, "-class",  0,
     117        "search by class", NULL);
     118    psMetadataAddStr(updateprocessedimfileArgs, PS_LIST_TAIL, "-class_id",  0,
     119        "search by class ID", NULL);
     120    psMetadataAddS8(updateprocessedimfileArgs, PS_LIST_TAIL, "-code",  0,
     121        "set fault code (required)", 0);
     122   
     123
    43124    // -pendingexp
    44125    psMetadata *pendingexpArgs = psMetadataAlloc();
    … …  
    55136    psMetadataAddU64(pendingexpArgs, PS_LIST_TAIL, "-limit",  0,
    56137        "limit result set to N items", 0);
    57     psMetadataAddBool(pendingexpArgs, PS_LIST_TAIL, "-faulted",  0,
    58         "only return imfiles with a fault status set", false);
    59138    psMetadataAddBool(pendingexpArgs, PS_LIST_TAIL, "-simple",  0,
    60139        "use the simple output format", false);
    61    
    62     // -pendingimfile
    63     psMetadata *pendingimfileArgs = psMetadataAlloc();
    64     psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-exp_tag",  0,
    65         "search by exposure ID", NULL);
    66     psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-class",  0,
    67         "search by class", NULL);
    68     psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-class_id",  0,
    69         "search by class ID", NULL);
    70     psMetadataAddU64(pendingimfileArgs, PS_LIST_TAIL, "-limit",  0,
    71         "limit result set to N items", 0);
    72     psMetadataAddBool(pendingimfileArgs, PS_LIST_TAIL, "-faulted",  0,
    73         "only return imfiles with a fault status set", false);
    74     psMetadataAddBool(pendingimfileArgs, PS_LIST_TAIL, "-simple",  0,
    75         "use the simple output format", false);
    76 
    77 
    78     // -updateexp
    79     psMetadata *updateexpArgs = psMetadataAlloc();
    80     psMetadataAddStr(updateexpArgs, PS_LIST_TAIL, "-exp_tag",  0,
     140
     141    // -addprocessedexp
     142    psMetadata *addprocessedexpArgs = psMetadataAlloc();
     143    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-exp_tag",  0,
    81144        "exp_tag to operate on (required)", NULL);
    82     psMetadataAddStr(updateexpArgs, PS_LIST_TAIL, "-exp_type",  0,
     145    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-exp_type",  0,
    83146        "define exposure type", NULL);
    84     psMetadataAddStr(updateexpArgs, PS_LIST_TAIL, "-filter",  0,
     147    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-filter",  0,
    85148        "define filter ", NULL);
    86     psMetadataAddF32(updateexpArgs, PS_LIST_TAIL, "-airmass",  0,
     149    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-airmass",  0,
    87150        "define airmass", NAN);
    88     psMetadataAddF64(updateexpArgs, PS_LIST_TAIL, "-ra",  0,
     151    psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-ra",  0,
    89152        "define RA", NAN);
    90     psMetadataAddF64(updateexpArgs, PS_LIST_TAIL, "-decl",  0,
     153    psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-decl",  0,
    91154        "define DEC", NAN);
    92     psMetadataAddF32(updateexpArgs, PS_LIST_TAIL, "-exp_time",  0,
     155    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-exp_time",  0,
    93156        "define exposure time", NAN);
    94     psMetadataAddF64(updateexpArgs, PS_LIST_TAIL, "-bg",  0,
     157    psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-bg",  0,
    95158        "define exposue background", NAN);
    96     psMetadataAddF64(updateexpArgs, PS_LIST_TAIL, "-bg_stdev",  0,
     159    psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-bg_stdev",  0,
    97160        "define exposue background stdev", NAN);
    98     psMetadataAddF64(updateexpArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,
     161    psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,
    99162        "define exposue background mean stdev", NAN);
    100     psMetadataAddF64(updateexpArgs, PS_LIST_TAIL, "-alt",  0,
     163    psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-alt",  0,
    101164        "define altitute", NAN);
    102     psMetadataAddF64(updateexpArgs, PS_LIST_TAIL, "-az",  0,
     165    psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-az",  0,
    103166        "define azimuth", NAN);
    104     psMetadataAddF64(updateexpArgs, PS_LIST_TAIL, "-ccd_temp",  0,
     167    psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-ccd_temp",  0,
    105168        "define ccd tempature", NAN);
    106     psMetadataAddF64(updateexpArgs, PS_LIST_TAIL, "-posang",  0,
     169    psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-posang",  0,
    107170        "define rotator position angle", NAN);
    108     psMetadataAddStr(updateexpArgs, PS_LIST_TAIL, "-object",  0,
     171    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-object",  0,
    109172        "define exposure object", NULL);
    110     psMetadataAddStr(updateexpArgs, PS_LIST_TAIL, "-dateobs",  0,
     173    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-dateobs",  0,
    111174        "define observation time", NULL);
    112     psMetadataAddStr(updateexpArgs, PS_LIST_TAIL, "-label",  0,
     175    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-label",  0,
    113176        "define label for phase 2 processing (non-detrend data only)", NULL);
     177    psMetadataAddS8(addprocessedexpArgs, PS_LIST_TAIL, "-code",  0,
     178        "set fault code (required)", 0);
    114179    /*
    115180    psMetadataAddStr(updateArgs, PS_LIST_TAIL, "-recip",  0,
    … …  
    118183        "define URL", NULL);
    119184    */
    120     psMetadataAddBool(updateexpArgs, PS_LIST_TAIL, "-detrend",  0,
     185    psMetadataAddBool(addprocessedexpArgs, PS_LIST_TAIL, "-detrend",  0,
    121186        "declare this as detrend data", false);
    122187
    123     // -faultexp
    124     psMetadata *faultexpArgs = psMetadataAlloc();
    125     psMetadataAddStr(faultexpArgs, PS_LIST_TAIL, "-exp_tag",  0,
    126         "search by exposure ID", NULL);
    127     psMetadataAddS8(faultexpArgs, PS_LIST_TAIL, "-code",  0,
     188    // -processedexp
     189    psMetadata *processedexpArgs = psMetadataAlloc();
     190    psMetadataAddStr(processedexpArgs, PS_LIST_TAIL, "-exp_tag",  0,
     191        "search by exposure ID", NULL);
     192    psMetadataAddU64(processedexpArgs, PS_LIST_TAIL, "-limit",  0,
     193        "limit result set to N items", 0);
     194    psMetadataAddBool(processedexpArgs, PS_LIST_TAIL, "-faulted",  0,
     195        "only return imfiles with a fault status set", false);
     196    psMetadataAddBool(processedexpArgs, PS_LIST_TAIL, "-simple",  0,
     197        "use the simple output format", false);
     198
     199    // -updatedprocessedexp
     200    psMetadata *updatedprocessedexpArgs = psMetadataAlloc();
     201    psMetadataAddStr(updatedprocessedexpArgs, PS_LIST_TAIL, "-exp_tag",  0,
     202        "search by exposure ID", NULL);
     203    psMetadataAddS8(updatedprocessedexpArgs, PS_LIST_TAIL, "-code",  0,
    128204        "set fault code (required)", 0);
    129205   
    130     // -updateimfile
    131     psMetadata *updateimfileArgs = psMetadataAlloc();
    132     psMetadataAddStr(updateimfileArgs, PS_LIST_TAIL, "-exp_tag",  0,
    133         "search by exposure ID", NULL);
    134     psMetadataAddStr(updateimfileArgs, PS_LIST_TAIL, "-class",  0,
    135         "search by class", NULL);
    136     psMetadataAddStr(updateimfileArgs, PS_LIST_TAIL, "-class_id",  0,
    137         "search by class ID", NULL);
    138     psMetadataAddStr(updateimfileArgs, PS_LIST_TAIL, "-exp_type",  0,
    139         "define exposure type", NULL);
    140     psMetadataAddStr(updateimfileArgs, PS_LIST_TAIL, "-filter",  0,
    141         "define filter ", NULL);
    142     psMetadataAddF32(updateimfileArgs, PS_LIST_TAIL, "-airmass",  0,
    143         "define airmass", NAN);
    144     psMetadataAddF64(updateimfileArgs, PS_LIST_TAIL, "-ra",  0,
    145         "define RA", NAN);
    146     psMetadataAddF64(updateimfileArgs, PS_LIST_TAIL, "-decl",  0,
    147         "define DEC", NAN);
    148     psMetadataAddF32(updateimfileArgs, PS_LIST_TAIL, "-exp_time",  0,
    149         "define exposure time", NAN);
    150     psMetadataAddF64(updateimfileArgs, PS_LIST_TAIL, "-bg",  0,
    151         "define exposue background", NAN);
    152     psMetadataAddF64(updateimfileArgs, PS_LIST_TAIL, "-bg_stdev",  0,
    153         "define exposue background stdev", NAN);
    154     psMetadataAddF64(updateimfileArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,
    155         "define exposue background mean stdev", NAN);
    156     psMetadataAddF64(updateimfileArgs, PS_LIST_TAIL, "-alt",  0,
    157         "define altitute", NAN);
    158     psMetadataAddF64(updateimfileArgs, PS_LIST_TAIL, "-az",  0,
    159         "define azimuth", NAN);
    160     psMetadataAddF64(updateimfileArgs, PS_LIST_TAIL, "-ccd_temp",  0,
    161         "define ccd tempature", NAN);
    162     psMetadataAddF64(updateimfileArgs, PS_LIST_TAIL, "-posang",  0,
    163         "define rotator position angle", NAN);
    164     psMetadataAddStr(updateimfileArgs, PS_LIST_TAIL, "-object",  0,
    165         "define exposure object", NULL);
    166     psMetadataAddStr(updateimfileArgs, PS_LIST_TAIL, "-dateobs",  0,
    167         "define observation time", NULL);
    168 
    169     // -faultimfile
    170     psMetadata *faultimfileArgs = psMetadataAlloc();
    171     psMetadataAddStr(faultimfileArgs, PS_LIST_TAIL, "-exp_tag",  0,
    172         "search by exposure ID", NULL);
    173     psMetadataAddStr(faultimfileArgs, PS_LIST_TAIL, "-class",  0,
    174         "search by class", NULL);
    175     psMetadataAddStr(faultimfileArgs, PS_LIST_TAIL, "-class_id",  0,
    176         "search by class ID", NULL);
    177     psMetadataAddS8(faultimfileArgs, PS_LIST_TAIL, "-code",  0,
    178         "set fault code (required)", 0);
    179    
    180     // -rawimfile
    181     psMetadata *rawimfileArgs = psMetadataAlloc();
    182     psMetadataAddStr(rawimfileArgs, PS_LIST_TAIL, "-exp_tag",  0,
    183         "search by exposure ID", NULL);
    184     psMetadataAddStr(rawimfileArgs, PS_LIST_TAIL, "-class_id",  0,
    185         "search by class ID", NULL);
    186     psMetadataAddBool(rawimfileArgs, PS_LIST_TAIL, "-simple",  0,
    187         "use the simple output format", false);
    188206
    189207#define PXTOOL_MODE(option, modeval, argset) \
    … …  
    207225    psMetadata *argSets = psMetadataAlloc();
    208226    // find which mode we're running under
    209     PXTOOL_MODE("-pendingexp",   P0TOOL_MODE_PENDINGEXP,    pendingexpArgs);
    210     PXTOOL_MODE("-pendingimfile",P0TOOL_MODE_PENDINGIMFILE, pendingimfileArgs);
    211     PXTOOL_MODE("-updateexp",    P0TOOL_MODE_UPDATEEXP,     updateexpArgs);
    212     PXTOOL_MODE("-faultexp",     P0TOOL_MODE_FAULTEXP,      faultexpArgs);
    213     PXTOOL_MODE("-updateimfile", P0TOOL_MODE_UPDATEIMFILE,  updateimfileArgs);
    214     PXTOOL_MODE("-faultimfile",  P0TOOL_MODE_FAULTIMFILE,   faultimfileArgs);
    215     PXTOOL_MODE("-rawimfile",    P0TOOL_MODE_RAWIMFILE,     rawimfileArgs);
     227    PXTOOL_MODE("-pendingimfile",   P0TOOL_MODE_PENDINGIMFILE, pendingimfileArgs);
     228    PXTOOL_MODE("-addprocessedimfile", P0TOOL_MODE_ADDPROCESSEDIMFILE, addprocessedimfileArgs);
     229    PXTOOL_MODE("-processedimfile", P0TOOL_MODE_PROCESSEDIMFILE, processedimfileArgs);
     230    PXTOOL_MODE("-updateprocessedimfile",  P0TOOL_MODE_UPDATEPROCESSEDIMFILE, updateprocessedimfileArgs);
     231    PXTOOL_MODE("-pendingexp",      P0TOOL_MODE_PENDINGEXP,pendingexpArgs);
     232    PXTOOL_MODE("-addprocessedexp", P0TOOL_MODE_ADDPROCESSEDEXP, addprocessedexpArgs);
     233    PXTOOL_MODE("-processedexp",    P0TOOL_MODE_PROCESSEDEXP, processedexpArgs);
     234    PXTOOL_MODE("-updateprocessedexp", P0TOOL_MODE_UPDATEPROCESSEDEXP,      updatedprocessedexpArgs);
    216235
    217236    bool argErr = false;
Note: See TracChangeset for help on using the changeset viewer.