IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
May 18, 2010, 5:06:01 PM (16 years ago)
Author:
watersc1
Message:

Almost working version of the mask-stats/software revision code.

Almost.

Location:
branches/czw_branch/20100427
Files:
25 edited

Legend:

Unmodified
Added
Removed

  • branches/czw_branch/20100427

  • branches/czw_branch/20100427/ippTools/src/camtool.c

    r27784 r28017  
    490490    PXOPT_LOOKUP_STR(ver_streaks, config->args, "-ver_streaks", false, false);
    491491
     492    PXOPT_LOOKUP_S32(maskfrac_npix, config->args, "-maskfrac_npix", false, false);
     493    PXOPT_LOOKUP_F32(maskfrac_static, config->args, "-maskfrac_static", false, false);
     494    PXOPT_LOOKUP_F32(maskfrac_dynamic, config->args, "-maskfrac_dynamic", false, false);
     495    PXOPT_LOOKUP_F32(maskfrac_magic, config->args, "-maskfrac_magic", false, false);
     496    PXOPT_LOOKUP_F32(maskfrac_advisory, config->args, "-maskfrac_advisory", false, false);
     497
    492498    psTrace("czw.test",1,"Received versions: pslib %s psmodules %s psphot %s psastro %s ppstats %s ppImage %s streaks %s\n",
    493499            ver_pslib,ver_psmodules,ver_psphot,ver_psastro,ver_ppstats,ver_ppimage,ver_streaks);
    494    
     500    psString software_ver = NULL;
     501    if ((ver_pslib)&&(ver_psmodules)) {
     502      software_ver = pxMergeCodeVersions(ver_pslib,ver_psmodules);
     503    }
     504    if (ver_psphot) {
     505      software_ver = pxMergeCodeVersions(software_ver,ver_psphot);
     506    }
     507    if (ver_psastro) {
     508      software_ver = pxMergeCodeVersions(software_ver,ver_psastro);
     509    }
     510    if (ver_ppstats) {
     511      software_ver = pxMergeCodeVersions(software_ver,ver_ppstats);
     512    }
     513    if (ver_ppimage) {
     514      software_ver = pxMergeCodeVersions(software_ver,ver_ppimage);
     515    }
     516    if (ver_streaks) {
     517      software_ver = pxMergeCodeVersions(software_ver,ver_streaks);
     518    }
     519
    495520//    Get this from the chipRun
    496521//    PXOPT_LOOKUP_S64(magicked, config->args, "-magicked", false, false);
    … …  
    606631        path_base,
    607632        fault,
    608         quality
    609 /*      quality, */
    610 /*      ver_pslib, */
    611 /*      ver_psmodules, */
    612 /*      ver_psphot, */
    613 /*      ver_psastro, */
    614 /*      ver_ppstats, */
    615 /*      ver_ppimage, */
    616 /*      ver_streaks      */
     633        software_ver,
     634        maskfrac_npix,
     635        maskfrac_static,
     636        maskfrac_dynamic,
     637        maskfrac_magic,
     638        maskfrac_advisory,
     639        quality
    617640        );
    618641
    … …  
    639662    // else continue on...
    640663
     664
     665    // Set camRun.software_ver to the appropriate value
     666    if (!pxSetRunSoftware(config, "camRun", "cam_id", cam_id, software_ver)) {
     667      if (!psDBRollback(config->dbh)) {
     668        psError(PS_ERR_UNKNOWN, false, "database error");
     669      }
     670      psError(PS_ERR_UNKNOWN, false, "failed to set camRun.software_ver for cam_id: %" PRId64,
     671              cam_id);
     672      psFree(output);
     673      return(false);
     674    }
     675    // Set chipRun.maskfrac* to the appropriate values.
     676    if (maskfrac_npix) {
     677      if (!pxSetRunMaskfrac(config, "camRun", "cam_id",cam_id, maskfrac_npix, maskfrac_static,
     678                            maskfrac_dynamic, maskfrac_magic, maskfrac_advisory)) {
     679        if (!psDBRollback(config->dbh)) {
     680          psError(PS_ERR_UNKNOWN, false, "database error");
     681        }
     682        psError(PS_ERR_UNKNOWN, false, "failed to set camRun.maskstats for cam_id: %" PRId64,
     683                cam_id);
     684        psFree(output);
     685        return(false);
     686      }
     687    }
     688
    641689    // since there is only one exp per 'new' set camRun.state = 'full'
    642690    // propagate magicked state from chipRun
    … …  
    647695        return false;
    648696    }
     697   
    649698    psFree(row);
    650699

  • branches/czw_branch/20100427/ippTools/src/camtoolConfig.c

    r27784 r28017  
    179179    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-ver_psastro", 0, "define psastro version", NULL);
    180180    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-ver_ppstats", 0, "define ppStats version", NULL);
    181     psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-ver_ppImage", 0, "define ppImage version", NULL);
     181    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-ver_ppimage", 0, "define ppImage version", NULL);
    182182    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-ver_streaks", 0, "define streaksremove version", NULL);
    183    
     183
     184    psMetadataAddS32(addprocessedexpArgs, PS_LIST_TAIL, "-maskfrac_npix", 0, "define number of pixels used for maskstats", 0);
     185    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-maskfrac_static", 0, "define static mask fraction", NAN);
     186    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-maskfrac_dynamic", 0, "define dynamic mask fraction", NAN);
     187    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-maskfrac_magic", 0, "define magic mask fraction", NAN);
     188    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-maskfrac_advisory", 0, "define advisory mask fraction", NAN);
     189
     190
    184191    // -processedexp
    185192    psMetadata *processedexpArgs = psMetadataAlloc();

  • branches/czw_branch/20100427/ippTools/src/chiptool.c

    r27784 r28017  
    422422    PXOPT_COPY_S64(config->args,  where, "-chip_id", "chipRun.chip_id", "==");
    423423    // we only allow a single label to match (do not use pxAddLabelSearchArgs here)
    424     PXOPT_COPY_STR(config->args,  where, "-label",   "chipRun.label",   "==");
     424    PXOPT_COPY_STR(config->args,  where, "-label",   "chipRun.label",   "LIKE");
    425425    PXOPT_COPY_STR(config->args,  where, "-state",   "chipRun.state",   "==");
    426     PXOPT_COPY_STR(config->args,  where, "-data_group", "chipRun.data_group",   "==");
    427     PXOPT_COPY_STR(config->args,  where, "-dist_group", "chipRun.dist_group",   "==");
     426    PXOPT_COPY_STR(config->args,  where, "-data_group", "chipRun.data_group",   "LIKE");
     427    PXOPT_COPY_STR(config->args,  where, "-dist_group", "chipRun.dist_group",   "LIKE");
    428428
    429429    if (!psListLength(where->list)) {
    … …  
    471471    }
    472472    psFree(where);
     473
     474    psStringAppend(&query, "\nORDER BY priority DESC, chip_id");
    473475
    474476    // treat limit == 0 as "no limit"
    … …  
    591593    PXOPT_LOOKUP_STR(ver_streaks, config->args, "-ver_streaks", false, false);
    592594
     595    PXOPT_LOOKUP_S32(maskfrac_npix, config->args, "-maskfrac_npix", false, false);
     596    PXOPT_LOOKUP_F32(maskfrac_static, config->args, "-maskfrac_static", false, false);
     597    PXOPT_LOOKUP_F32(maskfrac_dynamic, config->args, "-maskfrac_dynamic", false, false);
     598    PXOPT_LOOKUP_F32(maskfrac_magic, config->args, "-maskfrac_magic", false, false);
     599    PXOPT_LOOKUP_F32(maskfrac_advisory, config->args, "-maskfrac_advisory", false, false);
     600
    593601    psTrace("czw.test",1,"Received versions: pslib %s psmodules %s psphot %s psastro %s ppstats %s ppImage %s streaks %s\n",
    594602            ver_pslib,ver_psmodules,ver_psphot,ver_psastro,ver_ppstats,ver_ppimage,ver_streaks);
     603    psString ver_code = NULL;
     604    if ((ver_pslib)&&(ver_psmodules)) {
     605      ver_code = pxMergeCodeVersions(ver_pslib,ver_psmodules);
     606    }
     607    if (ver_psphot) {
     608      ver_code = pxMergeCodeVersions(ver_code,ver_psphot);
     609    }
     610    if (ver_psastro) {
     611      ver_code = pxMergeCodeVersions(ver_code,ver_psastro);
     612    }
     613    if (ver_ppstats) {
     614      ver_code = pxMergeCodeVersions(ver_code,ver_ppstats);
     615    }
     616    if (ver_ppimage) {
     617      ver_code = pxMergeCodeVersions(ver_code,ver_ppimage);
     618    }
     619    if (ver_streaks) {
     620      ver_code = pxMergeCodeVersions(ver_code,ver_streaks);
     621    }
    595622   
    596623    // default values
    … …  
    670697                                   fault,
    671698                                   quality,
    672                                    magicked
    673 /*                                 magicked, */
    674 /*                                 ver_pslib, */
    675 /*                                 ver_psmodules, */
    676 /*                                 ver_psphot, */
    677 /*                                 ver_psastro, */
    678 /*                                 ver_ppstats, */
    679 /*                                 ver_ppimage, */
    680 /*                                 ver_streaks */
     699                                   magicked,
     700                                   ver_code,
     701                                   maskfrac_npix,
     702                                   maskfrac_static,
     703                                   maskfrac_dynamic,
     704                                   maskfrac_magic,
     705                                   maskfrac_advisory
    681706            )) {
    682707        // rollback
    … …  
    13701395        psMetadata *row = output->data[i];
    13711396
     1397        psS64 chip_id = psMetadataLookupS64(NULL,row,"chip_id");
     1398       
     1399        psString software_ver = NULL;
     1400        psS32 maskfrac_npix = 0;
     1401        psF32 maskfrac_static = 0;
     1402        psF32 maskfrac_dynamic = 0;
     1403        psF32 maskfrac_magic = 0;
     1404        psF32 maskfrac_advisory = 0;
     1405
     1406        // Calculate run level masking and software state
     1407        if (!pxCoalesceRunStatus(config,"chiptool_coalesce_run.sql",chip_id,
     1408                                 &software_ver,&maskfrac_npix,
     1409                                 &maskfrac_static,&maskfrac_dynamic,
     1410                                 &maskfrac_magic,&maskfrac_advisory)) {
     1411          psError(PS_ERR_UNKNOWN, false, "failed to generate run level statistics");
     1412          psFree(output);
     1413          if (!psDBRollback(config->dbh)) {
     1414            psError(PS_ERR_UNKNOWN, false, "database error");
     1415          }
     1416          return(false);
     1417        }
     1418        psMetadataAddStr(row, PS_LIST_TAIL, "software_ver",  0, "Software version", software_ver);
     1419        psMetadataAddS32(row, PS_LIST_TAIL, "maskfrac_npix",  0, "Number of pixels used for mask stats", maskfrac_npix);
     1420        psMetadataAddF32(row, PS_LIST_TAIL, "maskfrac_static",  0, "Fraction of static masked pixels", maskfrac_static);
     1421        psMetadataAddF32(row, PS_LIST_TAIL, "maskfrac_dynamic",  0, "Fraction of dynamic masked pixels", maskfrac_dynamic);
     1422        psMetadataAddF32(row, PS_LIST_TAIL, "maskfrac_magic",  0, "Fraction of magic masked pixels", maskfrac_magic);
     1423        psMetadataAddF32(row, PS_LIST_TAIL, "maskfrac_advisory",  0, "Fraction of advisory pixels", maskfrac_advisory);
     1424        psWarning("ADVANCE %ld %s %d %f %f %f %f\n",chip_id,software_ver,maskfrac_npix,maskfrac_static,maskfrac_dynamic,maskfrac_magic,maskfrac_advisory);
    13721425        chipRunRow *chipRun = chipRunObjectFromMetadata(row);
    13731426        if (!psDBTransaction(config->dbh)) {
    … …  
    13761429        }
    13771430
     1431        // Set chipRun.software_ver to the appropriate value
     1432        if (!pxSetRunSoftware(config, "chipRun", "chip_id", chip_id, software_ver)) {
     1433          psError(PS_ERR_UNKNOWN, false, "failed to set chipRun.software_ver for chip_id: %" PRId64,
     1434                  chip_id);
     1435          psFree(output);
     1436          if (!psDBRollback(config->dbh)) {
     1437            psError(PS_ERR_UNKNOWN, false, "database error");
     1438          }
     1439          return(false);
     1440        }
     1441        // Set chipRun.maskfrac* to the appropriate values.
     1442        if (!pxSetRunMaskfrac(config, "chipRun", "chip_id",chip_id, maskfrac_npix, maskfrac_static,
     1443                              maskfrac_dynamic, maskfrac_magic, maskfrac_advisory)) {
     1444          psError(PS_ERR_UNKNOWN, false, "failed to set chipRun.software_ver for chip_id: %" PRId64,
     1445                  chip_id);
     1446          psFree(output);
     1447          if (!psDBRollback(config->dbh)) {
     1448            psError(PS_ERR_UNKNOWN, false, "database error");
     1449          }
     1450          return(false);
     1451        }
    13781452        // set chipRun.state to 'stop' and update the magicked state
    13791453        if (!pxchipRunSetState(config, chipRun->chip_id, "full", chipRun->magicked)) {
    … …  
    14001474        // stop
    14011475        if (!pxcamQueueByChipID(config,
    1402                     chipRun->chip_id,
    1403                     chipRun->workdir,
    1404                     chipRun->label,
    1405                     chipRun->data_group,
    1406                     chipRun->dist_group,
    1407                     chipRun->reduction,
    1408                     chipRun->expgroup,
    1409                     chipRun->dvodb,
    1410                     chipRun->tess_id,
    1411                     chipRun->end_stage,
    1412                     chipRun->magicked,
    1413                     NULL    // note does not propagate
     1476                                chipRun->chip_id,
     1477                                chipRun->workdir,
     1478                                chipRun->label,
     1479                                chipRun->data_group,
     1480                                chipRun->dist_group,
     1481                                chipRun->reduction,
     1482                                chipRun->expgroup,
     1483                                chipRun->dvodb,
     1484                                chipRun->tess_id,
     1485                                chipRun->end_stage,
     1486                                chipRun->magicked,
     1487                                NULL    // note does not propagate
    14141488        )) {
    14151489           if (!psDBRollback(config->dbh)) {

  • branches/czw_branch/20100427/ippTools/src/chiptoolConfig.c

    r27784 r28017  
    187187    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-ver_psastro", 0, "define psastro version", NULL);
    188188    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-ver_ppstats", 0, "define ppStats version", NULL);
    189     psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-ver_ppImage", 0, "define ppImage version", NULL);
     189    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-ver_ppimage", 0, "define ppImage version", NULL);
    190190    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-ver_streaks", 0, "define streaksremove version", NULL);
    191191   
     192    psMetadataAddS32(addprocessedimfileArgs, PS_LIST_TAIL, "-maskfrac_npix", 0, "define number of pixels used for maskstats", 0);
     193    psMetadataAddF32(addprocessedimfileArgs, PS_LIST_TAIL, "-maskfrac_static", 0, "define static mask fraction", NAN);
     194    psMetadataAddF32(addprocessedimfileArgs, PS_LIST_TAIL, "-maskfrac_dynamic", 0, "define dynamic mask fraction", NAN);
     195    psMetadataAddF32(addprocessedimfileArgs, PS_LIST_TAIL, "-maskfrac_magic", 0, "define magic mask fraction", NAN);
     196    psMetadataAddF32(addprocessedimfileArgs, PS_LIST_TAIL, "-maskfrac_advisory", 0, "define advisory mask fraction", NAN);
     197
    192198    // -processedimfile
    193199    psMetadata *processedimfileArgs = psMetadataAlloc();

  • branches/czw_branch/20100427/ippTools/src/difftool.c

    r27784 r28017  
    5858static bool tofullskyfileMode(pxConfig *config);
    5959static bool listrunMode(pxConfig *config);
     60static bool setskyfiletoupdateMode(pxConfig *config);
    6061
    6162
    … …  
    103104        MODECASE(DIFFTOOL_MODE_TOFULLSKYFILE,         tofullskyfileMode);
    104105        MODECASE(DIFFTOOL_MODE_LISTRUN,               listrunMode);
     106        MODECASE(DIFFTOOL_MODE_SETSKYFILETOUPDATE,    setskyfiletoupdateMode);
    105107
    106108        default:
    … …  
    160162            exposure,
    161163            false,
     164            NULL, // software version
     165            0,    // mask stat npix
     166            NAN,    // static
     167            NAN,    // dynamic
     168            NAN,    // magic
     169            NAN,    // advisory
    162170            diff_mode,
    163171            note
    … …  
    555563    PXOPT_LOOKUP_STR(ver_streaks, config->args, "-ver_streaks", false, false);
    556564
     565    PXOPT_LOOKUP_S32(maskfrac_npix, config->args, "-maskfrac_npix", false, false);
     566    PXOPT_LOOKUP_F32(maskfrac_static, config->args, "-maskfrac_static", false, false);
     567    PXOPT_LOOKUP_F32(maskfrac_dynamic, config->args, "-maskfrac_dynamic", false, false);
     568    PXOPT_LOOKUP_F32(maskfrac_magic, config->args, "-maskfrac_magic", false, false);
     569    PXOPT_LOOKUP_F32(maskfrac_advisory, config->args, "-maskfrac_advisory", false, false);
     570   
    557571    psTrace("czw.test",1,"Received versions: pslib %s psmodules %s psphot %s ppstats %s ppsub %s streaks %s\n",
    558572            ver_pslib,ver_psmodules,ver_psphot,ver_ppstats,ver_ppsub,ver_streaks);
    559    
     573    psString ver_code = NULL;
     574    if ((ver_pslib)&&(ver_psmodules)) {
     575      ver_code = pxMergeCodeVersions(ver_pslib,ver_psmodules);
     576    }
     577    if (ver_psphot) {
     578      ver_code = pxMergeCodeVersions(ver_code,ver_psphot);
     579    }
     580    if (ver_ppstats) {
     581      ver_code = pxMergeCodeVersions(ver_code,ver_ppstats);
     582    }
     583    if (ver_ppsub) {
     584      ver_code = pxMergeCodeVersions(ver_code,ver_ppsub);
     585    }
     586    if (ver_streaks) {
     587      ver_code = pxMergeCodeVersions(ver_code,ver_streaks);
     588    }
     589
    560590    if (!psDBTransaction(config->dbh)) {
    561591        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    590620                           fault,
    591621                           quality,
    592                            magicked
    593 /*                         magicked, */
    594 /*                         ver_pslib, */
    595 /*                         ver_psmodules, */
    596 /*                         ver_psphot, */
    597 /*                         ver_ppstats, */
    598 /*                         ver_ppsub, */
    599 /*                         ver_streaks */
    600                          
     622                           magicked,
     623                           ver_code,
     624                           maskfrac_npix,
     625                           maskfrac_static,
     626                           maskfrac_dynamic,
     627                           maskfrac_magic,
     628                           maskfrac_advisory
    601629          )) {
    602630        if (!psDBRollback(config->dbh)) {
    … …  
    687715        psS64 magicked = psMetadataLookupS64(NULL, row, "magicked");
    688716
     717        psString software_ver = NULL;
     718        psS32 maskfrac_npix = 0;
     719        psF32 maskfrac_static = 0;
     720        psF32 maskfrac_dynamic = 0;
     721        psF32 maskfrac_magic = 0;
     722        psF32 maskfrac_advisory = 0;
     723
     724        // Calculate run level masking and software state
     725        if (!pxCoalesceRunStatus(config,"difftool_coalesce_run.sql",diff_id,
     726                                 &software_ver,&maskfrac_npix,
     727                                 &maskfrac_static,&maskfrac_dynamic,
     728                                 &maskfrac_magic,&maskfrac_advisory)) {
     729          psError(PS_ERR_UNKNOWN, false, "failed to generate run level statistics");
     730          psFree(output);
     731          if (!psDBRollback(config->dbh)) {
     732            psError(PS_ERR_UNKNOWN, false, "database error");
     733          }
     734          return(false);
     735        }
     736        // Set diffRun.software_ver to the appropriate value
     737        if (!pxSetRunSoftware(config, "diffRun", "diff_id", diff_id, software_ver)) {
     738          psError(PS_ERR_UNKNOWN, false, "failed to set diffRun.software_ver for diff_id: %" PRId64,
     739                  diff_id);
     740          psFree(output);
     741          if (!psDBRollback(config->dbh)) {
     742            psError(PS_ERR_UNKNOWN, false, "database error");
     743          }
     744          return(false);
     745        }
     746        // Set diffRun.maskfrac* to the appropriate values.
     747        if (!pxSetRunMaskfrac(config, "diffRun", "diff_id", diff_id, maskfrac_npix, maskfrac_static,
     748                              maskfrac_dynamic, maskfrac_magic, maskfrac_advisory)) {
     749          psError(PS_ERR_UNKNOWN, false, "failed to set diffRun.software_ver for diff_id: %" PRId64,
     750                  diff_id);
     751          psFree(output);
     752          if (!psDBRollback(config->dbh)) {
     753            psError(PS_ERR_UNKNOWN, false, "database error");
     754          }
     755          return(false);
     756        }       
    689757        // set diffRun.state to 'full'
    690758        if (!setdiffRunState(config, diff_id, "full", magicked)) {
    … …  
    840908    }
    841909
    842     if (!psDBTransaction(config->dbh)) {
    843         psError(PS_ERR_UNKNOWN, false, "database error");
    844         psFree(where);
    845         return false;
    846     }
    847 
    848     // Update state to 'new'
    849     {
    850         psString query = pxDataGet("difftool_revertdiffskyfile_update.sql");
    851         if (!query) {
    852             psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    853             if (!psDBRollback(config->dbh)) {
    854                 psError(PS_ERR_UNKNOWN, false, "database error");
    855             }
    856             return false;
    857         }
    858 
    859         if (psListLength(where->list)) {
    860             psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    861             psStringAppend(&query, " AND %s", whereClause);
    862             psFree(whereClause);
    863         }
    864 
    865         if (!p_psDBRunQuery(config->dbh, query)) {
    866             psError(PS_ERR_UNKNOWN, false, "database error");
    867             psFree(query);
    868             if (!psDBRollback(config->dbh)) {
    869                 psError(PS_ERR_UNKNOWN, false, "database error");
    870             }
    871             return false;
    872         }
    873         psFree(query);
    874 
    875         psLogMsg("difftool", PS_LOG_INFO, "Updated %" PRIu64 " rows", psDBAffectedRows(config->dbh));
    876     }
    877 
    878     // Delete product
    879910    {
    880911        psString query = pxDataGet("difftool_revertdiffskyfile_delete.sql");
    881912        if (!query) {
    882913            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    883             if (!psDBRollback(config->dbh)) {
    884                 psError(PS_ERR_UNKNOWN, false, "database error");
    885             }
     914            return false;
     915        }
     916        psString query_updated = pxDataGet("difftool_revertdiffskyfile_updated.sql");
     917        if (!query_updated) {
     918            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    886919            return false;
    887920        }
    … …  
    890923            psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    891924            psStringAppend(&query, " AND %s", whereClause);
     925            psStringAppend(&query_updated, " AND %s", whereClause);
    892926            psFree(whereClause);
    893927        }
    … …  
    896930            psError(PS_ERR_UNKNOWN, false, "database error");
    897931            psFree(query);
    898             if (!psDBRollback(config->dbh)) {
    899                 psError(PS_ERR_UNKNOWN, false, "database error");
    900             }
    901932            return false;
    902933        }
    903934        psFree(query);
    904 
    905935        psLogMsg("difftool", PS_LOG_INFO, "Deleted %" PRIu64 " rows", psDBAffectedRows(config->dbh));
     936
     937        if (!p_psDBRunQuery(config->dbh, query_updated)) {
     938            psError(PS_ERR_UNKNOWN, false, "database error");
     939            psFree(query_updated);
     940            return false;
     941        }
     942        psFree(query_updated);
     943
     944        psLogMsg("difftool", PS_LOG_INFO, "Updated %" PRIu64 " rows", psDBAffectedRows(config->dbh));
    906945    }
    907946
    908947    psFree(where);
    909948
    910     if (!psDBCommit(config->dbh)) {
    911         psError(PS_ERR_UNKNOWN, false, "database error");
    912         return false;
    913     }
    914949
    915950    return true;
    … …  
    10341069            false,
    10351070            0,       // magicked
     1071            NULL, // software version
     1072            0,    // mask stat npix
     1073            NAN,    // static
     1074            NAN,    // dynamic
     1075            NAN,    // magic
     1076            NAN,    // advisory
    10361077            diff_mode, // diff_mode
    10371078            note
    … …  
    14611502                true,                   // exposure
    14621503                0,       // magicked
     1504                NULL, // software version
     1505                0,    // mask stat npix
     1506                NAN,    // static
     1507                NAN,    // dynamic
     1508                NAN,    // magic
     1509                NAN,    // advisory
    14631510                IPP_DIFF_MODE_WARP_STACK,
    14641511                note
    … …  
    18131860                                          true,  // exposure
    18141861                                          false, // magicked
     1862                                          NULL, // software version
     1863                                          0,    // mask stat npix
     1864                                          NAN,    // static
     1865                                          NAN,    // dynamic
     1866                                          NAN,    // magic
     1867                                          NAN,    // advisory                                   
    18151868                                          IPP_DIFF_MODE_WARP_WARP,
    18161869                                          note); // Run to insert
    … …  
    20952148                                      false,                 // exposure
    20962149                                      0,       // magicked
     2150                                      NULL, // software version
     2151                                      0,    // mask stat npix
     2152                                      NAN,    // static
     2153                                      NAN,    // dynamic
     2154                                      NAN,    // magic
     2155                                      NAN,    // advisory                                   
    20972156                                      IPP_DIFF_MODE_STACK_STACK, // diff_mode
    20982157                                      note
    … …  
    23882447    psMetadata *where = psMetadataAlloc();
    23892448    PXOPT_COPY_S64(config->args, where, "-diff_id",   "diff_id",   "==");
     2449    PXOPT_COPY_STR(config->args, where, "-skycell_id", "skycell_id",   "==");
    23902450
    23912451    if (!pxSetFaultCode(config->dbh, "diffSkyfile", where, fault)) {
    … …  
    27682828    return true;
    27692829}
     2830// a very specfic function to queue a cleaned warpSkyfile to be updated
     2831static bool setskyfiletoupdateMode(pxConfig *config)
     2832{
     2833    PS_ASSERT_PTR_NON_NULL(config, NULL);
     2834
     2835    PXOPT_LOOKUP_S64(diff_id, config->args, "-diff_id", true, false);
     2836    PXOPT_LOOKUP_STR(skycell_id, config->args, "-skycell_id", false, false);
     2837    PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
     2838
     2839    psString query = pxDataGet("difftool_setskyfiletoupdate.sql");
     2840    if (!query) {
     2841        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     2842        return false;
     2843    }
     2844
     2845    psString setHook = psStringCopy("");
     2846    if (label) {
     2847        psStringAppend(&setHook, "\n , diffRun.label = '%s'", label);
     2848    }
     2849
     2850    if (skycell_id) {
     2851        psStringAppend(&query, " AND (diffSkyfile.skycell_id = '%s')", skycell_id);
     2852    }
     2853
     2854    if (!p_psDBRunQueryF(config->dbh, query, setHook, diff_id)) {
     2855        psError(PS_ERR_UNKNOWN, false, "database error");
     2856        return false;
     2857    }
     2858
     2859    psFree(setHook);
     2860    psFree(query);
     2861
     2862    return true;
     2863}

  • branches/czw_branch/20100427/ippTools/src/difftool.h

    r27743 r28017  
    4848    DIFFTOOL_MODE_TOSCRUBBEDSKYFILE,
    4949    DIFFTOOL_MODE_TOFULLSKYFILE,
    50     DIFFTOOL_MODE_LISTRUN
     50    DIFFTOOL_MODE_LISTRUN,
     51    DIFFTOOL_MODE_SETSKYFILETOUPDATE,
    5152} difftoolMode;
    5253

  • branches/czw_branch/20100427/ippTools/src/difftoolConfig.c

    r27784 r28017  
    132132    psMetadataAddStr(adddiffskyfileArgs, PS_LIST_TAIL, "-ver_ppsub", 0, "define ppSub version", NULL);
    133133    psMetadataAddStr(adddiffskyfileArgs, PS_LIST_TAIL, "-ver_streaks", 0, "define streaksremove version", NULL);
    134    
     134    psMetadataAddS32(adddiffskyfileArgs, PS_LIST_TAIL, "-maskfrac_npix", 0, "define number of pixels used for maskstats", 0);
     135    psMetadataAddF32(adddiffskyfileArgs, PS_LIST_TAIL, "-maskfrac_static", 0, "define static mask fraction", NAN);
     136    psMetadataAddF32(adddiffskyfileArgs, PS_LIST_TAIL, "-maskfrac_dynamic", 0, "define dynamic mask fraction", NAN);
     137    psMetadataAddF32(adddiffskyfileArgs, PS_LIST_TAIL, "-maskfrac_magic", 0, "define magic mask fraction", NAN);
     138    psMetadataAddF32(adddiffskyfileArgs, PS_LIST_TAIL, "-maskfrac_advisory", 0, "define advisory mask fraction", NAN);
     139
    135140    // -advance
    136141    psMetadata *advanceArgs = psMetadataAlloc();
    … …  
    332337    psMetadata *updatediffskyfileArgs = psMetadataAlloc();
    333338    psMetadataAddS64(updatediffskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,      "define diff ID (required)", 0);
    334     psMetadataAddS16(updatediffskyfileArgs, PS_LIST_TAIL, "-fault", 0,         "set fault code (required)", 0);
     339    psMetadataAddS16(updatediffskyfileArgs, PS_LIST_TAIL, "-fault", 0,        "set fault code (required)", 0);
     340    psMetadataAddStr(updatediffskyfileArgs, PS_LIST_TAIL, "-skycell_id", 0,   "search by skycell ID", NULL);
    335341
    336342    // -tocleanedskyfile
    … …  
    354360    psMetadataAddStr(tofullskyfileArgs, PS_LIST_TAIL, "-skycell_id", 0, "skycell ID to update", NULL);
    355361    psMetadataAddS64(tofullskyfileArgs, PS_LIST_TAIL, "-magicked",  0, "define magicked state", 0);
     362
     363    // -setskyfiletoupdate
     364    psMetadata *setskyfiletoupdateArgs = psMetadataAlloc();
     365    psMetadataAddS64(setskyfiletoupdateArgs, PS_LIST_TAIL, "-diff_id", 0,           "search by difftool ID (required)", 0);
     366    psMetadataAddStr(setskyfiletoupdateArgs, PS_LIST_TAIL, "-skycell_id",  0,       "search by tessellation ID", NULL);
     367    psMetadataAddStr(setskyfiletoupdateArgs, PS_LIST_TAIL, "-set_label",  0,        "new value for diffRun.label", NULL);
     368
     369
    356370
    357371    // -exportrun
    … …  
    391405    PXOPT_ADD_MODE("-donecleanup",           "show runs that have been cleaned",     DIFFTOOL_MODE_DONECLEANUP,          donecleanupArgs);
    392406    PXOPT_ADD_MODE("-updatediffskyfile",     "update fault code for a diffskyfile",  DIFFTOOL_MODE_UPDATEDIFFSKYFILE,          updatediffskyfileArgs);
     407    PXOPT_ADD_MODE("-setskyfiletoupdate", "set cleaned skyfile to be updated", DIFFTOOL_MODE_SETSKYFILETOUPDATE, setskyfiletoupdateArgs);
     408
    393409    PXOPT_ADD_MODE("-exportrun",            "export run for import on other database", DIFFTOOL_MODE_EXPORTRUN, exportrunArgs);
    394410    PXOPT_ADD_MODE("-importrun",            "import run from metadata file",           DIFFTOOL_MODE_IMPORTRUN, importrunArgs);

  • branches/czw_branch/20100427/ippTools/src/magicdstool.c

    r27745 r28017  
    572572    // we can transition by query as well
    573573
    574 
    575574    psMetadata *where = psMetadataAlloc();
    576575    PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
    … …  
    12251224    }
    12261225
    1227     psString stateCheck = NULL;
    1228     if (!strcmp(state, "goto_cleaned")) {
    1229         // science cleanup sets runs to goto_cleaned. Don't undo it if already cleaned
    1230         psStringAppend(&stateCheck, " AND magicDSRun.state != 'cleaned'");
    1231     }
    1232 
    1233 
    12341226    psString query = NULL;
    12351227    psStringAppend(&query, "UPDATE magicDSRun SET state = '%s' %s\n", state, extraSetStr ? extraSetStr : "");
    … …  
    12411233        psFree(whereClause);
    12421234    } else {
    1243         psError(PS_ERR_UNKNOWN, true, "search arugments are required");
    1244         return false;
    1245     }
    1246 
    1247     if (stateCheck) {
    1248         psStringAppend(&query, stateCheck);
    1249     }
    1250     psFree(stateCheck);
     1235        psError(PS_ERR_UNKNOWN, true, "search arguments are required");
     1236        return false;
     1237    }
     1238
     1239    if (!strcmp(state, "goto_cleaned")) {
     1240        // Don't set state back to goto_cleaned if it is already cleaned
     1241        psStringAppend(&query, " AND (magicDSRun.state != 'cleaned')");
     1242
     1243        // don't clean up magicDSRun's where stage is camera
     1244        psStringAppend(&query, " AND (magicDSRun.stage != 'camera')");
     1245    }
     1246
    12511247    if (!p_psDBRunQuery(config->dbh, query)) {
    12521248        psError(PS_ERR_UNKNOWN, false,

  • branches/czw_branch/20100427/ippTools/src/magictool.c

    r27274 r28017  
    4848static bool maskMode(pxConfig *config);
    4949static bool censorrunMode(pxConfig *config);
     50static bool exposureMode(pxConfig *config);
    5051
    5152static bool setmagicRunState(pxConfig *config, psS64 magic_id, const char *state);
    … …  
    8788        MODECASE(MAGICTOOL_MODE_MASK,                maskMode);
    8889        MODECASE(MAGICTOOL_MODE_CENSORRUN,           censorrunMode);
     90        MODECASE(MAGICTOOL_MODE_EXPOSURE,            exposureMode);
    8991        default:
    9092            psAbort("invalid option (this should not happen)");
    … …  
    15141516    return true;
    15151517}
     1518
     1519
     1520static bool exposureMode(pxConfig *config)
     1521{
     1522    PS_ASSERT_PTR_NON_NULL(config, false);
     1523
     1524    psMetadata *where = psMetadataAlloc();
     1525    PXOPT_COPY_S64(config->args, where, "-magic_id", "magicRun.magic_id", "==");
     1526    PXOPT_COPY_BOOL(config->args, where, "-inverse", "magicRun.inverse", "==");
     1527
     1528    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1529
     1530    psString query = pxDataGet("magictool_exposure.sql");
     1531    if (!query) {
     1532        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1533        return false;
     1534    }
     1535
     1536    psString whereClause = psStringCopy(""); // WHERE restrictions
     1537    if (psListLength(where->list)) {
     1538        psString clause = psDBGenerateWhereConditionSQL(where, NULL);
     1539        psStringAppend(&whereClause, "\nWHERE %s", clause);
     1540        psFree(clause);
     1541    }
     1542    psFree(where);
     1543
     1544    if (!p_psDBRunQueryF(config->dbh, query, whereClause, whereClause)) {
     1545        psError(PS_ERR_UNKNOWN, false, "database error");
     1546        psFree(query);
     1547        return false;
     1548    }
     1549    psFree(query);
     1550
     1551    psArray *output = p_psDBFetchResult(config->dbh);
     1552    if (!output) {
     1553        psErrorCode err = psErrorCodeLast();
     1554        switch (err) {
     1555            case PS_ERR_DB_CLIENT:
     1556                psError(PXTOOLS_ERR_SYS, false, "database error");
     1557                break;
     1558            case PS_ERR_DB_SERVER:
     1559                psError(PXTOOLS_ERR_PROG, false, "database error");
     1560                break;
     1561            default:
     1562                psError(PXTOOLS_ERR_PROG, false, "unknown error");
     1563                break;
     1564        }
     1565        return false;
     1566    }
     1567    if (!psArrayLength(output)) {
     1568        psTrace("magictool", PS_LOG_INFO, "no rows found");
     1569        psFree(output);
     1570        return true;
     1571    }
     1572
     1573    if (!ippdbPrintMetadatas(stdout, output, "magicMask", !simple)) {
     1574        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1575        psFree(output);
     1576        return false;
     1577    }
     1578    psFree(output);
     1579
     1580    return true;
     1581}

  • branches/czw_branch/20100427/ippTools/src/magictool.h

    r24883 r28017  
    4242    MAGICTOOL_MODE_MASK,
    4343    MAGICTOOL_MODE_CENSORRUN,
     44    MAGICTOOL_MODE_EXPOSURE,
    4445} MAGICtoolMode;
    4546

  • branches/czw_branch/20100427/ippTools/src/magictoolConfig.c

    r27274 r28017  
    168168    psMetadataAddS64(censorrunArgs, PS_LIST_TAIL, "-exp_id", 0, "define exposure ID", 0);
    169169    psMetadataAddStr(censorrunArgs, PS_LIST_TAIL, "-label",       0, "define label", NULL);
     170
     171    // -exposure
     172    psMetadata *exposureArgs = psMetadataAlloc();
     173    psMetadataAddS64(exposureArgs, PS_LIST_TAIL, "-magic_id", 0, "define magictool ID", 0);
     174    psMetadataAddBool(exposureArgs, PS_LIST_TAIL, "-inverse", 0, "select the inverse subtraction?", false);
     175    psMetadataAddBool(exposureArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    170176
    171177    psFree(now);
    … …  
    191197    PXOPT_ADD_MODE("-mask",                "", MAGICTOOL_MODE_MASK,                maskArgs);
    192198    PXOPT_ADD_MODE("-censorrun",           "", MAGICTOOL_MODE_CENSORRUN,           censorrunArgs);
     199    PXOPT_ADD_MODE("-exposure",            "", MAGICTOOL_MODE_EXPOSURE,            exposureArgs);
    193200
    194201    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {

  • branches/czw_branch/20100427/ippTools/src/pstamptool.c

    r27740 r28017  
    4040static bool updatereqMode(pxConfig *config);
    4141static bool revertreqMode(pxConfig *config);
     42static bool pendingcleanupMode(pxConfig *config);
    4243static bool addjobMode(pxConfig *config);
    4344static bool listjobMode(pxConfig *config);
    … …  
    8182        MODECASE(PSTAMPTOOL_MODE_UPDATEREQ, updatereqMode);
    8283        MODECASE(PSTAMPTOOL_MODE_REVERTREQ, revertreqMode);
     84        MODECASE(PSTAMPTOOL_MODE_PENDINGCLEANUP, pendingcleanupMode);
    8385        MODECASE(PSTAMPTOOL_MODE_ADDJOB, addjobMode);
    8486        MODECASE(PSTAMPTOOL_MODE_LISTJOB, listjobMode);
    … …  
    265267        NULL,   // outProduct
    266268        uri,
     269        NULL,   // outdir
    267270        0       // fault
    268271        )) {
    … …  
    301304    }
    302305    psFree(where);
     306
     307    psStringAppend(&query, " ORDER BY priority DESC, req_id");
    303308
    304309    // treat limit == 0 as "no limit"
    … …  
    339344}
    340345
    341 static bool listreqMode(pxConfig *config)
     346static bool pendingcleanupMode(pxConfig *config)
    342347{
    343348    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    345350    psMetadata *where = psMetadataAlloc();
    346351    PXOPT_COPY_S64(config->args, where, "-req_id", "req_id", "==");
    347     PXOPT_COPY_S64(config->args, where, "-not_req_id", "req_id", "!=");
    348     PXOPT_COPY_STR(config->args, where, "-name", "name", "==");
    349 
    350     PXOPT_LOOKUP_U64(limit,   config->args, "-limit",  false, false);
     352    pxAddLabelSearchArgs(config, where, "-label", "label", "LIKE");
     353
     354    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    351355    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    352356
    353     if (!psListLength(where->list)) {
    354         psError(PS_ERR_UNKNOWN, true, "-req_id or -name must be supplied");
    355         return false;
    356     }
    357 
    358     psString query = psStringCopy("SELECT * from pstampRequest");
    359 
    360     psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    361     psStringAppend(&query, " WHERE %s", whereClause);
    362     psFree(whereClause);
    363     psFree(where);
     357    psString query = pxDataGet("pstamptool_pendingcleanup.sql");
     358    if (!query) {
     359        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     360        return false;
     361    }
     362
     363    if (psListLength(where->list)) {
     364        psString whereClause = psDBGenerateWhereConditionSQL(where, "pstampRequest");
     365        psStringAppend(&query, " AND %s", whereClause);
     366        psFree(whereClause);
     367    }
     368    psFree(where);
     369
     370    psStringAppend(&query, " ORDER BY priority DESC, req_id");
    364371
    365372    // treat limit == 0 as "no limit"
    … …  
    383390    }
    384391    if (!psArrayLength(output)) {
    385         psTrace("pstamptool", PS_LOG_INFO, "request not found");
    386         // This causes main to exit with PS_EXIT_DATA_ERROR which the script is looking for
    387         psError(PXTOOLS_ERR_CONFIG, true, "request not found");
    388         psFree(output);
    389         // we return false so that the caller can determine that a request does not exist
    390         return false;
     392        psTrace("pstamptool", PS_LOG_INFO, "no rows found");
     393        psFree(output);
     394        return true;
    391395    }
    392396
    … …  
    403407}
    404408
    405 static bool completedreqMode(pxConfig *config)
    406 {
    407     PS_ASSERT_PTR_NON_NULL(config, false);
    408 
    409     psMetadata *where = psMetadataAlloc();
    410     pxAddLabelSearchArgs(config, where, "-label", "label", "LIKE");
    411 
    412     PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     409static bool listreqMode(pxConfig *config)
     410{
     411    PS_ASSERT_PTR_NON_NULL(config, false);
     412
     413    psMetadata *where = psMetadataAlloc();
     414    PXOPT_COPY_S64(config->args, where, "-req_id", "req_id", "==");
     415    PXOPT_COPY_S64(config->args, where, "-not_req_id", "req_id", "!=");
     416    PXOPT_COPY_STR(config->args, where, "-name", "name", "==");
     417
     418    PXOPT_LOOKUP_U64(limit,   config->args, "-limit",  false, false);
    413419    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    414420
    415     psString query = pxDataGet("pstamptool_completedreq.sql");
    416 
    417     if (psListLength(where->list)) {
    418         psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    419         psStringAppend(&query, " AND %s", whereClause);
    420         psFree(whereClause);
    421     }
     421    if (!psListLength(where->list)) {
     422        psError(PS_ERR_UNKNOWN, true, "-req_id or -name must be supplied");
     423        return false;
     424    }
     425
     426    psString query = psStringCopy("SELECT * from pstampRequest");
     427
     428    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     429    psStringAppend(&query, " WHERE %s", whereClause);
     430    psFree(whereClause);
    422431    psFree(where);
    423432
    … …  
    434443        return false;
    435444    }
     445    psFree(query);
    436446
    437447    psArray *output = p_psDBFetchResult(config->dbh);
    … …  
    440450        return false;
    441451    }
    442 
    443452    if (!psArrayLength(output)) {
    444         psTrace("pstamptool", PS_LOG_INFO, "no rows found");
    445         psFree(output);
    446         return true;
     453        psTrace("pstamptool", PS_LOG_INFO, "request not found");
     454        // This causes main to exit with PS_EXIT_DATA_ERROR which the script is looking for
     455        psError(PXTOOLS_ERR_CONFIG, true, "request not found");
     456        psFree(output);
     457        // we return false so that the caller can determine that a request does not exist
     458        return false;
    447459    }
    448460
    … …  
    459471}
    460472
     473static bool completedreqMode(pxConfig *config)
     474{
     475    PS_ASSERT_PTR_NON_NULL(config, false);
     476
     477    psMetadata *where = psMetadataAlloc();
     478    pxAddLabelSearchArgs(config, where, "-label", "label", "LIKE");
     479
     480    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     481    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     482
     483    psString query = pxDataGet("pstamptool_completedreq.sql");
     484
     485    if (psListLength(where->list)) {
     486        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     487        psStringAppend(&query, " AND %s", whereClause);
     488        psFree(whereClause);
     489    }
     490    psFree(where);
     491
     492    psStringAppend(&query, " ORDER BY priority DESC, req_id");
     493
     494    // treat limit == 0 as "no limit"
     495    if (limit) {
     496        psString limitString = psDBGenerateLimitSQL(limit);
     497        psStringAppend(&query, " %s", limitString);
     498        psFree(limitString);
     499    }
     500
     501    if (!p_psDBRunQuery(config->dbh, query)) {
     502        psError(PS_ERR_UNKNOWN, false, "database error");
     503        psFree(query);
     504        return false;
     505    }
     506
     507    psArray *output = p_psDBFetchResult(config->dbh);
     508    if (!output) {
     509        psError(PS_ERR_UNKNOWN, false, "database error");
     510        return false;
     511    }
     512
     513    if (!psArrayLength(output)) {
     514        psTrace("pstamptool", PS_LOG_INFO, "no rows found");
     515        psFree(output);
     516        return true;
     517    }
     518
     519    // negative simple so the default is true
     520    if (!ippdbPrintMetadatas(stdout, output, "pstampRequest", !simple)) {
     521        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     522        psFree(output);
     523        return false;
     524    }
     525
     526    psFree(output);
     527
     528    return true;
     529}
     530
    461531static bool updatereqMode(pxConfig *config)
    462532{
    463533    PS_ASSERT_PTR_NON_NULL(config, false);
    464534
    465     PXOPT_LOOKUP_S64(req_id,     config->args, "-req_id",     true, false);
    466     PXOPT_LOOKUP_STR(state,      config->args, "-state",      false, false);
    467     PXOPT_LOOKUP_STR(outProduct, config->args, "-outProduct", false, false);
    468     PXOPT_LOOKUP_S16(fault,      config->args, "-fault",      false, false);
    469     PXOPT_LOOKUP_STR(uri,        config->args, "-uri",        false, false);
    470     PXOPT_LOOKUP_STR(name,       config->args, "-name",       false, false);
    471     PXOPT_LOOKUP_STR(reqType,    config->args, "-reqType",    false, false);
    472 
    473     psString query = NULL;
    474     psStringAppend(&query, "UPDATE pstampRequest SET");
    475 
     535    // PXOPT_LOOKUP_S64(req_id,     config->args, "-req_id",   true, false);
     536    PXOPT_LOOKUP_STR(state,      config->args, "-set_state",      false, false);
     537    PXOPT_LOOKUP_STR(label,      config->args, "-set_label",      false, false);
     538    PXOPT_LOOKUP_STR(outProduct, config->args, "-set_outProduct", false, false);
     539    PXOPT_LOOKUP_S16(fault,      config->args, "-set_fault",          false, false);
     540    PXOPT_LOOKUP_STR(uri,        config->args, "-set_uri",        false, false);
     541    PXOPT_LOOKUP_STR(outdir,     config->args, "-set_outdir",        false, false);
     542    PXOPT_LOOKUP_STR(name,       config->args, "-set_name",       false, false);
     543    PXOPT_LOOKUP_STR(reqType,    config->args, "-set_reqType",    false, false);
     544    PXOPT_LOOKUP_BOOL(clearfault,config->args, "-clearfault",    false);
     545
     546    psMetadata *where = psMetadataAlloc();
     547    PXOPT_COPY_S64(config->args, where, "-req_id",     "req_id", "==");
     548    PXOPT_COPY_S64(config->args, where, "-req_id_max", "req_id", "<=");
     549    PXOPT_COPY_S32(config->args, where, "-fault",      "fault", "==");
     550    PXOPT_COPY_STR(config->args, where, "-state",      "state", "==");
     551    pxAddLabelSearchArgs(config, where, "-label",      "pstampRequest.label", "LIKE");
     552    if (!psListLength(where->list)) {
     553        psFree(where);
     554        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     555        return false;
     556    }
     557
     558    psString query = psStringCopy("UPDATE pstampRequest SET");
     559
     560    psString stateCheck = NULL;
    476561    char c = ' ';
    477562    if (state) {
    478563        psStringAppend(&query, "%c state = '%s'", c, state);
    479564        c = ',';
     565        if (!strcmp(state, "goto_cleaned")) {
     566            psStringAppend(&stateCheck, " AND state != 'cleaned'");
     567        }
     568    }
     569    if (label) {
     570        psStringAppend(&query, "%c label = '%s'", c, label);
     571        c = ',';
    480572    }
    481573    if (outProduct) {
    … …  
    483575        c = ',';
    484576    }
    485     if (fault) {
     577    if (outdir) {
     578        psStringAppend(&query, "%c outdir = '%s'", c, outdir);
     579        c = ',';
     580    }
     581    if (clearfault) {
     582        if (fault) {
     583            psError(PXTOOLS_ERR_CONFIG, true, "only one of -fault and -clearfault is allowed");
     584            return false;
     585        }
     586        psStringAppend(&query, "%c fault = 0", c);
     587        c = ',';
     588    } else if (fault) {
    486589        psStringAppend(&query, "%c fault = %d", c, fault);
    487590        c = ',';
    … …  
    499602        c = ',';
    500603    }
    501     if (!state && !outProduct && !fault && !uri && !name && !reqType) {
    502         psError(PS_ERR_UNKNOWN, true, "at least one of state, outProduct, fault, uri, name, and reqType must be specified");
    503         return false;
    504     }
    505 
    506     psStringAppend(&query, " WHERE req_id = %" PRId64, req_id);
     604    if (c != ',') {
     605        psError(PS_ERR_UNKNOWN, true, "at least one set option is required");
     606        return false;
     607    }
     608
     609    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     610    psStringAppend(&query, "\nWHERE %s", whereClause);
     611    psFree(whereClause);
     612    psFree(where);
     613
     614    if (stateCheck) {
     615        psStringAppend(&query, "%s", stateCheck);
     616    }
    507617
    508618    if (!p_psDBRunQuery(config->dbh, query)) {
    … …  
    512622    }
    513623
    514     psU64 affected = psDBAffectedRows(config->dbh);
    515     // note zero is not an error
    516     if (affected > 1) {
    517         psError(PS_ERR_UNKNOWN, false, "should have affected one row but %"
    518                                         PRIu64 " rows were modified", affected);
    519         return false;
    520     }
     624    // psU64 affected = psDBAffectedRows(config->dbh);
     625    // psLogMsg("pstamptool", PS_LOG_INFO, "Updated %" PRIu64 " pstampRequests", affected);
    521626
    522627    return true;
    … …  
    530635
    531636    PXOPT_COPY_S64(config->args, where, "-req_id", "req_id", "==");
    532     PXOPT_COPY_S64(config->args, where, "-fault", "req_id", "==");
     637    PXOPT_COPY_S64(config->args, where, "-fault", "fault", "==");
    533638    PXOPT_COPY_STR(config->args, where, "-state", "pstampRequest.state", "==");
    534639    pxAddLabelSearchArgs(config, where, "-label", "pstampRequest.label", "LIKE");
    … …  
    705810    PXOPT_COPY_S64(config->args, where, "-job_id", "job_id", "==");
    706811    PXOPT_COPY_S64(config->args, where, "-req_id", "req_id", "==");
    707     pxAddLabelSearchArgs(config, where, "-label", "label", "LIKE");
     812    pxAddLabelSearchArgs(config, where, "-label", "pstampRequest.label", "LIKE");
    708813
    709814    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    … …  
    724829    psFree(where);
    725830
     831    psStringAppend(&query, " ORDER BY priority DESC, req_id");
     832
    726833    // treat limit == 0 as "no limit"
    727834    if (limit) {
    … …  
    772879        return false;
    773880    }
    774     PXOPT_LOOKUP_STR(state,     config->args, "-state",  true, false);
    775     PXOPT_LOOKUP_S32(fault,     config->args, "-fault",  false, false);
     881
     882    PXOPT_LOOKUP_STR(state,     config->args, "-set_state",  false, false);
     883    PXOPT_LOOKUP_S32(fault,     config->args, "-set_fault",  false, false);
     884   
     885    if (!state && !fault) {
     886        psError(PS_ERR_UNKNOWN, true, "at least one of -set_state and -set_fault is required");
     887        return false;
     888    }
    776889
    777890    psMetadata *where = psMetadataAlloc();
    … …  
    780893    PXOPT_COPY_S64(config->args, where, "-dep_id", "dep_id", "==");
    781894
    782     psString faultStr = NULL;
    783     if (!fault) {
    784         faultStr = psStringCopy("");
    785     } else {
    786         psStringAppend(&faultStr, "\n, pstampJob.fault = %d", fault);
    787     }
    788 
    789895    psString query = pxDataGet("pstamptool_updatejob.sql");
    790896
     897    char c = ' ';
     898    if (state) {
     899        psStringAppend(&query, "\n %c pstampJob.state = '%s'", c, state);
     900        c = ',';
     901    }
     902    if (fault) {
     903        psStringAppend(&query, "\n %c pstampJob.fault = %d", c, fault);
     904        c = ',';
     905    }
     906   
    791907    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    792908    psStringAppend(&query, " WHERE %s", whereClause);
    … …  
    794910    psFree(where);
    795911
    796     if (!p_psDBRunQueryF(config->dbh, query, state, faultStr)) {
     912    if (!p_psDBRunQuery(config->dbh, query)) {
    797913        psError(PS_ERR_UNKNOWN, false, "database error");
    798914        psFree(query);
    799915        return false;
    800916    }
    801     psFree(faultStr);
    802917    psFree(query);
    803918
    … …  
    9671082    PXOPT_LOOKUP_STR(component,   config->args, "-component",  true, false);
    9681083    PXOPT_LOOKUP_STR(imagedb,     config->args, "-imagedb",  true, false);
    969     PXOPT_LOOKUP_STR(rlabel,      config->args, "-rlabel",  false, false);
     1084    PXOPT_LOOKUP_STR(rlabel,      config->args, "-rlabel",  true, false);
     1085    PXOPT_LOOKUP_STR(outdir,      config->args, "-outdir",  true, false);
    9701086    PXOPT_LOOKUP_BOOL(need_magic, config->args, "-need_magic", false);
    9711087    PXOPT_LOOKUP_BOOL(no_create,  config->args, "-no_create", false);
    … …  
    9831099    }
    9841100
    985     psString query = pxDataGet("pstamptool_pendingdependent.sql");
     1101    psString query = pxDataGet("pstamptool_getdependent.sql");
    9861102    if (!query) {
    9871103        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    … …  
    10461162        rlabel,
    10471163        need_magic,
     1164        outdir,
    10481165        0               // fault
    10491166        )) {
    … …  
    10871204    PXOPT_COPY_STR(config->args, where, "-imagedb", "imagedb", "==");
    10881205    PXOPT_COPY_S64(config->args, where, "-stage_id", "stage_id", "==");
     1206    PXOPT_COPY_S64(config->args, where, "-dep_id", "dep_id", "==");
    10891207    PXOPT_COPY_STR(config->args, where, "-rlabel", "rlabel", "==");
    10901208    pxAddLabelSearchArgs(config, where, "-label", "pstampRequest.label", "==");
    … …  
    11051223    }
    11061224    psFree(where);
     1225
     1226    psStringAppend(&query, " ORDER BY priority DESC, req_id");
    11071227
    11081228    // treat limit == 0 as "no limit"
    … …  
    11481268    PXOPT_LOOKUP_S64(dep_id,    config->args, "-dep_id", true, false);
    11491269    PXOPT_LOOKUP_STR(state,     config->args, "-set_state",  false, false);
    1150     PXOPT_LOOKUP_S16(fault,     config->args, "-fault",  false, false);
     1270    PXOPT_LOOKUP_S16(fault,     config->args, "-set_fault",  false, false);
    11511271
    11521272    if (!fault && !state) {
    … …  
    11861306
    11871307    psMetadata *where = psMetadataAlloc();
    1188     PXOPT_COPY_S64(config->args, where, "-fault", "req_id", "==");
     1308    PXOPT_COPY_S64(config->args, where, "-fault", "pstampDependent.fault", "==");
    11891309    PXOPT_COPY_S64(config->args, where, "-dep_id", "dep_id", "==");
    11901310    pxAddLabelSearchArgs(config, where, "-label", "pstampRequest.label", "==");
    … …  
    12011321    }
    12021322
    1203     psString whereClause = psDBGenerateWhereSQL(where, NULL);
    1204     psStringAppend(&query, " %s", whereClause);
     1323    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1324    psStringAppend(&query, " AND %s", whereClause);
    12051325    psFree(whereClause);
    12061326    psFree(where);

  • branches/czw_branch/20100427/ippTools/src/pstamptool.h

    r27740 r28017  
    3434    PSTAMPTOOL_MODE_UPDATEREQ,
    3535    PSTAMPTOOL_MODE_REVERTREQ,
     36    PSTAMPTOOL_MODE_PENDINGCLEANUP,
    3637    PSTAMPTOOL_MODE_ADDJOB,
    3738    PSTAMPTOOL_MODE_LISTJOB,

  • branches/czw_branch/20100427/ippTools/src/pstamptoolConfig.c

    r27740 r28017  
    9898    // -updatereq
    9999    psMetadata *updatereqArgs = psMetadataAlloc();
    100     psMetadataAddS64(updatereqArgs, PS_LIST_TAIL, "-req_id", 0,            "req_id for which to change state", 0);
    101     psMetadataAddStr(updatereqArgs, PS_LIST_TAIL, "-state", 0,            "new state", NULL);
    102     psMetadataAddStr(updatereqArgs, PS_LIST_TAIL, "-outProduct", 0,            "define request outProduct", NULL);
    103     psMetadataAddS16(updatereqArgs, PS_LIST_TAIL, "-fault", 0,            "define request fault code", 0);
    104     psMetadataAddStr(updatereqArgs, PS_LIST_TAIL, "-uri", 0,            "define the uri", NULL);
    105     psMetadataAddStr(updatereqArgs, PS_LIST_TAIL, "-name", 0,            "define the name", NULL);
    106     psMetadataAddStr(updatereqArgs, PS_LIST_TAIL, "-reqType", 0,            "define the reqType", NULL);
     100    psMetadataAddS64(updatereqArgs, PS_LIST_TAIL, "-req_id", 0,       "req_id for which to update", 0);
     101    psMetadataAddS64(updatereqArgs, PS_LIST_TAIL, "-req_id_max", 0,   "maximum req_id for which to update", 0);
     102    psMetadataAddS16(updatereqArgs, PS_LIST_TAIL, "-fault", 0,        "search by fault code", 0);
     103    psMetadataAddStr(updatereqArgs, PS_LIST_TAIL, "-state", 0,        "search by state", NULL);
     104    psMetadataAddStr(updatereqArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by pstampJob label (LIKE comparision)", NULL);
     105    psMetadataAddStr(updatereqArgs, PS_LIST_TAIL, "-set_state", 0,        "new state", NULL);
     106    psMetadataAddStr(updatereqArgs, PS_LIST_TAIL, "-set_label", 0,        "new label", NULL);
     107    psMetadataAddStr(updatereqArgs, PS_LIST_TAIL, "-set_outProduct", 0,   "new outProduct", NULL);
     108    psMetadataAddStr(updatereqArgs, PS_LIST_TAIL, "-set_outdir", 0,   "new outdir", NULL);
     109    psMetadataAddS16(updatereqArgs, PS_LIST_TAIL, "-set_fault", 0,        "new fault code", 0);
     110    psMetadataAddStr(updatereqArgs, PS_LIST_TAIL, "-set_uri", 0,          "new uri", NULL);
     111    psMetadataAddStr(updatereqArgs, PS_LIST_TAIL, "-set_name", 0,         "new name", NULL);
     112    psMetadataAddStr(updatereqArgs, PS_LIST_TAIL, "-set_reqType", 0,      "new reqType", NULL);
     113    psMetadataAddBool(updatereqArgs, PS_LIST_TAIL, "-clearfault", 0,      "set fault to zero", false);
    107114
    108115    // -revertreq
    … …  
    112119    psMetadataAddStr(revertreqArgs, PS_LIST_TAIL, "-state", 0,      "state to revert", NULL);
    113120    psMetadataAddStr(revertreqArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by pstampRequest label (LIKE comparision)", NULL);
     121
     122    // -pendingcleanup
     123    psMetadata *pendingcleanupArgs = psMetadataAlloc();
     124    psMetadataAddS64(pendingcleanupArgs, PS_LIST_TAIL, "-req_id", 0,   "define req_id", 0);
     125    psMetadataAddS64(pendingcleanupArgs, PS_LIST_TAIL, "-ds_id", 0,    "define ds_id", 0);
     126    psMetadataAddStr(pendingcleanupArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by pstampRequest label (LIKE comparision)", NULL);
     127    psMetadataAddU64(pendingcleanupArgs, PS_LIST_TAIL, "-limit",  0,   "limit result set to N items", 0);
     128    psMetadataAddBool(pendingcleanupArgs, PS_LIST_TAIL, "-simple", 0,  "use the simple output format", false);
    114129
    115130    // -addjob
    … …  
    145160    psMetadataAddS64(updatejobArgs, PS_LIST_TAIL, "-job_id", 0,            "req_id for which to change state", 0);
    146161    psMetadataAddS64(updatejobArgs, PS_LIST_TAIL, "-dep_id", 0,            "dep_id for which to change state", 0);
    147     psMetadataAddStr(updatejobArgs, PS_LIST_TAIL, "-state", 0,            "new state", NULL);
    148     psMetadataAddS16(updatejobArgs, PS_LIST_TAIL, "-fault", 0,            "new result", 0);
     162    psMetadataAddStr(updatejobArgs, PS_LIST_TAIL, "-set_state", 0,            "new state", NULL);
     163    psMetadataAddS16(updatejobArgs, PS_LIST_TAIL, "-set_fault", 0,            "new result", 0);
    149164
    150165    // -revertjob
    … …  
    160175    // -getdependent
    161176    psMetadata *getdependentArgs = psMetadataAlloc();
    162     psMetadataAddS64(getdependentArgs, PS_LIST_TAIL, "-stage_id", 0, "define id for dependent (required)", 0);
     177    // arguabely all of these could be -set_ arguments, but since this mode is both a query and
     178    // a create if doesn't exist I like it this way
     179    psMetadataAddS64(getdependentArgs, PS_LIST_TAIL, "-stage_id", 0, "define stage id for dependent (required)", 0);
    163180    psMetadataAddStr(getdependentArgs, PS_LIST_TAIL, "-stage", 0,    "define stage for dependent (required)", NULL);
    164181    psMetadataAddStr(getdependentArgs, PS_LIST_TAIL, "-component", 0, "define component for depenent (required)", NULL);
    … …  
    166183    psMetadataAddStr(getdependentArgs, PS_LIST_TAIL, "-rlabel", 0,   "define label for dependent ", NULL);
    167184    psMetadataAddBool(getdependentArgs,PS_LIST_TAIL, "-need_magic", 0, "define need_magic", false);
     185    psMetadataAddStr(getdependentArgs, PS_LIST_TAIL, "-outdir", 0,    "define output directory for dependent (required)", NULL);
    168186    psMetadataAddBool(getdependentArgs,PS_LIST_TAIL, "-no_create", 0, "if no matching dependent do not create one", false);
    169187
    … …  
    172190    psMetadataAddS64(updatedependentArgs, PS_LIST_TAIL, "-dep_id", 0, "define id for dependent (required)", 0);
    173191    psMetadataAddStr(updatedependentArgs, PS_LIST_TAIL, "-set_state", 0, "new value for state", NULL);
    174     psMetadataAddS16(updatedependentArgs, PS_LIST_TAIL, "-fault",  0,   "new value for fault", 0);
     192    psMetadataAddS16(updatedependentArgs, PS_LIST_TAIL, "-set_fault",  0,   "new value for fault", 0);
    175193
    176194    // -revertdependent
    177195    psMetadata *revertdependentArgs = psMetadataAlloc();
    178196    psMetadataAddS64(revertdependentArgs, PS_LIST_TAIL, "-dep_id", 0, "define id for dependent", 0);
    179     psMetadataAddS16(revertdependentArgs, PS_LIST_TAIL, "-fault",  0,   "new value for fault", 0);
     197    psMetadataAddStr(revertdependentArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK,   "define label for dependent ", NULL);
     198    psMetadataAddS16(revertdependentArgs, PS_LIST_TAIL, "-fault",  0,   "define fault", 0);
    180199
    181200    // -pendingdependent
    … …  
    184203    psMetadataAddStr(pendingdependentArgs, PS_LIST_TAIL, "-stage", 0,    "define stage for dependent", NULL);
    185204    psMetadataAddStr(pendingdependentArgs, PS_LIST_TAIL, "-component", 0,    "define component for dependent", NULL);
     205    psMetadataAddS64(pendingdependentArgs, PS_LIST_TAIL, "-dep_id", 0, "define dep_id for dependent", 0);
    186206    psMetadataAddStr(pendingdependentArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK,   "define label for pstampRequest", NULL);
    187207    psMetadataAddStr(pendingdependentArgs, PS_LIST_TAIL, "-rlabel", 0,   "define label for dependent", NULL);
    … …  
    224244    PXOPT_ADD_MODE("-completedreq",    "", PSTAMPTOOL_MODE_COMPLETEDREQ, completedreqArgs);
    225245    PXOPT_ADD_MODE("-revertreq",       "", PSTAMPTOOL_MODE_REVERTREQ,    revertreqArgs);
     246    PXOPT_ADD_MODE("-pendingcleanup",  "", PSTAMPTOOL_MODE_PENDINGCLEANUP, pendingcleanupArgs);
    226247
    227248    PXOPT_ADD_MODE("-addjob",          "", PSTAMPTOOL_MODE_ADDJOB,       addjobArgs);

  • branches/czw_branch/20100427/ippTools/src/pxcam.c

    r27210 r28017  
    152152                    char *tess_id,
    153153                    char *end_stage,
    154                     psS64 magicked,
     154                    psS64 magicked,
    155155                    char *note)
    156156{
    … …  
    184184                end_stage ? end_stage : "NULL",
    185185                (long long) magicked,
     186                         "NULL", // This shouldn't be propagated
     187                         "NULL",
     188                         "NULL",
     189                         "NULL",
     190                         "NULL",
     191                         "NULL",
    186192                note     ? note     : "NULL",
    187193                (long long)chip_id

  • branches/czw_branch/20100427/ippTools/src/pxchip.c

    r27246 r28017  
    6969    psMetadataAddF64(md,  PS_LIST_TAIL, "-posang_min",         0, "search by min rotator position angle", NAN);
    7070    psMetadataAddF64(md,  PS_LIST_TAIL, "-posang_max",         0, "search by max rotator position angle", NAN);
    71     psMetadataAddF32(md,  PS_LIST_TAIL, "-sun_angle_min",         0, "search by min solar angle", NAN);
    72     psMetadataAddF32(md,  PS_LIST_TAIL, "-sun_angle_max",         0, "search by max solar angle", NAN);
     71    psMetadataAddF32(md,  PS_LIST_TAIL, "-sun_angle_min",      0, "search by min solar angle", NAN);
     72    psMetadataAddF32(md,  PS_LIST_TAIL, "-sun_angle_max",      0, "search by max solar angle", NAN);
    7373    psMetadataAddStr(md,  PS_LIST_TAIL, "-object",             0, "search by exposure object", NULL);
    7474    psMetadataAddStr(md,  PS_LIST_TAIL, "-comment",            0, "search by comment field (LIKE comparison)", NULL);
    75     psMetadataAddStr(md,  PS_LIST_TAIL, "-obs_mode", 0, "search by observation mode", NULL);
     75    psMetadataAddStr(md,  PS_LIST_TAIL, "-obs_mode",           0, "search by observation mode", NULL);
    7676    return true;
    7777}
    … …  
    121121    PXOPT_COPY_F64(config->args, where, "-posang_min", "rawExp.posang", ">=");
    122122    PXOPT_COPY_F64(config->args, where, "-posang_max", "rawExp.posang", "<");
    123     PXOPT_COPY_STR(config->args, where, "-object", "rawExp.object", "==");
     123    PXOPT_COPY_STR(config->args, where, "-object", "rawExp.object", "LIKE");
    124124    PXOPT_COPY_F32(config->args, where, "-sun_angle_min", "rawExp.sun_angle", ">=");
    125125    PXOPT_COPY_F32(config->args, where, "-sun_angle_max", "rawExp.sun_angle", "<");
    … …  
    277277            end_stage,
    278278            0,          // magicked
     279                       NULL,
     280                       0,
     281                       NAN,
     282                       NAN,
     283                       NAN,
     284                       NAN,
    279285            note
    280286            )

  • branches/czw_branch/20100427/ippTools/src/pxtools.c

    r27784 r28017  
    5757  psS32 num2;
    5858  psS32 numO;
     59
     60  if (!version1) {
     61    psStringAppend(&out,version2);
     62    return(out);
     63  }
     64  if (!version2) {
     65    psStringAppend(&out,version1);
     66    return(out);
     67  }
    5968 
    6069  if (strchr(version1,'M')) {
    … …  
    8493}
    8594
    86 
     95bool pxCoalesceRunStatus(pxConfig *config, const psString dbQFile, psS64 stage_id, psString *software_ver,
     96                         psS32 *maskfrac_npix, psF32 *maskfrac_static, psF32 *maskfrac_dynamic,
     97                         psF32 *maskfrac_magic, psF32 *maskfrac_advisory) {
     98  psString query = pxDataGet(dbQFile);
     99/*   psString text_id = NULL; */
     100/*   psStringAppend(&text_id," %" PRId64,stage_id); */
     101/*   psStringSubstitute(&query,text_id,"@STAGE_ID@"); */
     102/*   psFree(text_id); */
     103  if (!p_psDBRunQueryF(config->dbh, query, stage_id)) {
     104    psError(PS_ERR_UNKNOWN, false, "database error");
     105    psFree(query);
     106    return(false);
     107  }
     108  psFree(query);
     109  psArray *output = p_psDBFetchResult(config->dbh);
     110  if (!output) {
     111    psError(PS_ERR_UNKNOWN, false, "database error");
     112    return(false);
     113  }
     114 
     115  for (long i = 0; i < psArrayLength(output); i++) {
     116    psMetadata *row = output->data[i];
     117
     118    psS32 this_npix = psMetadataLookupS32(NULL, row, "maskfrac_npix");
     119    psF32 this_static = psMetadataLookupF32(NULL, row, "maskfrac_static");
     120    psF32 this_dynamic = psMetadataLookupF32(NULL, row, "maskfrac_dynamic");
     121    psF32 this_magic = psMetadataLookupF32(NULL, row, "maskfrac_magic");
     122    psF32 this_advisory = psMetadataLookupF32(NULL, row, "maskfrac_advisory");
     123    psString this_version = psMetadataLookupStr(NULL, row, "software_ver");
     124
     125    *software_ver = pxMergeCodeVersions(*software_ver,this_version);
     126
     127    *maskfrac_static = ((*maskfrac_static * *maskfrac_npix) + (this_npix * this_static)) / (this_npix + *maskfrac_npix);
     128    *maskfrac_dynamic = ((*maskfrac_dynamic * *maskfrac_npix) + (this_npix * this_dynamic)) / (this_npix + *maskfrac_npix);
     129    *maskfrac_magic = ((*maskfrac_magic * *maskfrac_npix) + (this_npix * this_magic)) / (this_npix + *maskfrac_npix);
     130    *maskfrac_advisory = ((*maskfrac_advisory * *maskfrac_npix) + (this_npix * this_advisory)) / (this_npix + *maskfrac_npix);
     131    *maskfrac_npix += this_npix;
     132  }
     133  psFree(output);
     134  return(true);
     135}
     136
     137bool pxSetRunSoftware(pxConfig *config, const psString tableName, const psString stage_id_name, const psS64 stage_id,
     138                      psString software_ver) {
     139  char *query = "UPDATE %s SET software_ver = '%s' WHERE %s = %" PRId64;
     140  printf(query,tableName,software_ver,stage_id_name,stage_id);
     141  if (!p_psDBRunQueryF(config->dbh,query,tableName,software_ver,stage_id_name,stage_id)) {
     142    psError(PS_ERR_UNKNOWN, false,
     143            "failed to set software version for %s %" PRId64,stage_id_name,stage_id);
     144    return(false);
     145  }
     146 
     147  return(true);
     148}
     149bool pxSetRunMaskfrac(pxConfig *config, const psString tableName, const psString stage_id_name, const psS64 stage_id,
     150                      psS32 maskfrac_npix, psF32 maskfrac_static, psF32 maskfrac_dynamic,
     151                      psF32 maskfrac_magic, psF32 maskfrac_advisory) {
     152  char *query = "UPDATE %s SET maskfrac_npix = %d, maskfrac_static = %f, maskfrac_dynamic = %f, maskfrac_magic = %f, maskfrac_advisory = %f WHERE %s = %" PRId64;
     153  if (!p_psDBRunQueryF(config->dbh,query,tableName,maskfrac_npix,maskfrac_static,
     154                       maskfrac_dynamic, maskfrac_magic,maskfrac_advisory,stage_id_name,stage_id)) {
     155    psError(PS_ERR_UNKNOWN, false,
     156            "failed to set maskfrac stats for %s %" PRId64,stage_id_name,stage_id);
     157    return(false);
     158  }
     159 
     160
     161
     162  return(true);
     163}
    87164
    88165// 'scrubbed' is no longer a virtual state equivalent to cleaned, but allows files to be removed

  • branches/czw_branch/20100427/ippTools/src/pxtools.h

    r27391 r28017  
    5353
    5454bool pxIsValidState(const char *state);
     55psString pxMergeCodeVersions(psString version1, psString version2);
     56bool pxCoalesceRunStatus(pxConfig *config, const psString dbQFile, psS64 stage_id, psString *software_ver,
     57                         psS32 *maskfrac_npix, psF32 *maskfrac_static, psF32 *maskfrac_dynamic,
     58                         psF32 *maskfrac_magic, psF32 *maskfrac_advisory);
     59bool pxSetRunSoftware(pxConfig *config, const psString tableName, const psString stage_id_name, const psS64 stage_id,
     60                      psString software_ver);
     61bool pxSetRunMaskfrac(pxConfig *config, const psString tableName, const psString stage_id_name, const psS64 stage_id,
     62                      psS32 maskfrac_npix, psF32 maskfrac_static, psF32 maskfrac_dynamic,
     63                      psF32 maskfrac_magic, psF32 maskfrac_advisory);
     64
    5565bool pxSetStateCleaned(const psString tableName, const psString columnName, psArray *rows);
    5666bool pxAddLabelSearchArgs (pxConfig *config, psMetadata *where, char *field, char *name, char *op);
    … …  
    286296  PXOPT_COPY_PRIMITIVE(from, to, psU64, U64, oldname, newname, comment)
    287297
     298#define PXOPT_COPY_BOOL(from, to, oldname, newname, comment) \
     299  PXOPT_COPY_V(from, to, psBool, Bool, oldname, newname, comment)
    288300
    289301/*** these PXOPT_ADD_WHERE macros are used to construct the default sql elements ***/

  • branches/czw_branch/20100427/ippTools/src/pxwarp.c

    r25835 r28017  
    6060        NULL,      // registered
    6161        0,         // magicked set to zero when created may get updated when warpRun goes to 'full'
     62                       NULL, // version
     63                       0,   // maskfrac_npix
     64                       NAN, // static
     65                       NAN, // dynamic
     66                       NAN, // magic
     67                       NAN, // advisory               
    6268        NULL        // note
    6369    )) {

  • branches/czw_branch/20100427/ippTools/src/stacktool.c

    r27784 r28017  
    370370            tess_id,
    371371            filter,
     372            NULL, // software_ver
    372373            note);
    373374
    … …  
    526527        tess_id,
    527528        filter,
     529        NULL, // software_ver
    528530        note);
    529531
    … …  
    853855    psTrace("czw.test",1,"Received versions: pslib %s psmodules %s psphot %s ppstats %s ppstack %s streaks %s\n",
    854856            ver_pslib,ver_psmodules,ver_psphot,ver_ppstats,ver_ppstack,ver_streaks);
     857    psString software_ver = NULL;
     858    if ((ver_pslib)&&(ver_psmodules)) {
     859      software_ver = pxMergeCodeVersions(ver_pslib,ver_psmodules);
     860    }
     861    if (ver_psphot) {
     862      software_ver = pxMergeCodeVersions(software_ver,ver_psphot);
     863    }
     864    if (ver_ppstats) {
     865      software_ver = pxMergeCodeVersions(software_ver,ver_ppstats);
     866    }
     867    if (ver_ppstack) {
     868      software_ver = pxMergeCodeVersions(software_ver,ver_ppstack);
     869    }
     870    if (ver_streaks) {
     871      software_ver = pxMergeCodeVersions(software_ver,ver_streaks);
     872    }
    855873   
    856874    // default values
    … …  
    893911                               good_frac,
    894912                               fault,
     913                               software_ver,
    895914                               quality
    896 /*                             quality, */
    897 /*                             ver_pslib, */
    898 /*                             ver_psmodules, */
    899 /*                             ver_psphot, */
    900 /*                             ver_ppstats, */
    901 /*                             ver_ppstack, */
    902 /*                             ver_streaks */
    903915          )) {
    904916        if (!psDBRollback(config->dbh)) {
    … …  
    910922
    911923    if (fault == 0) {
     924        // Set stackRun software if we are finished.
     925        if (!pxSetRunSoftware(config, "stackRun", "stack_id", stack_id, software_ver)) {
     926          if (!psDBRollback(config->dbh)) {
     927            psError(PS_ERR_UNKNOWN, false, "database error");
     928          }
     929          psError(PS_ERR_UNKNOWN, false, "failed to set stackRun.software_ver for stack_id: %" PRId64,
     930                  stack_id);
     931          return(false);
     932        }
     933
    912934        if (!setstackRunState(config, stack_id, "full")) {
    913935            if (!psDBRollback(config->dbh)) {

  • branches/czw_branch/20100427/ippTools/src/staticskytool.c

    r27546 r28017  
    107107
    108108    // optional
    109     PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
    110     PXOPT_LOOKUP_STR(data_group, config->args, "-set_data_group", false, false);
    111     PXOPT_LOOKUP_STR(dist_group, config->args, "-set_dist_group", false, false);
    112     PXOPT_LOOKUP_STR(reduction, config->args, "-set_reduction", false, false);
    113     PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
     109    PXOPT_LOOKUP_STR(label,       config->args, "-set_label", false, false);
     110    PXOPT_LOOKUP_STR(data_group,  config->args, "-set_data_group", false, false);
     111    PXOPT_LOOKUP_STR(dist_group,  config->args, "-set_dist_group", false, false);
     112    PXOPT_LOOKUP_STR(reduction,   config->args, "-set_reduction", false, false);
     113    PXOPT_LOOKUP_STR(note,        config->args, "-set_note", false, false);
    114114    PXOPT_LOOKUP_TIME(registered, config->args, "-set_registered", false, false);
    115115
    … …  
    118118
    119119    PXOPT_COPY_F32(config->args, where, "-select_good_frac_min", "stackSumSkyfile.good_frac", ">=");
    120     PXOPT_COPY_STR(config->args, where, "-select_skycell_id", "stackRun.skycell_id", "==");
    121     pxAddLabelSearchArgs(config, where, "-select_label", "stackRun.label", "LIKE");
    122     pxAddLabelSearchArgs(config, where, "-select_filter", "stackRun.filter", "LIKE");
     120    PXOPT_COPY_STR(config->args, where, "-select_skycell_id",    "stackRun.skycell_id",      "==");
     121    pxAddLabelSearchArgs(config, where, "-select_label",         "stackRun.label",            "LIKE");
     122    pxAddLabelSearchArgs(config, where, "-select_filter",        "stackRun.filter",          "LIKE");
    123123
    124124    // these are used to build the HAVING restriction
    125     PXOPT_COPY_S32(config->args, having, "-min_num", "num", ">=");
     125    PXOPT_COPY_S32(config->args, having, "-min_num",    "num",        ">=");
    126126    PXOPT_COPY_S32(config->args, having, "-min_filter", "num_filter", ">=");
    127127

  • branches/czw_branch/20100427/ippTools/src/staticskytoolConfig.c

    r27546 r28017  
    4646
    4747    // -definebyquery
     48    // XXX need a 'ra_min,max', 'dec_min,max' : to do this, we need a table of skycell boundaries
    4849    psMetadata *definebyqueryArgs = psMetadataAlloc();
    49     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_workdir", 0, "define workdir (required)", NULL);
    50     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_label", 0, "define label", NULL);
    51     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_data_group", 0, "define data group", NULL);
    52     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_dist_group", 0, "define dist group", NULL);
    53     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_note", 0, "define note", NULL);
    54     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_reduction", 0, "define reduction", NULL);
     50    psMetadataAddStr(definebyqueryArgs,  PS_LIST_TAIL, "-select_skycell_id", 0, "search for skycell_id", NULL);
     51    psMetadataAddStr(definebyqueryArgs,  PS_LIST_TAIL, "-select_tess_id", 0, "search for tess_id", NULL);
     52    psMetadataAddF32(definebyqueryArgs,  PS_LIST_TAIL, "-select_good_frac_min", 0, "define min good_frac", 0.0);
     53    psMetadataAddStr(definebyqueryArgs,  PS_LIST_TAIL, "-select_label", PS_META_DUPLICATE_OK, "search by stackRun label (LIKE comparison, multiple OK)", NULL);
     54    psMetadataAddStr(definebyqueryArgs,  PS_LIST_TAIL, "-select_filter", PS_META_DUPLICATE_OK, "search by filter (LIKE comparison, multiple OK)", NULL);
     55    psMetadataAddStr(definebyqueryArgs,  PS_LIST_TAIL, "-set_workdir", 0, "define workdir (required)", NULL);
     56    psMetadataAddStr(definebyqueryArgs,  PS_LIST_TAIL, "-set_label", 0, "define label", NULL);
     57    psMetadataAddStr(definebyqueryArgs,  PS_LIST_TAIL, "-set_data_group", 0, "define data group", NULL);
     58    psMetadataAddStr(definebyqueryArgs,  PS_LIST_TAIL, "-set_dist_group", 0, "define dist group", NULL);
     59    psMetadataAddStr(definebyqueryArgs,  PS_LIST_TAIL, "-set_note", 0, "define note", NULL);
     60    psMetadataAddStr(definebyqueryArgs,  PS_LIST_TAIL, "-set_reduction", 0, "define reduction", NULL);
    5561    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-set_registered", 0, "time detrend run was registered", now);
    56     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_skycell_id", 0, "search for skycell_id", NULL);
    57     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_tess_id", 0, "search for tess_id", NULL);
    58     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_good_frac_min", 0, "define min good_frac", 0.0);
    59     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_label", PS_META_DUPLICATE_OK, "search by stackRun label (LIKE comparison, multiple OK)", NULL);
    60     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_filter", PS_META_DUPLICATE_OK, "search by filter (LIKE comparison, multiple OK)", NULL);
    6162    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-pretend",  0, "do not actually modify the database", false);
    6263    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    … …  
    6465    // -updaterun
    6566    psMetadata *updaterunArgs = psMetadataAlloc();
    66     psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-ss_id", 0, "search by stack ID", 0);
     67    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-sky_id", 0, "search by stack ID", 0);
    6768    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0, "search by state", NULL);
    6869    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label", 0, "search by label", 0);
    … …  
    7576    // -inputs
    7677    psMetadata *inputsArgs = psMetadataAlloc();
    77     psMetadataAddS64(inputsArgs, PS_LIST_TAIL, "-ss_id", 0, "search by staticsky ID", 0);
     78    psMetadataAddS64(inputsArgs, PS_LIST_TAIL, "-sky_id", 0, "search by staticsky ID", 0);
    7879    psMetadataAddU64(inputsArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
    7980    psMetadataAddBool(inputsArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    … …  
    8182    // -todo
    8283    psMetadata *todoArgs = psMetadataAlloc();
    83     psMetadataAddS64(todoArgs, PS_LIST_TAIL, "-ss_id", 0, "search by staticsky ID", 0);
     84    psMetadataAddS64(todoArgs, PS_LIST_TAIL, "-sky_id", 0, "search by staticsky ID", 0);
    8485    psMetadataAddStr(todoArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by label", NULL);
    8586    psMetadataAddU64(todoArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
    … …  
    8889    // -addresult
    8990    psMetadata *addresultArgs = psMetadataAlloc();
    90     psMetadataAddS64(addresultArgs, PS_LIST_TAIL, "-ss_id", 0, "define stack ID (required)", 0);
     91    psMetadataAddS64(addresultArgs, PS_LIST_TAIL, "-sky_id", 0, "define stack ID (required)", 0);
    9192    psMetadataAddStr(addresultArgs, PS_LIST_TAIL, "-path_base", 0, "define base output location", 0);
    9293    psMetadataAddF32(addresultArgs, PS_LIST_TAIL, "-dtime_phot", 0, "define photometry time", NAN);
    … …  
    100101    // -result
    101102    psMetadata *resultArgs= psMetadataAlloc();
    102     psMetadataAddS64(resultArgs, PS_LIST_TAIL, "-ss_id", 0, "search by staticsky ID", 0);
     103    psMetadataAddS64(resultArgs, PS_LIST_TAIL, "-sky_id", 0, "search by staticsky ID", 0);
    103104    psMetadataAddStr(resultArgs, PS_LIST_TAIL, "-tess_id", 0, "search by tess ID", 0);
    104105    psMetadataAddStr(resultArgs, PS_LIST_TAIL, "-skycell_id", 0, "search by skycell ID", 0);
    … …  
    111112    // -revert
    112113    psMetadata *revertArgs= psMetadataAlloc();
    113     psMetadataAddS64(revertArgs, PS_LIST_TAIL, "-ss_id", 0, "search by staticsky ID", 0);
     114    psMetadataAddS64(revertArgs, PS_LIST_TAIL, "-sky_id", 0, "search by staticsky ID", 0);
    114115    psMetadataAddStr(revertArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by label", 0);
    115116    psMetadataAddS16(revertArgs, PS_LIST_TAIL, "-fault", 0, "search by fault code", 0);
    … …  
    118119    // -updateresult
    119120    psMetadata *updateresultArgs = psMetadataAlloc();
    120     psMetadataAddS64(updateresultArgs, PS_LIST_TAIL, "-ss_id", 0, "define staticksky ID (required)", 0);
     121    psMetadataAddS64(updateresultArgs, PS_LIST_TAIL, "-sky_id", 0, "define staticksky ID (required)", 0);
    121122    psMetadataAddS16(updateresultArgs, PS_LIST_TAIL, "-fault", 0, "set fault code (required)", 0);
    122123
    123124    // -exportrun
    124125    psMetadata *exportrunArgs = psMetadataAlloc();
    125     psMetadataAddS64(exportrunArgs, PS_LIST_TAIL, "-ss_id", 0, "export this staticsky ID (required)", 0);
     126    psMetadataAddS64(exportrunArgs, PS_LIST_TAIL, "-sky_id", 0, "export this staticsky ID (required)", 0);
    126127    psMetadataAddStr(exportrunArgs, PS_LIST_TAIL, "-outfile", 0, "export to this file (required)", NULL);
    127128    psMetadataAddU64(exportrunArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);

  • branches/czw_branch/20100427/ippTools/src/warptool.c

    r27784 r28017  
    177177            registered,
    178178            0,       // magicked
    179             note
     179            NULL,     // software version
     180            0,       // mask stat npix
     181            NAN,        // static
     182            NAN,        // dynamic
     183            NAN,        // magic
     184            NAN,        // advisory
     185            note
    180186    );
    181187    if (!warpRun) {
    … …  
    248254    PXOPT_COPY_F64(config->args,   where, "-posang_max",         "rawExp.posang",         "<");
    249255    PXOPT_COPY_STR(config->args,   where, "-object",             "rawExp.object",         "==");
     256    PXOPT_COPY_STR(config->args,   where, "-comment",            "rawExp.comment",        "LIKE");
     257    PXOPT_COPY_STR(config->args,   where, "-obs_mode",           "rawExp.obs_mode",       "LIKE");
    250258    PXOPT_COPY_F32(config->args,   where, "-sun_angle_min",      "rawExp.sun_angle",      ">=");
    251259    PXOPT_COPY_F32(config->args,   where, "-sun_angle_max",      "rawExp.sun_angle",      "<");
    … …  
    273281    PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
    274282    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     283    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
    275284
    276285    // check mode
    … …  
    310319    if (!psArrayLength(output)) {
    311320        psTrace("warptool", PS_LOG_INFO, "no rows found");
     321        psFree(output);
     322        return true;
     323    }
     324
     325    if (pretend) {
     326        // negative simple so the default is true
     327        if (!ippdbPrintMetadatas(stdout, output, "rawExp", !simple)) {
     328            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     329            psFree(output);
     330            return false;
     331        }
    312332        psFree(output);
    313333        return true;
    … …  
    925945        // to avoid slow queries and to the query itself
    926946        // to satisfy the user's requested limit
    927         psStringAppend(&limitString, psDBGenerateLimitSQL(limit));
     947        psStringAppend(&limitString, "%s", psDBGenerateLimitSQL(limit));
    928948        psStringAppend(&query, " %s", limitString);
    929949    }
    … …  
    10121032    PXOPT_LOOKUP_STR(ver_streaks, config->args, "-ver_streaks", false, false);
    10131033
     1034    PXOPT_LOOKUP_S32(maskfrac_npix, config->args, "-maskfrac_npix", false, false);
     1035    PXOPT_LOOKUP_F32(maskfrac_static, config->args, "-maskfrac_static", false, false);
     1036    PXOPT_LOOKUP_F32(maskfrac_dynamic, config->args, "-maskfrac_dynamic", false, false);
     1037    PXOPT_LOOKUP_F32(maskfrac_magic, config->args, "-maskfrac_magic", false, false);
     1038    PXOPT_LOOKUP_F32(maskfrac_advisory, config->args, "-maskfrac_advisory", false, false);
     1039
    10141040    psTrace("czw.test",1,"Received versions: pslib %s psmodules %s psphot %s ppstats %s pswarp %s streaks %s\n",
    10151041            ver_pslib,ver_psmodules,ver_psphot,ver_ppstats,ver_pswarp,ver_streaks);
    1016    
     1042    psString ver_code = NULL;
     1043    if ((ver_pslib)&&(ver_psmodules)) {
     1044      ver_code = pxMergeCodeVersions(ver_pslib,ver_psmodules);
     1045    }
     1046    if (ver_psphot) {
     1047      ver_code = pxMergeCodeVersions(ver_code,ver_psphot);
     1048    }
     1049    if (ver_ppstats) {
     1050      ver_code = pxMergeCodeVersions(ver_code,ver_ppstats);
     1051    }
     1052    if (ver_pswarp) {
     1053      ver_code = pxMergeCodeVersions(ver_code,ver_pswarp);
     1054    }
     1055    if (ver_streaks) {
     1056      ver_code = pxMergeCodeVersions(ver_code,ver_streaks);
     1057    }
    10171058   
    10181059    // default values
    … …  
    10491090                           fault,
    10501091                           quality,
    1051                            magicked
    1052 /*                         magicked, */
    1053 /*                         ver_pslib, */
    1054 /*                         ver_psmodules, */
    1055 /*                         ver_psphot, */
    1056 /*                         ver_ppstats, */
    1057 /*                         ver_pswarp, */
    1058 /*                         ver_streaks */
     1092                           magicked,
     1093                           ver_code,
     1094                           maskfrac_npix,
     1095                           maskfrac_static,
     1096                           maskfrac_dynamic,
     1097                           maskfrac_magic,
     1098                           maskfrac_advisory
    10591099        )) {
    10601100        if (!psDBRollback(config->dbh)) {
    … …  
    11211161        bool status;
    11221162        psS64 warp_id = psMetadataLookupS64(&status, row, "warp_id");
     1163
     1164        psString software_ver = NULL;
     1165        psS32 maskfrac_npix = 0;
     1166        psF32 maskfrac_static = 0;
     1167        psF32 maskfrac_dynamic = 0;
     1168        psF32 maskfrac_magic = 0;
     1169        psF32 maskfrac_advisory = 0;
     1170
     1171        // Calculate run level masking and software state
     1172        if (!pxCoalesceRunStatus(config,"warptool_coalesce_run.sql",warp_id,
     1173                                 &software_ver,&maskfrac_npix,
     1174                                 &maskfrac_static,&maskfrac_dynamic,
     1175                                 &maskfrac_magic,&maskfrac_advisory)) {
     1176          psError(PS_ERR_UNKNOWN, false, "failed to generate run level statistics");
     1177          psFree(output);
     1178          if (!psDBRollback(config->dbh)) {
     1179            psError(PS_ERR_UNKNOWN, false, "database error");
     1180          }
     1181          return(false);
     1182        }
     1183        // Set warpRun.software_ver to the appropriate value
     1184        if (!pxSetRunSoftware(config, "warpRun", "warp_id", warp_id, software_ver)) {
     1185          psError(PS_ERR_UNKNOWN, false, "failed to set warpRun.software_ver for warp_id: %" PRId64,
     1186                  warp_id);
     1187          psFree(output);
     1188          if (!psDBRollback(config->dbh)) {
     1189            psError(PS_ERR_UNKNOWN, false, "database error");
     1190          }
     1191          return(false);
     1192        }
     1193        // Set warpRun.maskfrac* to the appropriate values.
     1194        if (!pxSetRunMaskfrac(config, "warpRun", "warp_id", warp_id, maskfrac_npix, maskfrac_static,
     1195                              maskfrac_dynamic, maskfrac_magic, maskfrac_advisory)) {
     1196          psError(PS_ERR_UNKNOWN, false, "failed to set warpRun.software_ver for warp_id: %" PRId64,
     1197                  warp_id);
     1198          psFree(output);
     1199          if (!psDBRollback(config->dbh)) {
     1200            psError(PS_ERR_UNKNOWN, false, "database error");
     1201          }
     1202          return(false);
     1203        }       
     1204
     1205       
    11231206        if (!status) {
    11241207            psError(PS_ERR_UNKNOWN, false, "failed to look up value for warp_id");

  • branches/czw_branch/20100427/ippTools/src/warptoolConfig.c

    r27784 r28017  
    8989    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-posang_max",         0, "search by max rotator position angle", NAN);
    9090    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-object",             0, "search by exposure object", NULL);
    91     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-sun_angle_min",         0, "search by min solar angle", NAN);
    92     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-sun_angle_max",         0, "search by max solar angle", NAN);
     91    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-comment",            0, "search by comment field (LIKE comparison)", NULL);
     92    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-obs_mode",           0, "search by observation mode", NULL);
     93    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-sun_angle_min",      0, "search by min solar angle", NAN);
     94    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-sun_angle_max",      0, "search by max solar angle", NAN);
    9395    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-reduction",          0, "search by fakeRun reduction class", NULL);
    9496    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search on fakeRun label", NULL);
    … …  
    106108    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-registered",  0,            "time detrend run was registered", now);
    107109    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     110    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-pretend",  0,            "do not actually modify the database", false);
    108111
    109112    // -definerun
    … …  
    227230    psMetadataAddStr(addwarpedArgs, PS_LIST_TAIL, "-ver_pswarp", 0, "define pswarp version", NULL);
    228231    psMetadataAddStr(addwarpedArgs, PS_LIST_TAIL, "-ver_streaks", 0, "define streaksremove version", NULL);
     232
     233    psMetadataAddS32(addwarpedArgs, PS_LIST_TAIL, "-maskfrac_npix", 0, "define number of pixels used for maskstats", 0);
     234    psMetadataAddF32(addwarpedArgs, PS_LIST_TAIL, "-maskfrac_static", 0, "define static mask fraction", NAN);
     235    psMetadataAddF32(addwarpedArgs, PS_LIST_TAIL, "-maskfrac_dynamic", 0, "define dynamic mask fraction", NAN);
     236    psMetadataAddF32(addwarpedArgs, PS_LIST_TAIL, "-maskfrac_magic", 0, "define magic mask fraction", NAN);
     237    psMetadataAddF32(addwarpedArgs, PS_LIST_TAIL, "-maskfrac_advisory", 0, "define advisory mask fraction", NAN);
    229238
    230239   
Note: See TracChangeset for help on using the changeset viewer.