IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 32960


Ignore:
Timestamp:
Dec 14, 2011, 2:58:59 PM (14 years ago)
Author:
bills
Message:

first draft of changes to staticskytool to support skycalRun (the sky calibration stage)

Location:
trunk/ippTools
Files:
2 added
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/ippTools/share/Makefile.am

    r32832 r32960  
    385385        staticskytool_definebyquery_select_by_dg.sql \
    386386        staticskytool_definebyquery_inputs.sql \
     387        staticskytool_defineskycalrun.sql \
     388        staticskytool_pendingskycalrun.sql \
    387389        staticskytool_export_run.sql \
    388390        staticskytool_export_input.sql \

  • trunk/ippTools/share/pxadmin_create_tables.sql

    r32771 r32960  
    20352035) ENGINE=innodb DEFAULT CHARSET=latin1;
    20362036
     2037CREATE TABLE skycalRun (
     2038      skycal_id BIGINT AUTO_INCREMENT, -- unique identifier
     2039      sky_id BIGINT,
     2040      stack_id BIGINT,
     2041      state VARCHAR(64) NOT NULL,  -- state of run (new, full, etc.)
     2042      workdir VARCHAR(255) NOT NULL, -- working directory
     2043      label VARCHAR(64),             -- processing label
     2044      data_group VARCHAR(64),        -- group for data
     2045      dist_group VARCHAR(64),        -- group for distribution
     2046      reduction VARCHAR(64),         -- reduction class (for altering recipe)
     2047      registered TIMESTAMP DEFAULT CURRENT_TIMESTAMP, -- time run was registered
     2048      note VARCHAR(255),             -- note
     2049      PRIMARY KEY(skycal_id),
     2050      KEY(state),
     2051      KEY(label),
     2052      KEY(data_group),
     2053      KEY(dist_group),
     2054      KEY(sky_id),
     2055      KEY(stack_id),
     2056      FOREIGN KEY(sky_id) REFERENCES staticskyRun(sky_id),
     2057      FOREIGN KEY(stack_id) REFERENCES stackRun(stack_id)
     2058) ENGINE=innodb DEFAULT CHARSET=latin1;
     2059
     2060-- Result of sky calibration analysis
     2061CREATE TABLE skycalResult (
     2062      skycal_id BIGINT,
     2063      path_base VARCHAR(255) NOT NULL,
     2064      dtime_script FLOAT,
     2065      dtime_astrom FLOAT,
     2066      sigma_ra FLOAT,
     2067      sigma_dec FLOAT,
     2068      n_astrom INT,
     2069      zpt_obs FLOAT,
     2070      zpt_stdev FLOAT,
     2071      quality SMALLINT NOT NULL,
     2072      hostname VARCHAR(64) NOT NULL,
     2073      fault SMALLINT NOT NULL,
     2074      PRIMARY KEY(skycal_id),
     2075      KEY(fault),
     2076      KEY(quality),
     2077      FOREIGN KEY(skycal_id) REFERENCES skycalRun(skycal_id)
     2078) ENGINE=innodb DEFAULT CHARSET=latin1;
     2079
     2080
    20372081-- This comment line is here to avoid empty query error.
    20382082-- Another way to avoid that problem is to omit the semicolon above but I think that is untidy.

  • trunk/ippTools/share/pxadmin_drop_tables.sql

    r32604 r32960  
    8686DROP TABLE IF EXISTS publishDone;
    8787DROP TABLE IF EXISTS pstampDependent;
     88DROP TABLE IF EXISTS pstampFile;
    8889DROP TABLE IF EXISTS staticskyInput;
    8990DROP TABLE IF EXISTS staticskyResult;
    … …  
    105106DROP TABLE IF EXISTS vpProcessedCell;
    106107DROP TABLE IF EXISTS vpRun;
     108DROP TABLE IF EXISTS skycalRun;
     109DROP TABLE IF EXISTS skycalResult;
    107110
    108111SET FOREIGN_KEY_CHECKS=1

  • trunk/ippTools/src/staticskytool.c

    r31690 r32960  
    4242static bool importrunMode(pxConfig *config);
    4343
     44static bool defineskycalrunMode(pxConfig *config);
     45static bool updateskycalrunMode(pxConfig *config);
     46static bool pendingskycalrunMode(pxConfig *config);
     47
    4448static bool setstaticskyRunState(pxConfig *config, psS64 sky_id, const char *state);
    4549
    … …  
    7276        MODECASE(STATICSKYTOOL_MODE_EXPORTRUN,         exportrunMode);
    7377        MODECASE(STATICSKYTOOL_MODE_IMPORTRUN,         importrunMode);
     78        MODECASE(STATICSKYTOOL_MODE_DEFINESKYCALRUN,   defineskycalrunMode);
     79        MODECASE(STATICSKYTOOL_MODE_UPDATESKYCALRUN,   updateskycalrunMode);
     80        MODECASE(STATICSKYTOOL_MODE_PENDINGSKYCALRUN,  pendingskycalrunMode);
    7481        default:
    7582            psAbort("invalid option (this should not happen)");
    … …  
    97104{
    98105    PS_ASSERT_PTR_NON_NULL(config, false);
    99 
    100     // required options
    101     PXOPT_LOOKUP_STR(workdir, config->args, "-set_workdir", true, false);
     106    PXOPT_LOOKUP_STR(workdir,     config->args, "-set_workdir", true, false);
     107    PXOPT_LOOKUP_STR(label,       config->args, "-set_label", true, false);
    102108
    103109    // optional
    104     PXOPT_LOOKUP_STR(label,       config->args, "-set_label", true, false);
    105110    PXOPT_LOOKUP_STR(data_group,  config->args, "-set_data_group", false, false);
    106111    PXOPT_LOOKUP_STR(dist_group,  config->args, "-set_dist_group", false, false);
    … …  
    111116    psMetadata *whereMD = psMetadataAlloc();
    112117
     118    PXOPT_COPY_S64(config->args, whereMD, "-select_stack_id",      "stackRun.stack_id",         "==");
    113119    PXOPT_COPY_STR(config->args, whereMD, "-select_skycell_id",    "stackRun.skycell_id",       "==");
    114120    PXOPT_COPY_STR(config->args, whereMD, "-select_tess_id",       "stackRun.tess_id",          "==");
    … …  
    978984# endif
    979985
     986static bool defineskycalrunMode(pxConfig *config)
     987{
     988    PS_ASSERT_PTR_NON_NULL(config, false);
     989
     990    // required options
     991    // none required. We get workdir, etc from staticskyRun if not provided
     992
     993    // optional
     994    PXOPT_LOOKUP_STR(label,       config->args, "-set_label", false, false);
     995    PXOPT_LOOKUP_STR(workdir,     config->args, "-set_workdir", false, false);
     996    PXOPT_LOOKUP_STR(data_group,  config->args, "-set_data_group", false, false);
     997    PXOPT_LOOKUP_STR(dist_group,  config->args, "-set_dist_group", false, false);
     998    PXOPT_LOOKUP_STR(reduction,   config->args, "-set_reduction", false, false);
     999    PXOPT_LOOKUP_STR(note,        config->args, "-set_note", false, false);
     1000    PXOPT_LOOKUP_TIME(registered, config->args, "-set_registered", false, false);
     1001
     1002    psMetadata *whereMD = psMetadataAlloc();
     1003
     1004    PXOPT_COPY_S64(config->args, whereMD, "-select_sky_id",        "staticskyRun.sky_id",       "==");
     1005    PXOPT_COPY_S64(config->args, whereMD, "-select_stack_id",      "stackRun.stack_id",         "==");
     1006    PXOPT_COPY_STR(config->args, whereMD, "-select_skycell_id",    "stackRun.skycell_id",       "==");
     1007    PXOPT_COPY_STR(config->args, whereMD, "-select_tess_id",       "stackRun.tess_id",          "==");
     1008    PXOPT_COPY_F32(config->args, whereMD, "-select_good_frac_min", "stackSumSkyfile.good_frac", ">=");
     1009    pxAddLabelSearchArgs(config, whereMD, "-select_label",         "stackRun.label",            "LIKE");
     1010    pxAddLabelSearchArgs(config, whereMD, "-select_data_group",    "stackRun.data_group",       "LIKE");
     1011    pxAddLabelSearchArgs(config, whereMD, "-select_filter",        "stackRun.filter",           "LIKE");
     1012
     1013    PXOPT_LOOKUP_BOOL(rerun, config->args, "-rerun", false);
     1014    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1015    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
     1016
     1017    psString query = pxDataGet("staticskytool_defineskycalrun.sql");
     1018    if (!query) {
     1019        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1020        psFree(whereMD);
     1021        return false;
     1022    }
     1023
     1024    if (!psListLength(whereMD->list)) {
     1025        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     1026        psFree(whereMD);
     1027        return false;
     1028    }
     1029
     1030    psString whereClause = psDBGenerateWhereConditionSQL(whereMD, NULL);
     1031    psStringAppend(&query, "\nAND %s", whereClause);
     1032    psFree(whereClause);
     1033    psFree(whereMD);
     1034
     1035    if (!rerun) {
     1036        if (label)  {
     1037            psStringAppend(&query, "\nAND (skycalRun.label IS NULL OR skycalRun.label = '%s')", label);
     1038        }
     1039        psStringAppend(&query, "\nAND skycal_id IS NULL");
     1040    }
     1041
     1042    if (!p_psDBRunQuery(config->dbh, query)) {
     1043        psError(PS_ERR_UNKNOWN, false, "database error");
     1044        psFree(query);
     1045        return false;
     1046    }
     1047    psFree(query);
     1048
     1049    // we now have a list of (tess_id, skycell_id) that (potentially) meet out needs
     1050    // we now need to loop over all of these and for each pair, select the best set of
     1051    // inputs
     1052
     1053    psArray *output = p_psDBFetchResult(config->dbh);
     1054    if (!output) {
     1055        psErrorCode err = psErrorCodeLast();
     1056        switch (err) {
     1057            case PS_ERR_DB_CLIENT:
     1058                psError(PXTOOLS_ERR_SYS, false, "database error");
     1059            case PS_ERR_DB_SERVER:
     1060                psError(PXTOOLS_ERR_PROG, false, "database error");
     1061            default:
     1062                psError(PXTOOLS_ERR_PROG, false, "unknown error");
     1063        }
     1064        return false;
     1065    }
     1066    if (!psArrayLength(output)) {
     1067        psWarning("staticskytool: no rows found");
     1068        psFree(output);
     1069        return true;
     1070    }
     1071    if (pretend) {
     1072        // negative simple so the default is true
     1073        if (!ippdbPrintMetadatas(stdout, output, "skycalRun", !simple)) {
     1074            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1075            psFree(output);
     1076            return false;
     1077        }
     1078        psFree(output);
     1079        return true;
     1080    }
     1081
     1082    for (long i = 0; i < output->n; i++) {
     1083        psMetadata *row = output->data[i]; // Row from select
     1084        bool status;
     1085
     1086        psS64 sky_id = psMetadataLookupS64(&status, row, "sky_id");
     1087        psS64 stack_id = psMetadataLookupS64(&status, row, "stack_id");
     1088        psString sky_workdir = psMetadataLookupStr(&status, row, "workdir");
     1089        psString sky_label =  psMetadataLookupStr(&status, row, "label");
     1090        psString sky_data_group =  psMetadataLookupStr(&status, row, "data_group");
     1091
     1092        // create a staticskyRun
     1093        if (!skycalRunInsert(config->dbh,
     1094                                0x0,         // skycal_id
     1095                                sky_id,
     1096                                stack_id,
     1097                                "new",       // state
     1098                                workdir ? workdir : sky_workdir,
     1099                                label ? label : sky_label,
     1100                                data_group ? data_group : sky_data_group,
     1101                                dist_group,
     1102                                reduction,
     1103                                registered,
     1104                                note
     1105                )
     1106            ) {
     1107            psError(PS_ERR_UNKNOWN, false, "database error");
     1108            psFree(output);
     1109            return false;
     1110        }
     1111
     1112    }
     1113    psFree(output);
     1114    return true;
     1115}
     1116
     1117static bool updateskycalrunMode(pxConfig *config)
     1118{
     1119#ifdef notyet
     1120    PS_ASSERT_PTR_NON_NULL(config, false);
     1121
     1122    psMetadata *where = psMetadataAlloc();
     1123    PXOPT_COPY_S64(config->args, where, "-sky_id",  "sky_id",   "==");
     1124    PXOPT_COPY_STR(config->args, where, "-label",   "label",    "==");
     1125    PXOPT_COPY_STR(config->args, where, "-state",   "state",    "==");
     1126    if (!psListLength(where->list)) {
     1127        psFree(where);
     1128        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     1129        return false;
     1130    }
     1131
     1132    psString query = psStringCopy("UPDATE staticskyRun");
     1133
     1134    // pxUpdateRun gets parameters from config->args and updates
     1135    bool result = pxUpdateRun(config, where, &query, "staticskyRun", "sky_id", "staticskyResult", true, false);
     1136    psFree(query);
     1137    psFree(where);
     1138
     1139    return result;
     1140#endif
     1141    return false;
     1142}
     1143static bool pendingskycalrunMode(pxConfig *config)
     1144{
     1145    PS_ASSERT_PTR_NON_NULL(config, false);
     1146
     1147    psMetadata *whereMD = psMetadataAlloc();
     1148    PXOPT_COPY_S64(config->args, whereMD, "-skycal_id", "skycal_id", "==");
     1149    PXOPT_COPY_S64(config->args, whereMD, "-sky_id", "sky_id", "==");
     1150    pxAddLabelSearchArgs (config, whereMD, "-label", "skycalRun.label", "==");
     1151    PXOPT_COPY_STR(config->args, whereMD, "-filter", "stackRun.filter", "LIKE");
     1152
     1153    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1154    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1155
     1156    psString query = pxDataGet("staticskytool_pendingskycalrun.sql");
     1157    if (!query) {
     1158        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1159        return false;
     1160    }
     1161
     1162    if (!psListLength(whereMD->list)) {
     1163        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     1164        psFree(whereMD);
     1165        return false;
     1166    }
     1167
     1168    psString whereClause = psDBGenerateWhereConditionSQL(whereMD, NULL);
     1169    psStringAppend(&query, "\n AND %s", whereClause);
     1170    psFree(whereClause);
     1171    psFree(whereMD);
     1172
     1173//    psStringAppend(&query, "\n GROUP by skycal_id");
     1174
     1175    // treat limit == 0 as "no limit"
     1176    if (limit) {
     1177        psString limitString = psDBGenerateLimitSQL(limit);
     1178        psStringAppend(&query, "\n%s", limitString);
     1179        psFree(limitString);
     1180    }
     1181
     1182    // the where clause is required and matches the WHERE hook format string
     1183    if (!p_psDBRunQuery(config->dbh, query)) {
     1184        psError(PS_ERR_UNKNOWN, false, "database error");
     1185        psFree(query);
     1186        return false;
     1187    }
     1188    psFree(query);
     1189
     1190    psArray *output = p_psDBFetchResult(config->dbh);
     1191    if (!output) {
     1192        psErrorCode err = psErrorCodeLast();
     1193        switch (err) {
     1194            case PS_ERR_DB_CLIENT:
     1195                psError(PXTOOLS_ERR_SYS, false, "database error");
     1196            case PS_ERR_DB_SERVER:
     1197                psError(PXTOOLS_ERR_PROG, false, "database error");
     1198            default:
     1199                psError(PXTOOLS_ERR_PROG, false, "unknown error");
     1200        }
     1201
     1202        return false;
     1203    }
     1204    if (!psArrayLength(output)) {
     1205        psTrace("staticskytool", PS_LOG_INFO, "no rows found");
     1206        psFree(output);
     1207        return true;
     1208    }
     1209
     1210    if (psArrayLength(output)) {
     1211        // negative simple so the default is true
     1212        if (!ippdbPrintMetadatas(stdout, output, "pendingskycalRun", !simple)) {
     1213            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1214            psFree(output);
     1215            return false;
     1216        }
     1217    }
     1218
     1219    psFree(output);
     1220    return true;
     1221}

  • trunk/ippTools/src/staticskytool.h

    r27546 r32960  
    3434    STATICSKYTOOL_MODE_UPDATERESULT,
    3535    STATICSKYTOOL_MODE_EXPORTRUN,
    36     STATICSKYTOOL_MODE_IMPORTRUN
     36    STATICSKYTOOL_MODE_IMPORTRUN,
     37
     38    STATICSKYTOOL_MODE_DEFINESKYCALRUN,
     39    STATICSKYTOOL_MODE_PENDINGSKYCALRUN,
     40    STATICSKYTOOL_MODE_UPDATESKYCALRUN,
     41    STATICSKYTOOL_MODE_ADDSKYCALRESULT,
     42    STATICSKYTOOL_MODE_UPDATESKYCALRESULT,
     43    STATICSKYTOOL_MODE_SKYCALRESULT,
     44    STATICSKYTOOL_MODE_REVERTSKYCALRESULT,
    3745} staticskytoolMode;
    3846

  • trunk/ippTools/src/staticskytoolConfig.c

    r31687 r32960  
    4848    // XXX need a 'ra_min,max', 'dec_min,max' : to do this, we need a table of skycell boundaries
    4949    psMetadata *definebyqueryArgs = psMetadataAlloc();
     50    psMetadataAddS64(definebyqueryArgs,  PS_LIST_TAIL, "-select_stack_id", 0, "search for stack_id", 0);
    5051    psMetadataAddStr(definebyqueryArgs,  PS_LIST_TAIL, "-select_skycell_id", 0, "search for skycell_id", NULL);
    5152    psMetadataAddStr(definebyqueryArgs,  PS_LIST_TAIL, "-select_tess_id", 0, "search for tess_id", NULL);
    … …  
    138139    psMetadata *importrunArgs = psMetadataAlloc();
    139140    psMetadataAddStr(importrunArgs, PS_LIST_TAIL, "-infile", 0, "import from this file (required)", NULL);
    140 
     141 
     142    // -defineskycalrun
     143    psMetadata *defineskycalrunArgs = psMetadataAlloc();
     144    psMetadataAddS64(defineskycalrunArgs,  PS_LIST_TAIL, "-select_sky_id", 0, "search for sky_id", 0);
     145    psMetadataAddS64(defineskycalrunArgs,  PS_LIST_TAIL, "-select_stack_id", 0, "search for stack_id", 0);
     146    psMetadataAddStr(defineskycalrunArgs,  PS_LIST_TAIL, "-select_skycell_id", 0, "search for skycell_id", NULL);
     147    psMetadataAddStr(defineskycalrunArgs,  PS_LIST_TAIL, "-select_tess_id", 0, "search for tess_id", NULL);
     148    psMetadataAddF32(defineskycalrunArgs,  PS_LIST_TAIL, "-select_good_frac_min", 0, "define min good_frac", 0.0);
     149    psMetadataAddStr(defineskycalrunArgs,  PS_LIST_TAIL, "-select_label", PS_META_DUPLICATE_OK, "search by stackRun label (LIKE comparison, multiple OK)", NULL);
     150    psMetadataAddStr(defineskycalrunArgs,  PS_LIST_TAIL, "-select_data_group", PS_META_DUPLICATE_OK, "search by stackRun data_group (LIKE comparison, multiple OK)", NULL);
     151    psMetadataAddStr(defineskycalrunArgs,  PS_LIST_TAIL, "-select_filter", PS_META_DUPLICATE_OK, "search by filter (LIKE comparison, multiple OK)", NULL);
     152    psMetadataAddStr(defineskycalrunArgs,  PS_LIST_TAIL, "-set_workdir", 0, "define workdir", NULL);
     153    psMetadataAddStr(defineskycalrunArgs,  PS_LIST_TAIL, "-set_label", 0, "define label", NULL);
     154    psMetadataAddStr(defineskycalrunArgs,  PS_LIST_TAIL, "-set_data_group", 0, "define data group", NULL);
     155    psMetadataAddStr(defineskycalrunArgs,  PS_LIST_TAIL, "-set_dist_group", 0, "define dist group", NULL);
     156    psMetadataAddStr(defineskycalrunArgs,  PS_LIST_TAIL, "-set_note", 0, "define note", NULL);
     157    psMetadataAddStr(defineskycalrunArgs,  PS_LIST_TAIL, "-set_reduction", 0, "define reduction", NULL);
     158    psMetadataAddTime(defineskycalrunArgs, PS_LIST_TAIL, "-set_registered", 0, "time detrend run was registered", now);
     159    psMetadataAddBool(defineskycalrunArgs, PS_LIST_TAIL, "-rerun",  0, "queue new run even if one already exists for inputs", false);
     160    psMetadataAddBool(defineskycalrunArgs, PS_LIST_TAIL, "-pretend",  0, "do not actually modify the database", false);
     161    psMetadataAddBool(defineskycalrunArgs, PS_LIST_TAIL, "-check_inputs",  0, "list inputs, do not modify database", false);
     162    psMetadataAddBool(defineskycalrunArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
     163
     164    // -updateskycalrun
     165    psMetadata *updateskycalrunArgs = psMetadataAlloc();
     166    psMetadataAddS64(updateskycalrunArgs, PS_LIST_TAIL, "-sky_id", 0, "search by stack ID", 0);
     167    psMetadataAddStr(updateskycalrunArgs, PS_LIST_TAIL, "-state", 0, "search by state", NULL);
     168    psMetadataAddStr(updateskycalrunArgs, PS_LIST_TAIL, "-label", 0, "search by label", 0);
     169    psMetadataAddStr(updateskycalrunArgs, PS_LIST_TAIL, "-set_label", 0, "define new value for label", NULL);
     170    psMetadataAddStr(updateskycalrunArgs, PS_LIST_TAIL, "-set_state", 0, "define new state", NULL);
     171    psMetadataAddStr(updateskycalrunArgs, PS_LIST_TAIL, "-set_data_group", 0, "define new data_group", NULL);
     172    psMetadataAddStr(updateskycalrunArgs, PS_LIST_TAIL, "-set_dist_group", 0, "define new dist_group", NULL);
     173    psMetadataAddStr(updateskycalrunArgs, PS_LIST_TAIL, "-set_note", 0, "define new note", NULL);
     174
     175    // -pendingskycalrun
     176    psMetadata *pendingskycalrunArgs = psMetadataAlloc();
     177    psMetadataAddS64(pendingskycalrunArgs, PS_LIST_TAIL, "-skycal_id", 0, "search by skycal ID", 0);
     178    psMetadataAddS64(pendingskycalrunArgs, PS_LIST_TAIL, "-sky_id", 0, "search by staticsky ID", 0);
     179    psMetadataAddStr(pendingskycalrunArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by label", NULL);
     180    psMetadataAddStr(pendingskycalrunArgs, PS_LIST_TAIL, "-filter", 0, "search by filter", NULL);
     181    psMetadataAddU64(pendingskycalrunArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
     182    psMetadataAddBool(pendingskycalrunArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    141183
    142184    psFree(now);
    … …  
    155197    PXOPT_ADD_MODE("-exportrun",     "Export run",           STATICSKYTOOL_MODE_EXPORTRUN,     exportrunArgs);
    156198    PXOPT_ADD_MODE("-importrun",     "Import run",           STATICSKYTOOL_MODE_IMPORTRUN,     importrunArgs);
     199    PXOPT_ADD_MODE("-defineskycalrun", "Define a new skycalrun", STATICSKYTOOL_MODE_DEFINESKYCALRUN, defineskycalrunArgs);
     200    PXOPT_ADD_MODE("-updateskycalrun", "Update a skycalrun", STATICSKYTOOL_MODE_UPDATESKYCALRUN,     updateskycalrunArgs);
     201    PXOPT_ADD_MODE("-pendingskycalrun", "Get skcal runs to do",       STATICSKYTOOL_MODE_PENDINGSKYCALRUN,          pendingskycalrunArgs);
    157202
    158203    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {
Note: See TracChangeset for help on using the changeset viewer.