IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 18366


Ignore:
Timestamp:
Jun 29, 2008, 3:02:07 PM (18 years ago)
Author:
eugene
Message:

merge updates from cleanup branch

Location:
trunk/ippTools
Files:
2 added
1 deleted
17 edited

Legend:

Unmodified
Added
Removed

  • trunk/ippTools/scripts/regtest.sh

    r18336 r18366  
    3535$regtool -pendingexp|| exit 1
    3636
    37 $regtool -addprocessedexp -exp_id $exp_id1 -exp_name t10 -inst gpc -telescope ps1 -exp_tag batman.t10 -filelevel OTA -filter r -airmass 10 -ra 1 -decl 2 -exp_type bias -exp_time 0 -bg 10 -bg_stdev 1 -bg_mean_stdev 10 -alt 10 -az 10 -ccd_temp 45 -posang 10 -object dog -dateobs "2006-10-20T10:10:10Z" -label foobar -tess_id moldyshoe $* || exit 1
     37$regtool -addprocessedexp -exp_id $exp_id1 -exp_name t10 -inst gpc -telescope ps1 -exp_tag batman.t10 -filelevel OTA -filter r -airmass 10 -ra 1 -decl 2 -exp_type object -exp_time 0 -bg 10 -bg_stdev 1 -bg_mean_stdev 10 -alt 10 -az 10 -ccd_temp 45 -posang 10 -object dog -dateobs "2006-10-20T10:10:10Z" -label foobar -tess_id moldyshoe $* || exit 1
     38# use BIAS or OBJECT? $regtool -addprocessedexp -exp_id $exp_id1 -exp_name t10 -inst gpc -telescope ps1 -exp_tag batman.t10 -filelevel OTA -filter r -airmass 10 -ra 1 -decl 2 -exp_type bias -exp_time 0 -bg 10 -bg_stdev 1 -bg_mean_stdev 10 -alt 10 -az 10 -ccd_temp 45 -posang 10 -object dog -dateobs "2006-10-20T10:10:10Z" -label foobar -tess_id moldyshoe $* || exit 1
    3839
    3940$regtool -pendingimfile || exit 1
    … …  
    4546$regtool -pendingexp|| exit 1
    4647
    47 $regtool -addprocessedexp -exp_id $exp_id2 -exp_name t11 -inst gpc -telescope ps1 -exp_tag batman.t11 -filelevel OTA -filter r -airmass 11 -ra 1 -decl 2 -exp_type bias -exp_time 0 -bg 11 -bg_stdev 1 -bg_mean_stdev 11 -alt 11 -az 11 -ccd_temp 45 -posang 11 -object dog -dateobs 2006-10-20T10:10:10Z -label foobar -tess_id moldyshoe $* || exit 1
     48$regtool -addprocessedexp -exp_id $exp_id2 -exp_name t11 -inst gpc -telescope ps1 -exp_tag batman.t11 -filelevel OTA -filter r -airmass 11 -ra 1 -decl 2 -exp_type object -exp_time 0 -bg 11 -bg_stdev 1 -bg_mean_stdev 11 -alt 11 -az 11 -ccd_temp 45 -posang 11 -object dog -dateobs 2006-10-20T10:10:10Z -label foobar -tess_id moldyshoe $* || exit 1
     49# BIAS or OBJECT? $regtool -addprocessedexp -exp_id $exp_id2 -exp_name t11 -inst gpc -telescope ps1 -exp_tag batman.t11 -filelevel OTA -filter r -airmass 11 -ra 1 -decl 2 -exp_type bias -exp_time 0 -bg 11 -bg_stdev 1 -bg_mean_stdev 11 -alt 11 -az 11 -ccd_temp 45 -posang 11 -object dog -dateobs 2006-10-20T10:10:10Z -label foobar -tess_id moldyshoe $* || exit 1

  • trunk/ippTools/share/Makefile.am

    r18328 r18366  
    1111        chiptool_find_rawexp.sql \
    1212        chiptool_find_unprocessed_imfile.pl \
    13         chiptool_pendingcleanup.sql \
     13        chiptool_pendingcleanuprun.sql \
     14        chiptool_pendingcleanupimfile.sql \
    1415        chiptool_pendingimfile.sql \
    1516        chiptool_processedimfile.sql \
     17        chiptool_run.sql \
    1618        chiptool_revertprocessedimfile.sql \
    1719        chiptool_unmasked.sql \

  • trunk/ippTools/share/camtool_find_chip_id.sql

    r14227 r18366  
    2929        using(exp_id)
    3030    WHERE
    31         chipRun.state = 'stop') as Foo
     31        chipRun.state = 'full') as Foo

  • trunk/ippTools/share/camtool_find_pendingexp.sql

    r18029 r18366  
    2424        ON camRun.label = camMask.label
    2525    WHERE
    26         chipRun.state = 'stop'
     26        chipRun.state = 'full'
    2727        AND camRun.state = 'run'
    2828        AND camMask.label IS NULL

  • trunk/ippTools/share/camtool_queue_chip_id.sql

    r16170 r18366  
    1616    FROM chipRun
    1717    WHERE
    18         chipRun.state = 'stop'
     18        chipRun.state = 'full'
    1919        AND chipRun.chip_id = %lld

  • trunk/ippTools/share/chiptool_pendingimfile.sql

    r14065 r18366  
    2020    ON chipRun.label = chipMask.label
    2121WHERE
    22     chipRun.state = 'run'
     22    chipRun.state = 'new'
    2323    AND chipProcessedImfile.chip_id IS NULL
    2424    AND chipProcessedImfile.exp_id IS NULL

  • trunk/ippTools/share/flatcorr_completely_processed_chiprun.sql

    r15769 r18366  
    2626            AND rawImfile.class_id = chipProcessedImfile.class_id
    2727        WHERE
    28             chipRun.state = 'stop'
     28            chipRun.state = 'full'
    2929        GROUP BY
    3030            chipRun.chip_id,

  • trunk/ippTools/share/flatcorr_find_processedimfiles.sql

    r15755 r18366  
    1111WHERE
    1212    flatcorrRun.state = 'run'
    13     AND chipRun.state = 'stop'
     13    AND chipRun.state = 'new'
    1414

  • trunk/ippTools/share/flatcorr_pending.sql

    r15769 r18366  
    1515WHERE
    1616    flatcorrRun.state = 'run'
    17     AND chipRun.state = 'stop'
     17    AND chipRun.state = 'full'
    1818GROUP BY
    1919    chipRun.chip_id,

  • trunk/ippTools/src/Makefile.am

    r18336 r18366  
    7171        pxregister.c \
    7272        pxtag.c \
     73        pxtools.c \
    7374        pxtoolsErrorCodes.c \
    7475        pxtree.c \

  • trunk/ippTools/src/chiptool.c

    r18336 r18366  
    4545static bool unmaskedMode(pxConfig *config);
    4646static bool unblockMode(pxConfig *config);
    47 static bool pendingcleanupMode(pxConfig *config);
     47static bool pendingcleanuprunMode(pxConfig *config);
     48static bool pendingcleanupimfileMode(pxConfig *config);
    4849static bool donecleanupMode(pxConfig *config);
     50static bool runMode(pxConfig *config);
    4951
    5052static bool chipProcessedCompleteExp(pxConfig *config);
    … …  
    6769
    6870    switch (config->mode) {
    69         MODECASE(CHIPTOOL_MODE_DEFINEBYQUERY,                   definebyqueryMode);
     71        MODECASE(CHIPTOOL_MODE_DEFINEBYQUERY,           definebyqueryMode);
    7072        MODECASE(CHIPTOOL_MODE_UPDATERUN,               updaterunMode);
    7173        MODECASE(CHIPTOOL_MODE_PENDINGIMFILE,           pendingimfileMode);
    … …  
    7880        MODECASE(CHIPTOOL_MODE_UNMASKED,                unmaskedMode);
    7981        MODECASE(CHIPTOOL_MODE_UNBLOCK,                 unblockMode);
    80         MODECASE(CHIPTOOL_MODE_PENDINGCLEANUP,          pendingcleanupMode);
     82        MODECASE(CHIPTOOL_MODE_PENDINGCLEANUPRUN,       pendingcleanuprunMode);
     83        MODECASE(CHIPTOOL_MODE_PENDINGCLEANUPIMFILE,    pendingcleanupimfileMode);
    8184        MODECASE(CHIPTOOL_MODE_DONECLEANUP,             donecleanupMode);
     85        MODECASE(CHIPTOOL_MODE_RUN,                     runMode);
    8286        default:
    8387            psAbort("invalid option (this should not happen)");
    … …  
    835839
    836840
    837 static bool pendingcleanupMode(pxConfig *config)
     841static bool pendingcleanuprunMode(pxConfig *config)
    838842{
    839843    PS_ASSERT_PTR_NON_NULL(config, NULL);
    … …  
    845849    PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
    846850
    847     psString query = pxDataGet("chiptool_pendingcleanup.sql");
     851    psString query = pxDataGet("chiptool_pendingcleanuprun.sql");
    848852    if (!query) {
    849853        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    … …  
    884888
    885889    // negative simple so the default is true
    886     if (!ippdbPrintMetadatas(stdout, output, "chipPendingCleanup", !simple)) {
     890    if (!ippdbPrintMetadatas(stdout, output, "chipPendingCleanupRun", !simple)) {
    887891        psError(PS_ERR_UNKNOWN, false, "failed to print array");
    888892        psFree(output);
    … …  
    896900
    897901
    898 static bool donecleanupMode(pxConfig *config)
     902static bool pendingcleanupimfileMode(pxConfig *config)
    899903{
    900904    PS_ASSERT_PTR_NON_NULL(config, NULL);
    901905
     906    PXOPT_LOOKUP_S64(chip_id, config->args, "-chip_id", false, false);
    902907    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    903908    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    904909
    905910    psMetadata *where = psMetadataAlloc();
     911    if (chip_id) {
     912        PXOPT_COPY_S64(config->args, where, "-chip_id", "chip_id", "==");
     913    }
    906914    PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
    907915
    908     psString query = pxDataGet("chiptool_donecleanup.sql");
     916    psString query = pxDataGet("chiptool_pendingcleanupimfile.sql");
    909917    if (!query) {
    910918        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    … …  
    945953
    946954    // negative simple so the default is true
     955    if (!ippdbPrintMetadatas(stdout, output, "chipPendingCleanupImfile", !simple)) {
     956        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     957        psFree(output);
     958        return false;
     959    }
     960
     961    psFree(output);
     962
     963    return true;
     964}
     965
     966
     967static bool donecleanupMode(pxConfig *config)
     968{
     969    PS_ASSERT_PTR_NON_NULL(config, NULL);
     970
     971    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     972    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     973
     974    psMetadata *where = psMetadataAlloc();
     975    PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     976
     977    psString query = pxDataGet("chiptool_donecleanup.sql");
     978    if (!query) {
     979        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     980        return false;
     981    }
     982
     983    if (where && psListLength(where->list)) {
     984        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     985        psStringAppend(&query, " AND %s", whereClause);
     986        psFree(whereClause);
     987    }
     988    psFree(where);
     989
     990    // treat limit == 0 as "no limit"
     991    if (limit) {
     992        psString limitString = psDBGenerateLimitSQL(limit);
     993        psStringAppend(&query, " %s", limitString);
     994        psFree(limitString);
     995    }
     996
     997    if (!p_psDBRunQuery(config->dbh, query)) {
     998        psError(PS_ERR_UNKNOWN, false, "database error");
     999        psFree(query);
     1000        return false;
     1001    }
     1002    psFree(query);
     1003
     1004    psArray *output = p_psDBFetchResult(config->dbh);
     1005    if (!output) {
     1006        psError(PS_ERR_UNKNOWN, false, "database error");
     1007        return false;
     1008    }
     1009    if (!psArrayLength(output)) {
     1010        psTrace("chiptool", PS_LOG_INFO, "no rows found");
     1011        psFree(output);
     1012        return true;
     1013    }
     1014
     1015    // negative simple so the default is true
     1016    if (!ippdbPrintMetadatas(stdout, output, "chipDoneCleanup", !simple)) {
     1017        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1018        psFree(output);
     1019        return false;
     1020    }
     1021
     1022    psFree(output);
     1023
     1024    return true;
     1025}
     1026
     1027
     1028static bool runMode(pxConfig *config)
     1029{
     1030    PS_ASSERT_PTR_NON_NULL(config, NULL);
     1031
     1032    PXOPT_LOOKUP_STR(state, config->args, "-state", true, false);
     1033    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1034    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1035
     1036    // make sure that the state string is valid
     1037    if (!pxIsValidState(state)) {
     1038        psError(PXTOOLS_ERR_DATA, false, "%s is not a valid state", state);
     1039        return false;
     1040    }
     1041
     1042    psMetadata *where = psMetadataAlloc();
     1043    PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     1044    PXOPT_COPY_STR(config->args, where, "-state", "state", "==");
     1045
     1046    psString query = pxDataGet("chiptool_run.sql");
     1047    if (!query) {
     1048        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1049        return false;
     1050    }
     1051
     1052    if (where && psListLength(where->list)) {
     1053        psString whereClause = psDBGenerateWhereSQL(where, NULL);
     1054        psStringAppend(&query, " %s", whereClause);
     1055        psFree(whereClause);
     1056    }
     1057    psFree(where);
     1058
     1059    // treat limit == 0 as "no limit"
     1060    if (limit) {
     1061        psString limitString = psDBGenerateLimitSQL(limit);
     1062        psStringAppend(&query, " %s", limitString);
     1063        psFree(limitString);
     1064    }
     1065
     1066    if (!p_psDBRunQuery(config->dbh, query)) {
     1067        psError(PS_ERR_UNKNOWN, false, "database error");
     1068        psFree(query);
     1069        return false;
     1070    }
     1071    psFree(query);
     1072
     1073    psArray *output = p_psDBFetchResult(config->dbh);
     1074    if (!output) {
     1075        psError(PS_ERR_UNKNOWN, false, "database error");
     1076        return false;
     1077    }
     1078    if (!psArrayLength(output)) {
     1079        psTrace("chiptool", PS_LOG_INFO, "no rows found");
     1080        psFree(output);
     1081        return true;
     1082    }
     1083
     1084    // negative simple so the default is true
    9471085    if (!ippdbPrintMetadatas(stdout, output, "chipDoneCleanup", !simple)) {
    9481086        psError(PS_ERR_UNKNOWN, false, "failed to print array");
    … …  
    9921130        chipRunRow *chipRun = chipRunObjectFromMetadata(row);
    9931131        // set chipRun.state to 'stop'
    994         if (!pxchipRunSetState(config, chipRun->chip_id, "stop")) {
     1132        if (!pxchipRunSetState(config, chipRun->chip_id, "full")) {
    9951133            psError(PS_ERR_UNKNOWN, false, "failed to change chipRun.state for chip_id: %" PRId64, chipRun->chip_id);
    9961134            psFree(chipRun);

  • trunk/ippTools/src/chiptool.h

    r18093 r18366  
    3737    CHIPTOOL_MODE_UNBLOCK,
    3838    CHIPTOOL_MODE_RETRYPROCESSEDIMFILE,
    39     CHIPTOOL_MODE_PENDINGCLEANUP,
     39    CHIPTOOL_MODE_PENDINGCLEANUPRUN,
     40    CHIPTOOL_MODE_PENDINGCLEANUPIMFILE,
    4041    CHIPTOOL_MODE_DONECLEANUP,
     42    CHIPTOOL_MODE_RUN
    4143} chiptoolMode;
    4244

  • trunk/ippTools/src/chiptoolConfig.c

    r18336 r18366  
    4545
    4646    // -definebyquery
    47     psMetadata *queueArgs = psMetadataAlloc();
     47    psMetadata *definebyqueryArgs = psMetadataAlloc();
     48
    4849    // XXX need to allow multiple exp_ids
    49     psMetadataAddS64(queueArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exp_id", 0);
    50     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-exp_name",  0,            "search by exp_name", NULL);
    51     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-inst",  0,            "search for camera", NULL);
    52     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-telescope",  0,            "search for telescope", NULL);
    53     psMetadataAddTime(queueArgs, PS_LIST_TAIL, "-dateobs_begin", 0,            "search for exposures by time (>=)", NULL);
    54     psMetadataAddTime(queueArgs, PS_LIST_TAIL, "-dateobs_end", 0,            "search for exposures by time (<)", NULL);
    55     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-exp_tag",  0,            "search by exp_tag", NULL);
    56     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-exp_type",  0,            "search by exp_type", "object");
    57     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-filelevel",  0,            "search by filelevel", NULL);
    58     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-reduction",  0,            "search by reduction class", NULL);
    59     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-filter",  0,            "search for filter", NULL);
    60     psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-airmass_min",  0,            "define min airmass", NAN);
    61     psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-airmass_max",  0,            "define max airmass", NAN);
    62     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-ra_min",  0,            "define min", NAN);
    63     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-ra_max",  0,            "define max", NAN);
    64     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-decl_min",  0,            "define min", NAN);
    65     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-decl_max",  0,            "define max", NAN);
    66     psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-exp_time_min",  0,            "define min", NAN);
    67     psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-exp_time_max",  0,            "define max", NAN);
    68     psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-sat_pixel_frac_min",  0,            "define max fraction of saturated pixels", NAN);
    69     psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-sat_pixel_frac_max",  0,            "define min fraction of saturated pixels", NAN);
    70     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-bg_min",  0,            "define max", NAN);
    71     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-bg_max",  0,            "define max", NAN);
    72     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-bg_stdev_min",  0,            "define max", NAN);
    73     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-bg_stdev_max",  0,            "define max", NAN);
    74     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-bg_mean_stdev_min",  0,            "define max", NAN);
    75     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-bg_mean_stdev_max",  0,            "define max", NAN);
    76     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-alt_min",  0,            "define min", NAN);
    77     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-alt_max",  0,            "define max", NAN);
    78     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-az_min",  0,            "define min", NAN);
    79     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-az_max",  0,            "define max", NAN);
    80     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-ccd_temp_min",  0,            "define min ccd tempature", NAN);
    81     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-ccd_temp_max",  0,            "define max ccd tempature", NAN);
    82     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-posang_min",  0,            "define min rotator position angle", NAN);
    83     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-posang_max",  0,            "define max rotator position angle", NAN);
    84     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-object",  0,            "search by exposure object", NULL);
    85     psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-solang_min",  0,            "define min solar angle", NAN);
    86     psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-solang_max",  0,            "define max solar angle", NAN);
    87     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-comment",     0,        "search by comment field (LIKE comparison)", NULL);
    88 
    89     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_workdir",  0,            "define workdir", NULL);
    90     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_label",  0,            "define label", NULL);
    91     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_reduction",  0,            "define reduction class", NULL);
    92     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_expgroup",  0,            "define exposure group", NULL);
    93     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_dvodb",  0,            "define DVO db", NULL);
    94     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_tess_id",  0,            "define tessellation identifier", NULL);
    95     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_end_stage",  0,            "define end stage", NULL);
    96     psMetadataAddBool(queueArgs, PS_LIST_TAIL, "-pretend",  0,            "do not actually modify the database", false);
    97     psMetadataAddBool(queueArgs, PS_LIST_TAIL, "-all",  0,            "allow everything to be queued without search terms", false);
    98 
     50    psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exp_id", 0);
     51    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-exp_name",  0,            "search by exp_name", NULL);
     52    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-inst",  0,            "search for camera", NULL);
     53    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-telescope",  0,            "search for telescope", NULL);
     54    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-dateobs_begin", 0,            "search for exposures by time (>=)", NULL);
     55    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-dateobs_end", 0,            "search for exposures by time (<)", NULL);
     56    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-exp_tag",  0,            "search by exp_tag", NULL);
     57    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-exp_type",  0,            "search by exp_type", "object");
     58    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-filelevel",  0,            "search by filelevel", NULL);
     59    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-reduction",  0,            "search by reduction class", NULL);
     60    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-filter",  0,            "search for filter", NULL);
     61    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-airmass_min",  0,            "define min airmass", NAN);
     62    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-airmass_max",  0,            "define max airmass", NAN);
     63    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-ra_min",  0,            "define min", NAN);
     64    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-ra_max",  0,            "define max", NAN);
     65    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-decl_min",  0,            "define min", NAN);
     66    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-decl_max",  0,            "define max", NAN);
     67    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-exp_time_min",  0,            "define min", NAN);
     68    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-exp_time_max",  0,            "define max", NAN);
     69    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-sat_pixel_frac_min",  0,            "define max fraction of saturated pixels", NAN);
     70    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-sat_pixel_frac_max",  0,            "define min fraction of saturated pixels", NAN);
     71    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-bg_min",  0,            "define max", NAN);
     72    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-bg_max",  0,            "define max", NAN);
     73    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-bg_stdev_min",  0,            "define max", NAN);
     74    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-bg_stdev_max",  0,            "define max", NAN);
     75    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-bg_mean_stdev_min",  0,            "define max", NAN);
     76    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-bg_mean_stdev_max",  0,            "define max", NAN);
     77    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-alt_min",  0,            "define min", NAN);
     78    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-alt_max",  0,            "define max", NAN);
     79    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-az_min",  0,            "define min", NAN);
     80    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-az_max",  0,            "define max", NAN);
     81    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-ccd_temp_min",  0,            "define min ccd tempature", NAN);
     82    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-ccd_temp_max",  0,            "define max ccd tempature", NAN);
     83    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-posang_min",  0,            "define min rotator position angle", NAN);
     84    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-posang_max",  0,            "define max rotator position angle", NAN);
     85    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-object",  0,            "search by exposure object", NULL);
     86    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-solang_min",  0,            "define min solar angle", NAN);
     87    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-solang_max",  0,            "define max solar angle", NAN);
     88    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-comment",     0,        "search by comment field (LIKE comparison)", NULL);
     89
     90    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_workdir",  0,            "define workdir", NULL);
     91    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_label",  0,            "define label", NULL);
     92    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_reduction",  0,            "define reduction class", NULL);
     93    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_expgroup",  0,            "define exposure group", NULL);
     94    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_dvodb",  0,            "define DVO db", NULL);
     95    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_tess_id",  0,            "define tessellation identifier", NULL);
     96    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_end_stage",  0,            "define end stage", NULL);
     97    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-pretend",  0,            "do not actually modify the database", false);
     98    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-all",  0,            "allow everything to be queued without search terms", false);
    9999
    100100    // -updaterun
    … …  
    273273    psMetadataAddStr(unblockArgs, PS_LIST_TAIL, "-label",  0,            "name of a label to unmask (required)", NULL);
    274274
    275     // -pendingcleanup
    276     psMetadata *pendingcleanupArgs = psMetadataAlloc();
    277     psMetadataAddStr(pendingcleanupArgs, PS_LIST_TAIL, "-label",  0,            "list blocks for specified label", NULL);
    278     psMetadataAddBool(pendingcleanupArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    279     psMetadataAddU64(pendingcleanupArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     275    // -pendingcleanuprun
     276    psMetadata *pendingcleanuprunArgs = psMetadataAlloc();
     277    psMetadataAddStr(pendingcleanuprunArgs, PS_LIST_TAIL, "-label",  0,            "list blocks for specified label", NULL);
     278    psMetadataAddBool(pendingcleanuprunArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     279    psMetadataAddU64(pendingcleanuprunArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     280
     281    // -pendingcleanupifmile
     282    psMetadata *pendingcleanupimfileArgs = psMetadataAlloc();
     283    psMetadataAddStr(pendingcleanupimfileArgs, PS_LIST_TAIL, "-label",  0,            "list blocks for specified label", NULL);
     284    psMetadataAddS64(pendingcleanupimfileArgs, PS_LIST_TAIL, "-chip_id", 0,
     285        "search by chip ID", 0);
     286    psMetadataAddStr(pendingcleanupimfileArgs, PS_LIST_TAIL, "-exp_id",                 0,            "search by exp_id", NULL);
     287    psMetadataAddBool(pendingcleanupimfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     288    psMetadataAddU64(pendingcleanupimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    280289
    281290    // -doneclenaup
    … …  
    285294    psMetadataAddU64(donecleanupArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    286295
     296    // -run
     297    psMetadata *runArgs = psMetadataAlloc();
     298    psMetadataAddStr(runArgs, PS_LIST_TAIL, "-label",  0,       "search by label", NULL);
     299    psMetadataAddBool(runArgs, PS_LIST_TAIL, "-simple",  0,     "use the simple output format", false);
     300    psMetadataAddU64(runArgs, PS_LIST_TAIL, "-limit",  0,       "limit result set to N items", 0);
     301    psMetadataAddStr(runArgs, PS_LIST_TAIL, "-state", 0,        "search by state (required)", NULL);
     302
    287303    psMetadata *argSets = psMetadataAlloc();
    288304    psMetadata *modes = psMetadataAlloc();
    289305
    290     PXOPT_ADD_MODE("-definebyquery",                "create runs from raw exposures",
    291         CHIPTOOL_MODE_DEFINEBYQUERY,                queueArgs);
     306    PXOPT_ADD_MODE("-definebyquery",        "create runs from raw exposures",
     307        CHIPTOOL_MODE_DEFINEBYQUERY,        definebyqueryArgs);
    292308    PXOPT_ADD_MODE("-updaterun",            "change chip run properties",
    293309        CHIPTOOL_MODE_UPDATERUN,            updaterunArgs);
    … …  
    310326    PXOPT_ADD_MODE("-unblock",              "remove a label block",
    311327        CHIPTOOL_MODE_UNBLOCK,              unblockArgs);
    312     PXOPT_ADD_MODE("-pendingcleanup",       "show runs that need to be cleaned up",
    313         CHIPTOOL_MODE_PENDINGCLEANUP,       pendingcleanupArgs);
     328    PXOPT_ADD_MODE("-pendingcleanuprun",    "show runs that need to be cleaned up",
     329        CHIPTOOL_MODE_PENDINGCLEANUPRUN,    pendingcleanuprunArgs);
     330    PXOPT_ADD_MODE("-pendingcleanupimfile", "show runs that need to be cleaned up",
     331        CHIPTOOL_MODE_PENDINGCLEANUPIMFILE, pendingcleanupimfileArgs);
    314332    PXOPT_ADD_MODE("-donecleanup",          "show runs that have been cleaned",
    315333        CHIPTOOL_MODE_DONECLEANUP,          donecleanupArgs);
     334    PXOPT_ADD_MODE("-run",                  "show runs",
     335        CHIPTOOL_MODE_RUN,                  runArgs);
    316336
    317337    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {

  • trunk/ippTools/src/faketoolConfig.c

    r18336 r18366  
    231231            "allow everything to be queued without search terms", false);
    232232
     233    // -pendingexp
     234    psMetadata *pendingexpArgs = psMetadataAlloc();
     235    psMetadataAddS64(pendingexpArgs, PS_LIST_TAIL, "-cam_id", 0,
     236            "search by camtool ID", 0);
     237    psMetadataAddS64(pendingexpArgs, PS_LIST_TAIL, "-chip_id", 0,
     238            "search by chiptool ID", 0);
     239    psMetadataAddU64(pendingexpArgs, PS_LIST_TAIL, "-limit",  0,
     240            "limit result set to N items", 0);
     241    psMetadataAddBool(pendingexpArgs, PS_LIST_TAIL, "-simple", 0,
     242            "use the simple output format", false);
    233243
    234244    // -pendingexp

  • trunk/ippTools/src/pxchip.c

    r17161 r18366  
    3535
    3636    // check that state is a valid string value
    37     if (!(
    38             (strncmp(state, "run", 4) == 0)
    39             || (strncmp(state, "stop", 5) == 0)
    40             || (strncmp(state, "reg", 4) == 0)
    41         )
    42     ) {
    43         psError(PS_ERR_UNKNOWN, false,
    44                 "invalid chipRun state: %s", state);
     37    if (!pxIsValidState(state)) {
     38        psError(PS_ERR_UNKNOWN, false, "invalid chipRun state: %s", state);
    4539        return false;
    4640    }
    … …  
    6357
    6458    // check that state is a valid string value
    65     if (!(
    66             (strncmp(state, "run", 4) == 0)
    67             || (strncmp(state, "stop", 5) == 0)
    68             || (strncmp(state, "reg", 4) == 0)
    69         )
    70     ) {
    71         psError(PS_ERR_UNKNOWN, false,
    72                 "invalid chipRun state: %s", state);
     59    if (!pxIsValidState(state)) {
     60        psError(PS_ERR_UNKNOWN, false, "invalid chipRun state: %s", state);
    7361        return false;
    7462    }
     63
    7564
    7665    psString query = psStringCopy("UPDATE chipRun JOIN rawExp USING(exp_id) SET state = '%s'");
    … …  
    151140            0x0, // chip_id
    152141            exp_id,
    153             "run",      // state               
     142            "new",      // state               
    154143            workdir,
    155144            "dirty",    // workdir_state
    … …  
    167156    return psDBLastInsertID(config->dbh);
    168157}
     158

  • trunk/ippTools/src/pxchip.h

    r17161 r18366  
    4040                         const char *end_stage);
    4141
     42
    4243#endif // PXCHIP_H

  • trunk/ippTools/src/pxtools.h

    r18336 r18366  
    4343# define PXTOOL_MODE_NONE 0x0
    4444
    45 bool pxCreateTables (pxConfig *config);
    46 bool pxDeleteTables (pxConfig *config);
     45bool pxIsValidState(const char *state);
    4746
    4847bool pxSetFaultCode(psDB *dbh, const char *tableName, psMetadata *where, psS16 code);
Note: See TracChangeset for help on using the changeset viewer.