IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 32962


Ignore:
Timestamp:
Dec 15, 2011, 4:42:59 PM (14 years ago)
Author:
bills
Message:

finish implementation of the sky calibration stage

Location:
trunk/ippTools
Files:
2 added
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/ippTools/share/Makefile.am

    r32960 r32962  
    387387        staticskytool_defineskycalrun.sql \
    388388        staticskytool_pendingskycalrun.sql \
     389        staticskytool_revertskycal.sql \
     390        staticskytool_skycalresult.sql \
    389391        staticskytool_export_run.sql \
    390392        staticskytool_export_input.sql \

  • trunk/ippTools/share/disttool_definebyquery_raw_no_magic.sql

    r31236 r32962  
    1414JOIN rcInterest USING(target_id)
    1515LEFT JOIN distRun ON distRun.stage_id = exp_id AND distRun.target_id = distTarget.target_id
    16 WHERE distRun.dist_id IS NULL           -- no existing distRun for this exposure
    17     AND distTarget.state = 'enabled'    -- target and intrest are enabled
     16WHERE distTarget.state = 'enabled'    -- target and intrest are enabled
    1817    AND rcInterest.state = 'enabled'

  • trunk/ippTools/src/staticskytool.c

    r32960 r32962  
    3838static bool resultMode(pxConfig *config);
    3939static bool revertMode(pxConfig *config);
    40 static bool updateresult(pxConfig *config);
     40static bool updateresultMode(pxConfig *config);
    4141static bool exportrunMode(pxConfig *config);
    4242static bool importrunMode(pxConfig *config);
    … …  
    4545static bool updateskycalrunMode(pxConfig *config);
    4646static bool pendingskycalrunMode(pxConfig *config);
     47static bool addskycalresultMode(pxConfig *config);
     48static bool skycalresultMode(pxConfig *config);
     49static bool revertskycalresultMode(pxConfig *config);
     50static bool updateskycalresultMode(pxConfig *config);
    4751
    4852static bool setstaticskyRunState(pxConfig *config, psS64 sky_id, const char *state);
    … …  
    7377        MODECASE(STATICSKYTOOL_MODE_RESULT,            resultMode);
    7478        MODECASE(STATICSKYTOOL_MODE_REVERT,            revertMode);
    75         MODECASE(STATICSKYTOOL_MODE_UPDATERESULT,      updateresult);
     79        MODECASE(STATICSKYTOOL_MODE_UPDATERESULT,      updateresultMode);
    7680        MODECASE(STATICSKYTOOL_MODE_EXPORTRUN,         exportrunMode);
    7781        MODECASE(STATICSKYTOOL_MODE_IMPORTRUN,         importrunMode);
    … …  
    7983        MODECASE(STATICSKYTOOL_MODE_UPDATESKYCALRUN,   updateskycalrunMode);
    8084        MODECASE(STATICSKYTOOL_MODE_PENDINGSKYCALRUN,  pendingskycalrunMode);
     85        MODECASE(STATICSKYTOOL_MODE_ADDSKYCALRESULT,   addskycalresultMode);
     86        MODECASE(STATICSKYTOOL_MODE_UPDATESKYCALRESULT,updateskycalresultMode);
     87        MODECASE(STATICSKYTOOL_MODE_REVERTSKYCALRESULT,revertskycalresultMode);
     88        MODECASE(STATICSKYTOOL_MODE_SKYCALRESULT,      skycalresultMode);
    8189        default:
    8290            psAbort("invalid option (this should not happen)");
    … …  
    741749}
    742750
    743 static bool updateresult(pxConfig *config)
     751static bool updateresultMode(pxConfig *config)
    744752{
    745753    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    11711179    psFree(whereMD);
    11721180
    1173 //    psStringAppend(&query, "\n GROUP by skycal_id");
    1174 
    11751181    // treat limit == 0 as "no limit"
    11761182    if (limit) {
    … …  
    12201226    return true;
    12211227}
     1228
     1229static bool addskycalresultMode(pxConfig *config)
     1230{
     1231    PS_ASSERT_PTR_NON_NULL(config, false);
     1232
     1233    // required
     1234    PXOPT_LOOKUP_S64(skycal_id, config->args, "-skycal_id", true, false);
     1235
     1236    // optional
     1237    PXOPT_LOOKUP_F32(sigma_ra, config->args,  "-sigma_ra", false, false);
     1238    PXOPT_LOOKUP_F32(sigma_dec, config->args, "-sigma_dec", false, false);
     1239
     1240    PXOPT_LOOKUP_F32(zpt_obs, config->args,   "-zpt_obs", false, false);
     1241    PXOPT_LOOKUP_F32(zpt_stdev, config->args, "-zpt_stdev", false, false);
     1242
     1243
     1244    PXOPT_LOOKUP_F32(dtime_script, config->args,   "-dtime_script", false, false);
     1245    PXOPT_LOOKUP_F32(dtime_astrom, config->args,   "-dtime_astrom", false, false);
     1246
     1247    PXOPT_LOOKUP_STR(hostname, config->args,    "-hostname", false, false);
     1248//    PXOPT_LOOKUP_S32(n_stars, config->args,     "-n_stars", false, false);
     1249    PXOPT_LOOKUP_S32(n_astrom, config->args,    "-n_astrom", false, false);
     1250
     1251    PXOPT_LOOKUP_STR(path_base, config->args,   "-path_base", false, false);
     1252    PXOPT_LOOKUP_S16(fault, config->args,       "-fault", false, false);
     1253    PXOPT_LOOKUP_S16(quality, config->args,     "-quality", false, false);
     1254
     1255    PXOPT_LOOKUP_STR(ver_pslib, config->args,   "-ver_pslib", false, false);
     1256    PXOPT_LOOKUP_STR(ver_psmodules, config->args, "-ver_psmodules", false, false);
     1257    PXOPT_LOOKUP_STR(ver_psphot, config->args,  "-ver_psphot", false, false);
     1258    PXOPT_LOOKUP_STR(ver_psastro, config->args, "-ver_psastro", false, false);
     1259    PXOPT_LOOKUP_STR(ver_ppstats, config->args, "-ver_ppstats", false, false);
     1260
     1261    psString software_ver = NULL;
     1262    if ((ver_pslib)&&(ver_psmodules)) {
     1263      software_ver = pxMergeCodeVersions(ver_pslib,ver_psmodules);
     1264    }
     1265    if (ver_psphot) {
     1266      software_ver = pxMergeCodeVersions(software_ver,ver_psphot);
     1267    }
     1268    if (ver_psastro) {
     1269      software_ver = pxMergeCodeVersions(software_ver,ver_psastro);
     1270    }
     1271    if (ver_ppstats) {
     1272      software_ver = pxMergeCodeVersions(software_ver,ver_ppstats);
     1273    }
     1274
     1275    if (!psDBTransaction(config->dbh)) {
     1276        psError(PS_ERR_UNKNOWN, false, "database error");
     1277        return false;
     1278    }
     1279
     1280    skycalResultRow *row = skycalResultRowAlloc(
     1281        skycal_id,
     1282        path_base,
     1283        dtime_script,
     1284        dtime_astrom,
     1285        sigma_ra,
     1286        sigma_dec,
     1287        n_astrom,
     1288        zpt_obs,
     1289        zpt_stdev,
     1290        quality,
     1291        software_ver,
     1292        hostname,
     1293        fault
     1294        );
     1295
     1296    if (!skycalResultInsertObject(config->dbh, row)) {
     1297        // rollback
     1298        if (!psDBRollback(config->dbh)) {
     1299            psError(PS_ERR_UNKNOWN, false, "database error");
     1300        }
     1301        psError(PS_ERR_UNKNOWN, false, "database error");
     1302        psFree(row);
     1303        return false;
     1304    }
     1305
     1306    psFree(row);
     1307
     1308    if (fault) {
     1309        if (!psDBCommit(config->dbh)) {
     1310            psError(PS_ERR_UNKNOWN, false, "database error");
     1311            return false;
     1312        }
     1313        return true;
     1314    }
     1315
     1316    psString query = "UPDATE skycalRun SET state = 'full' WHERE skycal_id = %" PRId64;
     1317    if (!p_psDBRunQueryF(config->dbh, query, skycal_id)) {
     1318        psError(PS_ERR_UNKNOWN, false, "database error");
     1319        return false;
     1320    }
     1321    if (!psDBCommit(config->dbh)) {
     1322        psError(PS_ERR_UNKNOWN, false, "database error");
     1323        return false;
     1324    }
     1325
     1326    return true;
     1327}
     1328static bool updateskycalresultMode(pxConfig *config)
     1329{
     1330    PS_ASSERT_PTR_NON_NULL(config, false);
     1331
     1332    PXOPT_LOOKUP_S16(fault, config->args, "-set_fault", true, false);
     1333    PXOPT_LOOKUP_S16(quality, config->args, "-set_quality", false, false);
     1334
     1335    psMetadata *where = psMetadataAlloc();
     1336    PXOPT_COPY_S64(config->args, where, "-skycal_id",   "skycal_id",   "==");
     1337
     1338    if (!pxSetFaultCode(config->dbh, "skycalResult", where, fault, quality)) {
     1339        psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag");
     1340        psFree (where);
     1341        return false;
     1342    }
     1343    psFree (where);
     1344    return true;
     1345}
     1346static bool skycalresultMode(pxConfig *config)
     1347{
     1348    PS_ASSERT_PTR_NON_NULL(config, false);
     1349
     1350    psMetadata *where = psMetadataAlloc();
     1351    PXOPT_COPY_S64(config->args, where, "-skycal_id",  "skycalRun.skycal_id", "==");
     1352    PXOPT_COPY_S64(config->args, where, "-sky_id",     "skycalRun.sky_id", "==");
     1353    PXOPT_COPY_S64(config->args, where, "-stack_id",   "skycalRun.stack_id", "==");
     1354    PXOPT_COPY_STR(config->args, where, "-tess_id",    "stackRun.tess_id", "LIKE");
     1355    PXOPT_COPY_STR(config->args, where, "-skycell_id", "stackRun.skycell_id", "LIKE");
     1356    PXOPT_COPY_STR(config->args, where, "-filter",     "stackRun.filter", "LIKE");
     1357    PXOPT_COPY_STR(config->args, where, "-label",      "skycalRun.label", "==");
     1358    PXOPT_COPY_STR(config->args, where, "-data_group", "skycalRun.data_group", "LIKE");
     1359    PXOPT_COPY_S16(config->args, where, "-fault",      "skycalResult.fault", "==");
     1360
     1361    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1362    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1363
     1364    psString query = pxDataGet("staticskytool_skycalresult.sql");
     1365    if (!query) {
     1366        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1367        return false;
     1368    }
     1369
     1370    if (!psListLength(where->list)) {
     1371        psError(PXTOOLS_ERR_CONFIG, true, "search parameters are required");
     1372        return false;
     1373    }
     1374    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1375    psStringAppend(&query, " WHERE %s", whereClause);
     1376    psFree(whereClause);
     1377    psFree(where);
     1378
     1379    // treat limit == 0 as "no limit"
     1380    if (limit) {
     1381        psString limitString = psDBGenerateLimitSQL(limit);
     1382        psStringAppend(&query, " %s", limitString);
     1383        psFree(limitString);
     1384    }
     1385
     1386    if (!p_psDBRunQuery(config->dbh, query)) {
     1387        psError(PS_ERR_UNKNOWN, false, "database error");
     1388        psFree(query);
     1389        return false;
     1390    }
     1391    psFree(query);
     1392
     1393    psArray *output = p_psDBFetchResult(config->dbh);
     1394    if (!output) {
     1395        psErrorCode err = psErrorCodeLast();
     1396        switch (err) {
     1397            case PS_ERR_DB_CLIENT:
     1398                psError(PXTOOLS_ERR_SYS, false, "database error");
     1399            case PS_ERR_DB_SERVER:
     1400                psError(PXTOOLS_ERR_PROG, false, "database error");
     1401            default:
     1402                psError(PXTOOLS_ERR_PROG, false, "unknown error");
     1403        }
     1404
     1405        return false;
     1406    }
     1407    if (!psArrayLength(output)) {
     1408        psTrace("staticskytool", PS_LOG_INFO, "no rows found");
     1409        psFree(output);
     1410        return true;
     1411    }
     1412
     1413    if (psArrayLength(output)) {
     1414        if (!ippdbPrintMetadatas(stdout, output, "staticskyResult", !simple)) {
     1415            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1416            psFree(output);
     1417            return false;
     1418        }
     1419    }
     1420
     1421    psFree(output);
     1422
     1423    return true;
     1424}
     1425static bool revertskycalresultMode(pxConfig *config)
     1426{
     1427    PS_ASSERT_PTR_NON_NULL(config, false);
     1428
     1429    psMetadata *where = psMetadataAlloc();
     1430    PXOPT_COPY_S64(config->args, where, "-skycal_id", "staticskyResult.sky_id", "==");
     1431    pxAddLabelSearchArgs(config, where, "-label", "staticskyRun.label", "==");
     1432    pxAddLabelSearchArgs(config, where, "-data_group", "staticskyRun.data_group", "==");
     1433    pxAddLabelSearchArgs(config, where, "-filter", "stackRun.filter", "==");
     1434    PXOPT_COPY_S16(config->args, where, "-fault", "staticskyResult.fault", "==");
     1435
     1436    if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
     1437        psFree(where);
     1438        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     1439        return false;
     1440    }
     1441
     1442    // Delete product
     1443    psString delete = pxDataGet("staticskytool_revertskycal.sql");
     1444    if (!delete) {
     1445        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1446        return false;
     1447    }
     1448
     1449    if (psListLength(where->list)) {
     1450        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1451        psStringAppend(&delete, " AND %s", whereClause);
     1452        psFree(whereClause);
     1453    }
     1454
     1455    if (!p_psDBRunQuery(config->dbh, delete)) {
     1456        psError(PS_ERR_UNKNOWN, false, "database error");
     1457        psFree(delete);
     1458        psFree(where);
     1459        return false;
     1460    }
     1461    psFree(delete);
     1462
     1463    int numRows = psDBAffectedRows(config->dbh); // Number of row affected
     1464    psLogMsg("staticskytool", PS_LOG_INFO, "Deleted %d rows", numRows);
     1465
     1466    psFree(where);
     1467    return true;
     1468}

  • trunk/ippTools/src/staticskytoolConfig.c

    r32960 r32962  
    182182    psMetadataAddBool(pendingskycalrunArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    183183
     184
     185    // -addskycalresult
     186    psMetadata *addskycalresultArgs = psMetadataAlloc();
     187    psMetadataAddS64(addskycalresultArgs, PS_LIST_TAIL, "-skycal_id", 0,            "define camtool ID (required)", 0);
     188    psMetadataAddF32(addskycalresultArgs, PS_LIST_TAIL, "-sigma_ra", 0,            "define exposure E ra", NAN);
     189    psMetadataAddF32(addskycalresultArgs, PS_LIST_TAIL, "-sigma_dec", 0,            "define exposure E dec", NAN);
     190    psMetadataAddF32(addskycalresultArgs, PS_LIST_TAIL, "-zpt_obs", 0,   "define observed zero point", 0);
     191    psMetadataAddF32(addskycalresultArgs, PS_LIST_TAIL, "-zpt_stdev", 0,   "define observed zero point stdandard deviation", 0);
     192
     193    psMetadataAddF32(addskycalresultArgs, PS_LIST_TAIL, "-dtime_script", 0, "define elapsed time in script (seconds)", NAN);
     194    psMetadataAddF32(addskycalresultArgs, PS_LIST_TAIL, "-dtime_astrom", 0, "define elapsed time for astrometry (seconds)", NAN);
     195
     196    psMetadataAddStr(addskycalresultArgs, PS_LIST_TAIL, "-hostname", 0,            "define hostname", NULL);
     197    // psMetadataAddS32(addskycalresultArgs, PS_LIST_TAIL, "-n_stars", 0,            "define number of stars", 0);
     198    psMetadataAddS32(addskycalresultArgs, PS_LIST_TAIL, "-n_astrom", 0,            "define number of astrometry reference objects", 0);
     199
     200    psMetadataAddStr(addskycalresultArgs, PS_LIST_TAIL, "-path_base", 0,            "define base output location", NULL);
     201    psMetadataAddS16(addskycalresultArgs, PS_LIST_TAIL, "-fault",  0,            "set fault code", 0);
     202    psMetadataAddS16(addskycalresultArgs, PS_LIST_TAIL, "-quality",  0,            "set quality", 0);
     203
     204    psMetadataAddStr(addskycalresultArgs, PS_LIST_TAIL, "-ver_pslib", 0, "define psLib version", NULL);
     205    psMetadataAddStr(addskycalresultArgs, PS_LIST_TAIL, "-ver_psmodules", 0, "define psModules version", NULL);
     206    psMetadataAddStr(addskycalresultArgs, PS_LIST_TAIL, "-ver_psphot", 0, "define psphot version", NULL);
     207    psMetadataAddStr(addskycalresultArgs, PS_LIST_TAIL, "-ver_psastro", 0, "define psastro version", NULL);
     208    psMetadataAddStr(addskycalresultArgs, PS_LIST_TAIL, "-ver_ppstats", 0, "define ppStats version", NULL);
     209    psMetadataAddStr(addskycalresultArgs, PS_LIST_TAIL, "-ver_streaks", 0, "define streaksremove version", NULL);
     210
     211    // -revertskycal
     212    psMetadata *revertskycalArgs= psMetadataAlloc();
     213    psMetadataAddS64(revertskycalArgs, PS_LIST_TAIL, "-skycal_id", 0, "search by staticsky ID", 0);
     214    psMetadataAddStr(revertskycalArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by label", 0);
     215    psMetadataAddStr(revertskycalArgs, PS_LIST_TAIL, "-data_group", PS_META_DUPLICATE_OK, "search by data_group", 0);
     216    psMetadataAddStr(revertskycalArgs, PS_LIST_TAIL, "-filter", PS_META_DUPLICATE_OK, "search by filter", 0);
     217    psMetadataAddS16(revertskycalArgs, PS_LIST_TAIL, "-fault", 0, "search by fault code", 0);
     218    psMetadataAddBool(revertskycalArgs, PS_LIST_TAIL, "-all", 0, "allow no search terms", false);
     219
     220    // -updateskycalresult
     221    psMetadata *updateskycalresultArgs = psMetadataAlloc();
     222    psMetadataAddS64(updateskycalresultArgs, PS_LIST_TAIL, "-skycal_id", 0, "define staticksky ID (required)", 0);
     223    psMetadataAddS16(updateskycalresultArgs, PS_LIST_TAIL, "-set_fault", 0, "set fault code (required)", 0);
     224    psMetadataAddS16(updateskycalresultArgs, PS_LIST_TAIL, "-set_quality", 0, "set quality code", 0);
     225
     226    // -skycalresult
     227    psMetadata *skycalresultArgs= psMetadataAlloc();
     228    psMetadataAddS64(skycalresultArgs, PS_LIST_TAIL, "-skycal_id", 0, "search by skycal ID", 0);
     229    psMetadataAddS64(skycalresultArgs, PS_LIST_TAIL, "-sky_id", 0, "search by staticsky ID", 0);
     230    psMetadataAddS64(skycalresultArgs, PS_LIST_TAIL, "-stack_id", 0, "search by stack ID", 0);
     231    psMetadataAddStr(skycalresultArgs, PS_LIST_TAIL, "-tess_id", 0, "search by tess ID (LIKE comparison)", 0);
     232    psMetadataAddStr(skycalresultArgs, PS_LIST_TAIL, "-skycell_id", 0, "search by skycell ID (LIKE comparison)", 0);
     233    psMetadataAddStr(skycalresultArgs, PS_LIST_TAIL, "-filter", 0, "search by filter (LIKE comparison)", 0);
     234    psMetadataAddStr(skycalresultArgs, PS_LIST_TAIL, "-label", 0, "search by label (LIKE comparison)", NULL);
     235    psMetadataAddStr(skycalresultArgs, PS_LIST_TAIL, "-data_group", 0, "search by data_group (LIKE comparison)", NULL);
     236    psMetadataAddS16(skycalresultArgs, PS_LIST_TAIL, "-fault", 0, "search by fault code", 0);
     237    psMetadataAddU64(skycalresultArgs, PS_LIST_TAIL, "-limit", 0, "limit skycalresult set to N items", 0);
     238    psMetadataAddBool(skycalresultArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
     239
    184240    psFree(now);
    185241
    … …  
    200256    PXOPT_ADD_MODE("-updateskycalrun", "Update a skycalrun", STATICSKYTOOL_MODE_UPDATESKYCALRUN,     updateskycalrunArgs);
    201257    PXOPT_ADD_MODE("-pendingskycalrun", "Get skcal runs to do",       STATICSKYTOOL_MODE_PENDINGSKYCALRUN,          pendingskycalrunArgs);
     258    PXOPT_ADD_MODE("-addskycalresult", "add skycal result",       STATICSKYTOOL_MODE_ADDSKYCALRESULT, addskycalresultArgs);
     259    PXOPT_ADD_MODE("-revertskycal",  "revert faulted skycal run", STATICSKYTOOL_MODE_REVERTSKYCALRESULT, revertskycalArgs);
     260    PXOPT_ADD_MODE("-updateskycal",  "revert faulted skycal run", STATICSKYTOOL_MODE_UPDATESKYCALRESULT, updateskycalresultArgs);
     261    PXOPT_ADD_MODE("-skycalresult",  "Get result of skycal run",  STATICSKYTOOL_MODE_SKYCALRESULT, skycalresultArgs);
    202262
    203263    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {
Note: See TracChangeset for help on using the changeset viewer.