IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
May 28, 2010, 3:09:59 PM (16 years ago)
Author:
watersc1
Message:

JPEG work should be done. Transitioning to try to pick up stackAssociation concept in this branch as well.

Location:
branches/czw_branch/20100519
Files:
20 edited
3 copied

Legend:

Unmodified
Added
Removed

  • branches/czw_branch/20100519

  • branches/czw_branch/20100519/ippTools/src

    • Property svn:ignore

      •  

        old new  
        2020flatcorr
        2121guidetool
         22labeltool
        2223magicdstool
        2324magictool
        … …  
        3738stamp-h1
        3839warptool
         40

  • branches/czw_branch/20100519/ippTools/src/Makefile.am

    r26378 r28164  
    1010        flatcorr \
    1111        dqstatstool \
     12        labeltool \
    1213        magictool \
    1314        magicdstool \
    … …  
    2122        regtool \
    2223        stacktool \
     24        staticskytool \
    2325        warptool \
    2426        receivetool \
    … …  
    5557        faketool.h \
    5658        dqstatstool.h \
     59        labeltool.h \
    5760        magictool.h \
    5861        magicdstool.h \
    … …  
    6467        regtool.h \
    6568        stacktool.h \
     69        staticskytool.h \
    6670        warptool.h \
    6771        pubtool.h
    … …  
    153157    dqstatstoolConfig.c
    154158
     159labeltool_CFLAGS = $(PSLIB_CFLAGS) $(PSMODULES_CFLAGS) $(IPPDB_CFLAGS)
     160labeltool_LDADD = $(PSLIB_LIBS) $(PSMODULES_LIBS) $(IPPDB_LIBS) libpxtools.la
     161labeltool_SOURCES = \
     162    labeltool.c \
     163    labeltoolConfig.c
     164
    155165magictool_CFLAGS = $(PSLIB_CFLAGS) $(PSMODULES_CFLAGS) $(IPPDB_CFLAGS)
    156166magictool_LDADD = $(PSLIB_LIBS) $(PSMODULES_LIBS) $(IPPDB_LIBS) libpxtools.la
    … …  
    188198    stacktool.c \
    189199    stacktoolConfig.c
     200
     201staticskytool_CFLAGS = $(PSLIB_CFLAGS) $(PSMODULES_CFLAGS) $(IPPDB_CFLAGS)
     202staticskytool_LDADD = $(PSLIB_LIBS) $(PSMODULES_LIBS) $(IPPDB_LIBS) libpxtools.la
     203staticskytool_SOURCES = \
     204    staticskytool.c \
     205    staticskytoolConfig.c
    190206
    191207pxadmin_CFLAGS = $(PSLIB_CFLAGS) $(PSMODULES_CFLAGS) $(IPPDB_CFLAGS)

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

    r28043 r28164  
    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 
    498     psTrace("czw.test",1,"Received versions: pslib %s psmodules %s psphot %s psastro %s ppstats %s ppImage %s streaks %s\n",
    499             ver_pslib,ver_psmodules,ver_psphot,ver_psastro,ver_ppstats,ver_ppimage,ver_streaks);
     492    PXOPT_LOOKUP_S32(maskfrac_ref_npix, config->args, "-maskfrac_ref_npix", false, false);
     493    PXOPT_LOOKUP_F32(maskfrac_ref_static, config->args, "-maskfrac_ref_static", false, false);
     494    PXOPT_LOOKUP_F32(maskfrac_ref_dynamic, config->args, "-maskfrac_ref_dynamic", false, false);
     495    PXOPT_LOOKUP_F32(maskfrac_ref_magic, config->args, "-maskfrac_ref_magic", false, false);
     496    PXOPT_LOOKUP_F32(maskfrac_ref_advisory, config->args, "-maskfrac_ref_advisory", false, false);
     497
     498    PXOPT_LOOKUP_S32(maskfrac_max_npix, config->args, "-maskfrac_max_npix", false, false);
     499    PXOPT_LOOKUP_F32(maskfrac_max_static, config->args, "-maskfrac_max_static", false, false);
     500    PXOPT_LOOKUP_F32(maskfrac_max_dynamic, config->args, "-maskfrac_max_dynamic", false, false);
     501    PXOPT_LOOKUP_F32(maskfrac_max_magic, config->args, "-maskfrac_max_magic", false, false);
     502    PXOPT_LOOKUP_F32(maskfrac_max_advisory, config->args, "-maskfrac_max_advisory", false, false);
     503
     504/*     psTrace("czw.test",1,"Received versions: pslib %s psmodules %s psphot %s psastro %s ppstats %s ppImage %s streaks %s\n", */
     505/*          ver_pslib,ver_psmodules,ver_psphot,ver_psastro,ver_ppstats,ver_ppimage,ver_streaks); */
    500506    psString software_ver = NULL;
    501507    if ((ver_pslib)&&(ver_psmodules)) {
    … …  
    632638        fault,
    633639        software_ver,
    634         maskfrac_npix,
    635         maskfrac_static,
    636         maskfrac_dynamic,
    637         maskfrac_magic,
    638         maskfrac_advisory,
     640        maskfrac_ref_npix,
     641        maskfrac_ref_static,
     642        maskfrac_ref_dynamic,
     643        maskfrac_ref_magic,
     644        maskfrac_ref_advisory,
     645        maskfrac_max_npix,
     646        maskfrac_max_static,
     647        maskfrac_max_dynamic,
     648        maskfrac_max_magic,
     649        maskfrac_max_advisory,
    639650        quality
    640651        );
    … …  
    674685    }
    675686    // 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)) {
     687    if (maskfrac_ref_npix) {
     688      if (!pxCamSetRunMaskfrac(config, "camRun", "cam_id",cam_id,
     689                               (float) maskfrac_ref_npix, maskfrac_ref_static,
     690                               maskfrac_ref_dynamic, maskfrac_ref_magic, maskfrac_ref_advisory,
     691                               (float) maskfrac_max_npix, maskfrac_max_static,
     692                               maskfrac_max_dynamic, maskfrac_max_magic, maskfrac_max_advisory)) {
    679693        if (!psDBRollback(config->dbh)) {
    680694          psError(PS_ERR_UNKNOWN, false, "database error");

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

    r28043 r28164  
    182182    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-ver_streaks", 0, "define streaksremove version", NULL);
    183183
    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);
     184    psMetadataAddS32(addprocessedexpArgs, PS_LIST_TAIL, "-maskfrac_ref_npix", 0, "define number of pixels used for maskstats", 0);
     185    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-maskfrac_ref_static", 0, "define static mask fraction", NAN);
     186    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-maskfrac_ref_dynamic", 0, "define dynamic mask fraction", NAN);
     187    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-maskfrac_ref_magic", 0, "define magic mask fraction", NAN);
     188    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-maskfrac_ref_advisory", 0, "define advisory mask fraction", NAN);
     189
     190    psMetadataAddS32(addprocessedexpArgs, PS_LIST_TAIL, "-maskfrac_max_npix", 0, "define number of pixels used for maskstats", 0);
     191    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-maskfrac_max_static", 0, "define static mask fraction", NAN);
     192    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-maskfrac_max_dynamic", 0, "define dynamic mask fraction", NAN);
     193    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-maskfrac_max_magic", 0, "define magic mask fraction", NAN);
     194    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-maskfrac_max_advisory", 0, "define advisory mask fraction", NAN);
    189195
    190196

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

    r28043 r28164  
    141141    )
    142142{
    143     // start a transaction so we don't end up with an exp without any associted
     143    // start a transaction so we don't end up with an exp without any associated
    144144    // imfiles
    145145    if (!psDBTransaction(config->dbh)) {
    … …  
    13981398       
    13991399        psString software_ver = NULL;
    1400         psS32 maskfrac_npix = 0;
     1400        psS64 maskfrac_npix = 0;
    14011401        psF32 maskfrac_static = 0;
    14021402        psF32 maskfrac_dynamic = 0;
    … …  
    14171417        }
    14181418        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);
     1419        psMetadataAddS32(row, PS_LIST_TAIL, "maskfrac_npix",  0, "Number of pixels used for mask stats", (psS32) maskfrac_npix);
    14201420        psMetadataAddF32(row, PS_LIST_TAIL, "maskfrac_static",  0, "Fraction of static masked pixels", maskfrac_static);
    14211421        psMetadataAddF32(row, PS_LIST_TAIL, "maskfrac_dynamic",  0, "Fraction of dynamic masked pixels", maskfrac_dynamic);
    14221422        psMetadataAddF32(row, PS_LIST_TAIL, "maskfrac_magic",  0, "Fraction of magic masked pixels", maskfrac_magic);
    14231423        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);
     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); */
    14251425        chipRunRow *chipRun = chipRunObjectFromMetadata(row);
    14261426        if (!psDBTransaction(config->dbh)) {
    … …  
    14301430
    14311431        // 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");
     1432        if (software_ver) {
     1433          if (!pxSetRunSoftware(config, "chipRun", "chip_id", chip_id, software_ver)) {
     1434            psError(PS_ERR_UNKNOWN, false, "failed to set chipRun.software_ver for chip_id: %" PRId64,
     1435                    chip_id);
     1436            psFree(output);
     1437            if (!psDBRollback(config->dbh)) {
     1438              psError(PS_ERR_UNKNOWN, false, "database error");
     1439            }
     1440            return(false);
    14381441          }
    1439           return(false);
    14401442        }
    14411443        // 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");
     1444        if (maskfrac_npix) {
     1445          if (!pxSetRunMaskfrac(config, "chipRun", "chip_id",chip_id, maskfrac_npix, maskfrac_static,
     1446                                maskfrac_dynamic, maskfrac_magic, maskfrac_advisory)) {
     1447            psError(PS_ERR_UNKNOWN, false, "failed to set chipRun.software_ver for chip_id: %" PRId64,
     1448                    chip_id);
     1449            psFree(output);
     1450            if (!psDBRollback(config->dbh)) {
     1451              psError(PS_ERR_UNKNOWN, false, "database error");
     1452            }
     1453            return(false);
    14491454          }
    1450           return(false);
    14511455        }
    14521456        // set chipRun.state to 'stop' and update the magicked state

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

    r28043 r28164  
    8989    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-chip_id",              0,            "search by chip ID", 0);
    9090    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,            "search by state", NULL);
    91     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label",  0,           "search by label", NULL);
    92     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-data_group",  0,      "search by data_group", NULL);
    93     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-dist_group",  0,      "search by dist_group", NULL);
     91    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label",  0,           "search by label (LIKE comparison)", NULL);
     92    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-data_group",  0,      "search by data_group (LIKE comparison)", NULL);
     93    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-dist_group",  0,      "search by dist_group (LIKE comparison)", NULL);
    9494    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_state", 0,        "set state", NULL);
    9595    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_label", 0,        "set label", NULL);
    … …  
    101101    psMetadata *setimfiletoupdateArgs = psMetadataAlloc();
    102102    psMetadataAddS64(setimfiletoupdateArgs, PS_LIST_TAIL, "-chip_id", 0,   "search by chip ID (required)", 0);
    103     psMetadataAddStr(setimfiletoupdateArgs, PS_LIST_TAIL, "-class_id", 0,  "search by class_id (required)", NULL);
     103    psMetadataAddStr(setimfiletoupdateArgs, PS_LIST_TAIL, "-class_id", 0,  "search by class_id", NULL);
    104104    psMetadataAddStr(setimfiletoupdateArgs, PS_LIST_TAIL, "-set_label",  0,"new value for label", NULL);
    105105

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

    r28043 r28164  
    4444static bool definewarpwarpMode(pxConfig *config);
    4545static bool definestackstackMode(pxConfig *config);
     46static bool tosummaryMode(pxConfig *config);
     47static bool addsummaryMode(pxConfig *config);
    4648static bool pendingcleanuprunMode(pxConfig *config);
    4749static bool pendingcleanupskyfileMode(pxConfig *config);
    … …  
    9395        MODECASE(DIFFTOOL_MODE_DEFINEWARPWARP,        definewarpwarpMode);
    9496        MODECASE(DIFFTOOL_MODE_DEFINESTACKSTACK,      definestackstackMode);
     97        MODECASE(DIFFTOOL_MODE_TOSUMMARY,             tosummaryMode);
     98        MODECASE(DIFFTOOL_MODE_ADDSUMMARY,            addsummaryMode);
    9599        MODECASE(DIFFTOOL_MODE_PENDINGCLEANUPRUN,     pendingcleanuprunMode);
    96100        MODECASE(DIFFTOOL_MODE_PENDINGCLEANUPSKYFILE, pendingcleanupskyfileMode);
    … …  
    203207
    204208    PXOPT_COPY_S64(config->args, where, "-diff_id",  "diff_id",   "==");
    205     PXOPT_COPY_STR(config->args, where, "-label",     "label",     "==");
    206     PXOPT_COPY_STR(config->args, where, "-data_group","data_group",     "==");
     209    PXOPT_COPY_STR(config->args, where, "-label",     "label",     "LIKE");
     210    PXOPT_COPY_STR(config->args, where, "-data_group","data_group","LIKE");
     211    PXOPT_COPY_STR(config->args, where, "-dist_group","dist_group","LIKE");
    207212    PXOPT_COPY_STR(config->args, where, "-state",     "state",     "==");
    208213    if (!psListLength(where->list)) {
    … …  
    716721
    717722        psString software_ver = NULL;
    718         psS32 maskfrac_npix = 0;
     723        psS64 maskfrac_npix = 0;
    719724        psF32 maskfrac_static = 0;
    720725        psF32 maskfrac_dynamic = 0;
    … …  
    22492254}
    22502255
     2256static bool tosummaryMode(pxConfig *config) {
     2257  PS_ASSERT_PTR_NON_NULL(config, NULL);
     2258 
     2259  psMetadata *where = psMetadataAlloc();
     2260  PXOPT_COPY_S64(config->args, where, "-warp_id",    "diffSkyfile.warp_id", "==");
     2261  PXOPT_COPY_STR(config->args, where, "-tess_id",    "diffSkyfile.tess_id", "==");
     2262  PXOPT_COPY_STR(config->args, where, "-state",      "diffRun.state", "==");
     2263  PXOPT_COPY_TIME(config->args, where, "-dateobs_begin", "rawExp.dateobs",  ">=");
     2264  PXOPT_COPY_TIME(config->args, where, "-dateobs_end",   "rawExp.dateobs",  "<=");
     2265  PXOPT_COPY_STR(config->args, where, "-filter",    "rawExp.filter", "LIKE");
     2266  PXOPT_COPY_S64(config->args, where, "-magicked", "diffSkyfile.magicked", "==");
     2267  pxAddLabelSearchArgs (config, where, "-label",   "diffRun.label", "LIKE");
     2268  pxAddLabelSearchArgs (config, where, "-data_group",   "diffRun.data_group", "LIKE");
     2269
     2270  PXOPT_LOOKUP_BOOL(all, config->args, "-all", false);
     2271
     2272  PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     2273  PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     2274 
     2275  // find all rawImfiles matching the default query
     2276  psString query = pxDataGet("difftool_tosummary.sql");
     2277  if (!query) {
     2278    psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     2279    return false;
     2280  }
     2281
     2282  // generate where strings for arguments that require extra processing
     2283  // beyond PXOPT_COPY*
     2284  psString where2 = NULL;
     2285  if (!pxmagicAddWhere(config, &where2, "diffSkyfile")) {
     2286    psError(psErrorCodeLast(), false, "pxMagicAddWhere failed");
     2287    return false;
     2288  }
     2289 
     2290  if (psListLength(where->list)) {
     2291    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     2292    psStringAppend(&query, " WHERE %s", whereClause);
     2293    psFree(whereClause);
     2294  } else if (!all && !where2) {
     2295    psError(PXTOOLS_ERR_CONFIG, true, "search parameters or -all are required");
     2296    return false;
     2297  }
     2298 
     2299  if (where2) {
     2300    if (psListLength(where->list)) {
     2301      psStringAppend(&query, " %s", where2);
     2302    } else {
     2303      psStringAppend(&query, " WHERE 1 %s", where2);
     2304    }
     2305  }
     2306  psFree(where);
     2307
     2308  // treat limit == 0 as "no limit"
     2309  if (limit) {
     2310    psString limitString = psDBGenerateLimitSQL(limit);
     2311    psStringAppend(&query, " %s", limitString);
     2312    psFree(limitString);
     2313  }
     2314 
     2315  if (!p_psDBRunQuery(config->dbh, query)) {
     2316    psError(PS_ERR_UNKNOWN, false, "database error");
     2317    psFree(query);
     2318    return false;
     2319  }
     2320  psFree(query);
     2321
     2322  psArray *output = p_psDBFetchResult(config->dbh);
     2323  if (!output) {
     2324    psErrorCode err = psErrorCodeLast();
     2325    switch (err) {
     2326    case PS_ERR_DB_CLIENT:
     2327      psError(PXTOOLS_ERR_SYS, false, "database error");
     2328    case PS_ERR_DB_SERVER:
     2329      psError(PXTOOLS_ERR_PROG, false, "database error");
     2330    default:
     2331      psError(PXTOOLS_ERR_PROG, false, "unknown error");
     2332    }
     2333   
     2334    return false;
     2335  }
     2336  if (!psArrayLength(output)) {
     2337    psTrace("difftool", PS_LOG_INFO, "no rows found");
     2338    psFree(output);
     2339    return true;
     2340  }
     2341 
     2342  if (psArrayLength(output)) {
     2343    // negative simple so the default is true
     2344    if (!ippdbPrintMetadatas(stdout, output, "diffRun", !simple)) {
     2345      psError(PS_ERR_UNKNOWN, false, "failed to print array");
     2346      psFree(output);
     2347      return false;
     2348    }
     2349  }
     2350 
     2351  psFree(output);
     2352  return(true);
     2353}
     2354static bool addsummaryMode(pxConfig *config) {
     2355  PS_ASSERT_PTR_NON_NULL(config, NULL);
     2356
     2357  PXOPT_LOOKUP_S64(diff_id, config->args, "-diff_id", true, false);
     2358  PXOPT_LOOKUP_STR(tangent_plane, config->args, "-tangent_plane", true, false);
     2359  PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", true, false);
     2360
     2361  psString query = pxDataGet("difftool_addsummary.sql");
     2362  if (!query) {
     2363    psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     2364    return(false);
     2365  }
     2366  if (!p_psDBRunQueryF(config->dbh, query, diff_id, tangent_plane, path_base)) {
     2367    psError(PS_ERR_UNKNOWN, false, "database error");
     2368    psFree(query);
     2369    return(false);
     2370  }
     2371  psS64 numUpdated = psDBAffectedRows(config->dbh);
     2372 
     2373  if (numUpdated != 1) {
     2374    psError(PS_ERR_UNKNOWN, false, "should have affected 1 row");
     2375    psFree(query);
     2376    return false;
     2377  }
     2378 
     2379  psFree(query);
     2380
     2381  // Print anything here?
     2382 
     2383  return(true);
     2384}
     2385
     2386
    22512387static bool pendingcleanuprunMode(pxConfig *config)
    22522388{

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

    r27794 r28164  
    3232    DIFFTOOL_MODE_ADDDIFFSKYFILE,
    3333    DIFFTOOL_MODE_ADVANCE,
     34    DIFFTOOL_MODE_TOSUMMARY,
     35    DIFFTOOL_MODE_ADDSUMMARY,
    3436    DIFFTOOL_MODE_DIFFSKYFILE,
    3537    DIFFTOOL_MODE_REVERTDIFFSKYFILE,

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

    r28043 r28164  
    6464    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-diff_id", 0,          "define diff ID", 0);
    6565    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,            "set state", NULL);
    66     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label", 0,            "define by label instead of diff ID", 0);
    67     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-data_group", 0,       "define by data_group instead of diff ID", 0);
     66    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label", 0,            "define by label instead of diff ID (LIKE comparison)", 0);
     67    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-data_group", 0,       "define by data_group instead of diff ID (LIKE comparison)", 0);
     68    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-dist_group", 0,       "define by dist_group instead of diff ID (LIKE comparison)", 0);
    6869    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_label", 0,        "define new value for label", 0);
    6970    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_state", 0,        "define new state", NULL);
    7071    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_data_group", 0,   "define new data_group", NULL);
    7172    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_dist_group", 0,   "define new dist_group", NULL);
    72     psMetadataAddS16(updaterunArgs, PS_LIST_TAIL, "-set_diff_mode", 0,       "specify type of difference (WW=1,WS=2,SW=3,SS=4)", 0);
     73    psMetadataAddS16(updaterunArgs, PS_LIST_TAIL, "-set_diff_mode", 0,    "specify type of difference (WW=1,WS=2,SW=3,SS=4)", 0);
    7374    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_note", 0,         "define new note", NULL);
    7475
    … …  
    322323    psMetadataAddU64(pendingcleanuprunArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    323324
     325    // -tosummary
     326    psMetadata *tosummaryArgs = psMetadataAlloc();
     327    psMetadataAddS64(tosummaryArgs, PS_LIST_TAIL,  "-diff_id", 0,           "search by diff ID", 0);
     328    psMetadataAddStr(tosummaryArgs, PS_LIST_TAIL,  "-tess_id",  0,          "search by tessellation ID", NULL);
     329    psMetadataAddStr(tosummaryArgs , PS_LIST_TAIL, "-warp_id",  0,         "search by warp_id", NULL);
     330    psMetadataAddBool(tosummaryArgs, PS_LIST_TAIL, "-template",  0,        "apply exposure args to template of bothways diff", false);
     331    psMetadataAddS64(tosummaryArgs, PS_LIST_TAIL,  "-exp_id",  0,           "search by exposure ID", 0);
     332    psMetadataAddStr(tosummaryArgs , PS_LIST_TAIL, "-exp_name",  0,        "search by exposure name", NULL);
     333    psMetadataAddTime(tosummaryArgs, PS_LIST_TAIL, "-dateobs_begin", 0,    "search for exposures by time (>=)", NULL);
     334    psMetadataAddTime(tosummaryArgs, PS_LIST_TAIL, "-dateobs_end", 0,      "search for exposures by time (<=)", NULL);
     335    psMetadataAddStr(tosummaryArgs, PS_LIST_TAIL,  "-filter", 0,           "search for filter", NULL);
     336    psMetadataAddStr(tosummaryArgs,  PS_LIST_TAIL, "-label",  PS_META_DUPLICATE_OK, "search by diffRun label (LIKE comparison)", NULL);
     337    psMetadataAddStr(tosummaryArgs,  PS_LIST_TAIL, "-data_group",  PS_META_DUPLICATE_OK, "search by diffRun data_group (LIKE comparison)", NULL);
     338    psMetadataAddStr(tosummaryArgs,  PS_LIST_TAIL, "-dist_group",  PS_META_DUPLICATE_OK, "search by diffRun dist_group (LIKE comparison)", NULL);
     339
     340    psMetadataAddBool(tosummaryArgs, PS_LIST_TAIL, "-all",  0,             "search without arguments", false);
     341    psMetadataAddU64(tosummaryArgs, PS_LIST_TAIL,  "-limit",  0,            "limit result set to N items", 0);
     342    psMetadataAddBool(tosummaryArgs, PS_LIST_TAIL, "-simple",  0,          "use the simple output format", false);
     343   
     344    // -addsummary
     345    psMetadata *addsummaryArgs = psMetadataAlloc();
     346    psMetadataAddS64(addsummaryArgs, PS_LIST_TAIL,  "-diff_id", 0,           "search by diff ID", 0);
     347    psMetadataAddStr(addsummaryArgs, PS_LIST_TAIL, "-tangent_plane", 0, "set tangent plane", NULL);
     348    psMetadataAddStr(addsummaryArgs, PS_LIST_TAIL, "-path_base", 0, "set summary path base", NULL);
     349
    324350    // -pendingcleanupskyfile
    325351    psMetadata *pendingcleanupskyfileArgs = psMetadataAlloc();
    … …  
    379405    psMetadata *importrunArgs = psMetadataAlloc();
    380406    psMetadataAddStr(importrunArgs, PS_LIST_TAIL, "-infile",  0,          "import from this file (required)", NULL);
    381 
    382407
    383408
    … …  
    414439    PXOPT_ADD_MODE("-toscrubbedskyfile", "set skyfile as scrubbed", DIFFTOOL_MODE_TOSCRUBBEDSKYFILE, toscrubbedskyfileArgs);
    415440    PXOPT_ADD_MODE("-tofullskyfile", "set skyfile as full", DIFFTOOL_MODE_TOFULLSKYFILE, tofullskyfileArgs);
     441    PXOPT_ADD_MODE("-tosummary",            "show runs that can be summarized", DIFFTOOL_MODE_TOSUMMARY, tosummaryArgs);
     442    PXOPT_ADD_MODE("-addsummary",           "add entry to the summary table", DIFFTOOL_MODE_ADDSUMMARY, addsummaryArgs);
    416443
    417444    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {

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

    r28043 r28164  
    4949
    5050psString pxMergeCodeVersions(psString version1, psString version2) {
    51   psString out = NULL;
    52 
    53   bool mod1 = false;
    54   bool mod2 = false;
    55 
    56   psS32 num1;
    57   psS32 num2;
    58   psS32 numO;
    59 
    60   if (!version1) {
    61     psStringAppend(&out,version2);
     51    psString out = NULL;
     52
     53    bool mod1 = false;
     54    bool mod2 = false;
     55
     56    psS32 num1;
     57    psS32 num2;
     58    psS32 numO;
     59
     60    if (!version1) {
     61        psStringAppend(&out, "%s", version2);
     62        return(out);
     63    }
     64    if (!version2) {
     65        psStringAppend(&out, "%s", version1);
     66        return(out);
     67    }
     68 
     69    if (strchr(version1,'M')) {
     70        psStringSubstitute(&version1,"M","");
     71        mod1 = true;
     72    }
     73    if (strchr(version2,'M')) {
     74        psStringSubstitute(&version2,"M","");
     75        mod2 = true;
     76    }
     77
     78    num1 = strtol(version1,NULL,10);
     79    num2 = strtol(version2,NULL,10);
     80
     81    if (num1 >= num2) {
     82        numO = num1;
     83    }
     84    else {
     85        numO = num2;
     86    }
     87 
     88    psStringAppend(&out,"%" PRId32,numO);
     89    if (mod1 || mod2) {
     90        psStringAppend(&out,"M");
     91    }
    6292    return(out);
    63   }
    64   if (!version2) {
    65     psStringAppend(&out,version1);
    66     return(out);
    67   }
    68  
    69   if (strchr(version1,'M')) {
    70     psStringSubstitute(&version1,"M","");
    71     mod1 = true;
    72   }
    73   if (strchr(version2,'M')) {
    74     psStringSubstitute(&version2,"M","");
    75     mod2 = true;
    76   }
    77 
    78   num1 = strtol(version1,NULL,10);
    79   num2 = strtol(version2,NULL,10);
    80 
    81   if (num1 >= num2) {
    82     numO = num1;
    83   }
    84   else {
    85     numO = num2;
    86   }
    87  
    88   psStringAppend(&out,"%" PRId32,numO);
    89   if (mod1 || mod2) {
    90     psStringAppend(&out,"M");
    91   }
    92   return(out);
    9393}
    9494
    9595bool pxCoalesceRunStatus(pxConfig *config, const psString dbQFile, psS64 stage_id, psString *software_ver,
    96                          psS32 *maskfrac_npix, psF32 *maskfrac_static, psF32 *maskfrac_dynamic,
     96                         psS64 *maskfrac_npix, psF32 *maskfrac_static, psF32 *maskfrac_dynamic,
    9797                         psF32 *maskfrac_magic, psF32 *maskfrac_advisory) {
    98   psString query = pxDataGet(dbQFile);
     98    psString query = pxDataGet(dbQFile);
    9999/*   psString text_id = NULL; */
    100100/*   psStringAppend(&text_id," %" PRId64,stage_id); */
    101101/*   psStringSubstitute(&query,text_id,"@STAGE_ID@"); */
    102102/*   psFree(text_id); */
    103   if (!p_psDBRunQueryF(config->dbh, query, stage_id)) {
    104     psError(PS_ERR_UNKNOWN, false, "database error");
     103    if (!p_psDBRunQueryF(config->dbh, query, stage_id)) {
     104        psError(PS_ERR_UNKNOWN, false, "database error");
     105        psFree(query);
     106        return(false);
     107    }
    105108    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);
     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/*     printf("%ld : %d %f %f %f %f <-> %ld %f %f %f %f\n",i,this_npix,this_static,this_dynamic,this_magic,this_advisory, */
     127/*         *maskfrac_npix,*maskfrac_static,*maskfrac_dynamic,*maskfrac_magic,*maskfrac_advisory); */
     128        if (this_npix > 0) {
     129            *maskfrac_static = ((*maskfrac_static * *maskfrac_npix) + (this_npix * this_static)) / (this_npix + *maskfrac_npix);
     130            *maskfrac_dynamic = ((*maskfrac_dynamic * *maskfrac_npix) + (this_npix * this_dynamic)) / (this_npix + *maskfrac_npix);
     131            *maskfrac_magic = ((*maskfrac_magic * *maskfrac_npix) + (this_npix * this_magic)) / (this_npix + *maskfrac_npix);
     132            *maskfrac_advisory = ((*maskfrac_advisory * *maskfrac_npix) + (this_npix * this_advisory)) / (this_npix + *maskfrac_npix);
     133            *maskfrac_npix += this_npix;
     134        }
     135    }
     136    psFree(output);
     137    return(true);
    135138}
    136139
    137140bool pxSetRunSoftware(pxConfig *config, const psString tableName, const psString stage_id_name, const psS64 stage_id,
    138141                      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 }
     142    char *query = "UPDATE %s SET software_ver = '%s' WHERE %s = %" PRId64;
     143/*   printf(query,tableName,software_ver,stage_id_name,stage_id); */
     144    if (!p_psDBRunQueryF(config->dbh,query,tableName,software_ver,stage_id_name,stage_id)) {
     145        psError(PS_ERR_UNKNOWN, false,
     146                "failed to set software version for %s %" PRId64,stage_id_name,stage_id);
     147        return(false);
     148    }
     149 
     150    return(true);
     151}
     152
    149153bool 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,
     154                      psS64 maskfrac_npix, psF32 maskfrac_static, psF32 maskfrac_dynamic,
    151155                      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)) {
     156    char *query = "UPDATE %s SET maskfrac_npix = %f, maskfrac_static = %f, maskfrac_dynamic = %f, maskfrac_magic = %f, maskfrac_advisory = %f WHERE %s = %" PRId64;
     157    if (!p_psDBRunQueryF(config->dbh,query,tableName,(float) maskfrac_npix,maskfrac_static,
     158                         maskfrac_dynamic, maskfrac_magic,maskfrac_advisory,stage_id_name,stage_id)) {
     159        psError(PS_ERR_UNKNOWN, false,
     160                "failed to set maskfrac stats for %s %" PRId64,stage_id_name,stage_id);
     161        return(false);
     162    }
     163 
     164
     165
     166    return(true);
     167}
     168
     169bool pxCamSetRunMaskfrac(pxConfig *config, const psString tableName, const psString stage_id_name, const psS64 stage_id,
     170                         psS64 maskfrac_ref_npix, psF32 maskfrac_ref_static, psF32 maskfrac_ref_dynamic,
     171                         psF32 maskfrac_ref_magic, psF32 maskfrac_ref_advisory,
     172                         psS64 maskfrac_max_npix, psF32 maskfrac_max_static, psF32 maskfrac_max_dynamic,
     173                         psF32 maskfrac_max_magic, psF32 maskfrac_max_advisory) {
     174  char *query = "UPDATE %s SET maskfrac_ref_npix = %f, maskfrac_ref_static = %f, maskfrac_ref_dynamic = %f, maskfrac_ref_magic = %f, maskfrac_ref_advisory = %f, maskfrac_max_npix = %f, maskfrac_max_static = %f, maskfrac_max_dynamic = %f, maskfrac_max_magic = %f, maskfrac_max_advisory = %f WHERE %s = %" PRId64;
     175  if (!p_psDBRunQueryF(config->dbh,query,tableName,(float) maskfrac_ref_npix,maskfrac_ref_static,
     176                       maskfrac_ref_dynamic, maskfrac_ref_magic,maskfrac_ref_advisory,
     177                       (float) maskfrac_max_npix,maskfrac_max_static,
     178                       maskfrac_max_dynamic, maskfrac_max_magic,maskfrac_max_advisory,
     179                       stage_id_name,stage_id)) {
    155180    psError(PS_ERR_UNKNOWN, false,
    156181            "failed to set maskfrac stats for %s %" PRId64,stage_id_name,stage_id);
    … …  
    268293    char *comma = ",";
    269294
    270 #   define addColumn(_tab, _val) \
    271         do { \
    272             if (_val) { \
    273                 psStringAppend(pQuery, "%s %s.%s = '%s'", separator, _tab, #_val, _val); \
    274                 separator = comma; \
    275             } \
    276         } while (0)
     295#   define addColumn(_tab, _val)                                        \
     296    do {                                                                \
     297        if (_val) {                                                     \
     298            psStringAppend(pQuery, "%s %s.%s = '%s'", separator, _tab, #_val, _val); \
     299            separator = comma;                                          \
     300        }                                                               \
     301    } while (0)
    277302
    278303    addColumn(runTable, state);
    … …  
    411436        if (import_version && strcmp(import_version, schema_version)) {
    412437            psError(PS_ERR_UNKNOWN, true, "input file schema_version: %s does not match data base: %s",
    413                 import_version, schema_version);
     438                    import_version, schema_version);
    414439            return false;
    415440        } else if (!import_version) {

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

    r28043 r28164  
    5555psString pxMergeCodeVersions(psString version1, psString version2);
    5656bool pxCoalesceRunStatus(pxConfig *config, const psString dbQFile, psS64 stage_id, psString *software_ver,
    57                          psS32 *maskfrac_npix, psF32 *maskfrac_static, psF32 *maskfrac_dynamic,
     57                         psS64 *maskfrac_npix, psF32 *maskfrac_static, psF32 *maskfrac_dynamic,
    5858                         psF32 *maskfrac_magic, psF32 *maskfrac_advisory);
    5959bool pxSetRunSoftware(pxConfig *config, const psString tableName, const psString stage_id_name, const psS64 stage_id,
    6060                      psString software_ver);
    6161bool 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,
     62                      psS64 maskfrac_npix, psF32 maskfrac_static, psF32 maskfrac_dynamic,
    6363                      psF32 maskfrac_magic, psF32 maskfrac_advisory);
     64bool pxCamSetRunMaskfrac(pxConfig *config, const psString tableName, const psString stage_id_name, const psS64 stage_id,
     65                         psS64 maskfrac_ref_npix, psF32 maskfrac_ref_static, psF32 maskfrac_ref_dynamic,
     66                         psF32 maskfrac_ref_magic, psF32 maskfrac_ref_advisory,
     67                         psS64 maskfrac_max_npix, psF32 maskfrac_max_static, psF32 maskfrac_max_dynamic,
     68                         psF32 maskfrac_max_magic, psF32 maskfrac_max_advisory);
    6469
    6570bool pxSetStateCleaned(const psString tableName, const psString columnName, psArray *rows);

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

    r28043 r28164  
    4040static bool sumskyfileMode(pxConfig *config);
    4141static bool revertsumskyfileMode(pxConfig *config);
     42static bool tosummaryMode(pxConfig *config);
     43static bool addsummaryMode(pxConfig *config);
    4244static bool pendingcleanuprunMode(pxConfig *config);
    4345static bool pendingcleanupskyfileMode(pxConfig *config);
    … …  
    7678        MODECASE(STACKTOOL_MODE_SUMSKYFILE,            sumskyfileMode);
    7779        MODECASE(STACKTOOL_MODE_REVERTSUMSKYFILE,      revertsumskyfileMode);
     80        MODECASE(STACKTOOL_MODE_TOSUMMARY,             tosummaryMode);
     81        MODECASE(STACKTOOL_MODE_ADDSUMMARY,            addsummaryMode);
    7882        MODECASE(STACKTOOL_MODE_PENDINGCLEANUPRUN,     pendingcleanuprunMode);
    7983        MODECASE(STACKTOOL_MODE_PENDINGCLEANUPSKYFILE, pendingcleanupskyfileMode);
    … …  
    11251129}
    11261130#endif
     1131static bool tosummaryMode(pxConfig *config) {
     1132  PS_ASSERT_PTR_NON_NULL(config, NULL);
     1133 
     1134  psMetadata *where = psMetadataAlloc();
     1135  PXOPT_COPY_S64(config->args, where, "-stack_id",    "stackSumSkyfile.warp_id", "==");
     1136  PXOPT_COPY_STR(config->args, where, "-tess_id",    "stackSumSkyfile.tess_id", "==");
     1137  PXOPT_COPY_STR(config->args, where, "-state",      "stackRun.state", "==");
     1138  PXOPT_COPY_STR(config->args, where, "-filter",    "stackRun.filter", "LIKE");
     1139  pxAddLabelSearchArgs (config, where, "-label",   "stackRun.label", "LIKE");
     1140  pxAddLabelSearchArgs (config, where, "-data_group",   "stackRun.data_group", "LIKE");
     1141 
     1142  PXOPT_LOOKUP_BOOL(all, config->args, "-all", false);
     1143
     1144  PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1145  PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1146 
     1147  // find all rawImfiles matching the default query
     1148  psString query = pxDataGet("stacktool_tosummary.sql");
     1149  if (!query) {
     1150    psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1151    return false;
     1152  }
     1153
     1154  // generate where strings for arguments that require extra processing
     1155  // beyond PXOPT_COPY*
     1156  if (psListLength(where->list)) {
     1157    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1158    psStringAppend(&query, " WHERE %s", whereClause);
     1159    psFree(whereClause);
     1160  } else if (!all) {
     1161    psError(PXTOOLS_ERR_CONFIG, true, "search parameters or -all are required");
     1162    return false;
     1163  }
     1164 
     1165  psFree(where);
     1166
     1167  // treat limit == 0 as "no limit"
     1168  if (limit) {
     1169    psString limitString = psDBGenerateLimitSQL(limit);
     1170    psStringAppend(&query, " %s", limitString);
     1171    psFree(limitString);
     1172  }
     1173 
     1174  if (!p_psDBRunQuery(config->dbh, query)) {
     1175    psError(PS_ERR_UNKNOWN, false, "database error");
     1176    psFree(query);
     1177    return false;
     1178  }
     1179  psFree(query);
     1180
     1181  psArray *output = p_psDBFetchResult(config->dbh);
     1182  if (!output) {
     1183    psErrorCode err = psErrorCodeLast();
     1184    switch (err) {
     1185    case PS_ERR_DB_CLIENT:
     1186      psError(PXTOOLS_ERR_SYS, false, "database error");
     1187    case PS_ERR_DB_SERVER:
     1188      psError(PXTOOLS_ERR_PROG, false, "database error");
     1189    default:
     1190      psError(PXTOOLS_ERR_PROG, false, "unknown error");
     1191    }
     1192   
     1193    return false;
     1194  }
     1195  if (!psArrayLength(output)) {
     1196    psTrace("stacktool", PS_LOG_INFO, "no rows found");
     1197    psFree(output);
     1198    return true;
     1199  }
     1200 
     1201  if (psArrayLength(output)) {
     1202    // negative simple so the default is true
     1203    if (!ippdbPrintMetadatas(stdout, output, "stackRun", !simple)) {
     1204      psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1205      psFree(output);
     1206      return false;
     1207    }
     1208  }
     1209 
     1210  psFree(output);
     1211  return(true);
     1212}
     1213static bool addsummaryMode(pxConfig *config) {
     1214  PS_ASSERT_PTR_NON_NULL(config, NULL);
     1215
     1216  PXOPT_LOOKUP_S64(stack_id, config->args, "-stack_id", true, false);
     1217  PXOPT_LOOKUP_STR(tangent_plane, config->args, "-tangent_plane", true, false);
     1218  PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", true, false);
     1219
     1220  psString query = pxDataGet("stacktool_addsummary.sql");
     1221  if (!query) {
     1222    psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1223    return(false);
     1224  }
     1225  if (!p_psDBRunQueryF(config->dbh, query, stack_id, tangent_plane, path_base)) {
     1226    psError(PS_ERR_UNKNOWN, false, "database error");
     1227    psFree(query);
     1228    return(false);
     1229  }
     1230  psS64 numUpdated = psDBAffectedRows(config->dbh);
     1231 
     1232  if (numUpdated != 1) {
     1233    psError(PS_ERR_UNKNOWN, false, "should have affected 1 row");
     1234    psFree(query);
     1235    return false;
     1236  }
     1237 
     1238  psFree(query);
     1239
     1240  // Print anything here?
     1241 
     1242  return(true);
     1243}
    11271244
    11281245static bool pendingcleanuprunMode(pxConfig *config)

  • branches/czw_branch/20100519/ippTools/src/stacktool.h

    r23310 r28164  
    3434    STACKTOOL_MODE_SUMSKYFILE,
    3535    STACKTOOL_MODE_REVERTSUMSKYFILE,
     36    STACKTOOL_MODE_TOSUMMARY,
     37    STACKTOOL_MODE_ADDSUMMARY,
    3638    STACKTOOL_MODE_PENDINGCLEANUPRUN,
    3739    STACKTOOL_MODE_PENDINGCLEANUPSKYFILE,

  • branches/czw_branch/20100519/ippTools/src/stacktoolConfig.c

    r28043 r28164  
    204204    psMetadataAddBool(revertsumskyfileArgs, PS_LIST_TAIL, "-all",  0, "allow no search terms", 0);
    205205
     206    // -tosummary
     207    psMetadata *tosummaryArgs = psMetadataAlloc();
     208    psMetadataAddS64(tosummaryArgs, PS_LIST_TAIL, "-stack_id", 0,  "search by stack ID", 0);
     209    psMetadataAddStr(tosummaryArgs, PS_LIST_TAIL, "-tess_id", 0,   "search by tessellation ID", NULL);
     210    psMetadataAddStr(tosummaryArgs, PS_LIST_TAIL, "-state", 0,     "search by state", NULL);
     211    psMetadataAddStr(tosummaryArgs, PS_LIST_TAIL, "-filter", 0,    "search by filter", NULL);
     212    psMetadataAddStr(tosummaryArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by stackRun label (LIKE comparison)", NULL);
     213    psMetadataAddStr(tosummaryArgs, PS_LIST_TAIL, "-data_group", PS_META_DUPLICATE_OK, "search by stackRun data_group (LIKE comparison)", NULL);
     214    psMetadataAddStr(tosummaryArgs, PS_LIST_TAIL, "-dist_group", PS_META_DUPLICATE_OK, "search by stackRun dist_group (LIKE comparison)", NULL);
     215
     216    psMetadataAddBool(tosummaryArgs, PS_LIST_TAIL, "-all",  0,             "search without arguments", false);
     217    psMetadataAddU64(tosummaryArgs, PS_LIST_TAIL,  "-limit",  0,            "limit result set to N items", 0);
     218    psMetadataAddBool(tosummaryArgs, PS_LIST_TAIL, "-simple",  0,          "use the simple output format", false);
     219
     220    // -addsummary
     221    psMetadata *addsummaryArgs = psMetadataAlloc();
     222    psMetadataAddS64(addsummaryArgs, PS_LIST_TAIL, "-stack_id", 0,      "set stack ID", 0);
     223    psMetadataAddStr(addsummaryArgs, PS_LIST_TAIL, "-tangent_plane", 0, "set tangent plane", NULL);
     224    psMetadataAddStr(addsummaryArgs, PS_LIST_TAIL, "-path_base", 0,     "set summary path base", NULL);             
     225   
    206226    // -pendingcleanuprun
    207227    psMetadata *pendingcleanuprunArgs = psMetadataAlloc();
    … …  
    257277    PXOPT_ADD_MODE("-donecleanup",           "show runs that have been cleaned",     STACKTOOL_MODE_DONECLEANUP,          donecleanupArgs);
    258278    PXOPT_ADD_MODE("-updatesumskyfile",      "update fault code for sumskyfile",     STACKTOOL_MODE_UPDATESUMSKYFILE,          updatesumskyfileArgs);
     279    PXOPT_ADD_MODE("-tosummary",            "show runs that can be summarized", STACKTOOL_MODE_TOSUMMARY, tosummaryArgs);
     280    PXOPT_ADD_MODE("-addsummary",           "add entry to the summary table", STACKTOOL_MODE_ADDSUMMARY, addsummaryArgs);
    259281    PXOPT_ADD_MODE("-exportrun",            "export run for import on other database", STACKTOOL_MODE_EXPORTRUN, exportrunArgs);
    260282    PXOPT_ADD_MODE("-importrun",            "import run from metadata file",           STACKTOOL_MODE_IMPORTRUN, importrunArgs);

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

    r27963 r28164  
    11/*
    2  * stacktool.c
     2 * staticskytool.c
    33 *
    44 * Copyright (C) 2007-2010  Joshua Hoblitt, Paul Price
    … …  
    2929
    3030#include "pxtools.h"
    31 #include "stacktool.h"
     31#include "staticskytool.h"
    3232
    3333static bool definebyqueryMode(pxConfig *config);
    34 static bool definerunMode(pxConfig *config);
    3534static bool updaterunMode(pxConfig *config);
    36 static bool addinputskyfileMode(pxConfig *config);
    37 static bool inputskyfileMode(pxConfig *config);
    38 static bool tosumMode(pxConfig *config);
    39 static bool addsumskyfileMode(pxConfig *config);
    40 static bool sumskyfileMode(pxConfig *config);
    41 static bool revertsumskyfileMode(pxConfig *config);
    42 static bool pendingcleanuprunMode(pxConfig *config);
    43 static bool pendingcleanupskyfileMode(pxConfig *config);
    44 static bool donecleanupMode(pxConfig *config);
    45 static bool updatesumskyfileMode(pxConfig *config);
     35static bool inputsMode(pxConfig *config);
     36static bool todoMode(pxConfig *config);
     37static bool addresultMode(pxConfig *config);
     38static bool resultMode(pxConfig *config);
     39static bool revertMode(pxConfig *config);
     40static bool updateresult(pxConfig *config);
    4641static bool exportrunMode(pxConfig *config);
    4742static bool importrunMode(pxConfig *config);
    48 
    49 static bool setstackRunState(pxConfig *config, psS64 stack_id, const char *state);
    5043
    5144# define MODECASE(caseName, func) \
    … …  
    6053    psLibInit(NULL);
    6154
    62     pxConfig *config = stacktoolConfig(NULL, argc, argv);
     55    pxConfig *config = staticskytoolConfig(NULL, argc, argv);
    6356    if (!config) {
    6457        psError(PXTOOLS_ERR_CONFIG, false, "failed to configure");
    … …  
    6760
    6861    switch (config->mode) {
    69         MODECASE(STACKTOOL_MODE_DEFINEBYQUERY, definebyqueryMode);
    70         MODECASE(STACKTOOL_MODE_UPDATERUN,     updaterunMode);
    71         MODECASE(STACKTOOL_MODE_INPUTS,        inputsMode);
    72         MODECASE(STACKTOOL_MODE_TODO,          todoMode);
    73         MODECASE(STACKTOOL_MODE_ADDRESULT,     addresultMode);
    74         MODECASE(STACKTOOL_MODE_RESULT,        resultMode);
    75         MODECASE(STACKTOOL_MODE_REVERT,        revertMode);
    76         MODECASE(STACKTOOL_MODE_UPDATERESULT,  updateresultMode);
    77         MODECASE(STACKTOOL_MODE_EXPORTRUN,     exportrunMode);
    78         MODECASE(STACKTOOL_MODE_IMPORTRUN,     importrunMode);
     62        MODECASE(STATICSKYTOOL_MODE_DEFINEBYQUERY,    definebyqueryMode);
     63        MODECASE(STATICSKYTOOL_MODE_UPDATERUN,         updaterunMode);
     64        MODECASE(STATICSKYTOOL_MODE_INPUTS,            inputsMode);
     65        MODECASE(STATICSKYTOOL_MODE_TODO,              todoMode);
     66        MODECASE(STATICSKYTOOL_MODE_ADDRESULT,         addresultMode);
     67        MODECASE(STATICSKYTOOL_MODE_RESULT,            resultMode);
     68        MODECASE(STATICSKYTOOL_MODE_REVERT,            revertMode);
     69        MODECASE(STATICSKYTOOL_MODE_UPDATERESULT,      updateresult);
     70        MODECASE(STATICSKYTOOL_MODE_EXPORTRUN,         exportrunMode);
     71        MODECASE(STATICSKYTOOL_MODE_IMPORTRUN,         importrunMode);
    7972        default:
    8073            psAbort("invalid option (this should not happen)");
    … …  
    114107    PXOPT_LOOKUP_TIME(registered, config->args, "-set_registered", false, false);
    115108
    116     psMetadata *where = psMetadataAlloc();
    117     psMetadata *having = psMetadataAlloc(); // HAVING clause
    118 
    119     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");
    123 
    124     // these are used to build the HAVING restriction
    125     PXOPT_COPY_S32(config->args, having, "-min_num",    "num",        ">=");
    126     PXOPT_COPY_S32(config->args, having, "-min_filter", "num_filter", ">=");
     109    psMetadata *whereMD = psMetadataAlloc();
     110
     111    PXOPT_COPY_STR(config->args, whereMD, "-select_skycell_id",    "stackRun.skycell_id",       "==");
     112    PXOPT_COPY_STR(config->args, whereMD, "-select_tess_id",       "stackRun.tess_id",          "==");
     113    PXOPT_COPY_F32(config->args, whereMD, "-select_good_frac_min", "stackSumSkyfile.good_frac", ">=");
     114    pxAddLabelSearchArgs(config, whereMD, "-select_label",         "stackRun.label",            "LIKE");
     115    pxAddLabelSearchArgs(config, whereMD, "-select_filter",        "stackRun.filter",           "LIKE");
     116
     117    // find the number of requested filters:
     118    psMetadataItem *filters = psMetadataLookup(config->args, "-select_filter");
     119    psAssert (filters, "-select_filter must exist");
     120    psAssert (filters->type == PS_DATA_METADATA_MULTI, "-select_filter should be a multi container");
     121    psAssert (filters->data.list->n, "-select_filter should at least have a place-holder");
     122    int num_filter = filters->data.list->n;
     123    if (num_filter < 2) {
     124        psError(PXTOOLS_ERR_CONFIG, false, "invalid request: only 1 filter selected");
     125        psFree(whereMD);
     126        return false;
     127    }
    127128
    128129    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    129130    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
    130 
    131     if (!psListLength(where->list)) {
    132         psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    133         psFree(where);
    134         psFree(having);
    135         return false;
    136     }
    137131
    138132    psString select = pxDataGet("staticskytool_definebyquery_select.sql");
    139133    if (!select) {
    140134        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    141         psFree(where);
    142         psFree(having);
    143         return false;
    144     }
    145 
    146     psString where1 = psStringCopy("");
    147     if (psListLength(where->list)) {
    148         psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    149         psStringAppend(&where1, "\nAND %s", whereClause);
    150         psFree(whereClause);
    151     }
    152 
    153     psString where2 = psStringCopy("");
    154     if (label) {
    155         psStringAppend(&where2, "\nWHERE stackRun.label = '%s'", label);
    156     }
    157 
    158     // Restriction on aggregated quantities using HAVING
    159     {
    160         psString havingClause = NULL;   // HAVING string
    161         if (psListLength(having->list)) {
    162             havingClause = psDBGenerateWhereConditionSQL(having, NULL);
    163         }
    164 
    165         if (min_new > 0) {
    166             if (havingClause) {
    167                 psStringAppend(&havingClause, " AND");
    168             }
    169             psStringAppend(&havingClause,
    170                            " (num_warp - num_stack >= %d OR (num_warp >= %d AND num_stack IS NULL))",
    171                            min_new, min_new);
    172         }
    173         if (isfinite(min_frac)) {
    174             if (havingClause) {
    175                 psStringAppend(&havingClause, " AND");
    176             }
    177             // Avoiding division by zero
    178             psStringAppend(&havingClause, " (num_warp >= %f * num_stack OR num_stack IS NULL)",
    179                            (double)min_frac);
    180         }
    181         if (havingClause) {
    182             psStringAppend(&select, " HAVING %s", havingClause);
    183             psFree(havingClause);
    184         }
    185     }
    186     psFree(having);
    187 
    188     if (!p_psDBRunQueryF(config->dbh, select, where1, where2)) {
     135        psFree(whereMD);
     136        return false;
     137    }
     138
     139    if (!psListLength(whereMD->list)) {
     140        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     141        psFree(whereMD);
     142        return false;
     143    }
     144
     145    // this 'where' is used for both staticskytool_definebyquery_select.sql and staticskytool_definebyquery_inputs.sql
     146    psString where = NULL;
     147    psString whereClause = psDBGenerateWhereConditionSQL(whereMD, NULL);
     148    psStringAppend(&where, "\nAND %s", whereClause);
     149    psFree(whereClause);
     150    psFree(whereMD);
     151
     152    if (!p_psDBRunQueryF(config->dbh, select, where, num_filter)) {
    189153        psError(PS_ERR_UNKNOWN, false, "database error");
    190154        psFree(select);
    191         psFree(where1);
    192         psFree(where2);
    193155        return false;
    194156    }
    195157    psFree(select);
    196     psFree(where1);
    197     psFree(where2);
     158
     159    // we now have a list of (tess_id, skycell_id) that (potentially) meet out needs
     160    // we now need to loop over all of these and for each pair, select the best set of
     161    // inputs
    198162
    199163    psArray *output = p_psDBFetchResult(config->dbh);
    … …  
    212176    }
    213177    if (!psArrayLength(output)) {
    214         psWarning("stacktool: no rows found");
     178        psWarning("staticskytool: no rows found");
    215179        psFree(output);
    216180        psFree(where);
    … …  
    219183    if (pretend) {
    220184        // negative simple so the default is true
    221         if (!ippdbPrintMetadatas(stdout, output, "stackSkycells", !simple)) {
     185        if (!ippdbPrintMetadatas(stdout, output, "staticskyInput", !simple)) {
    222186            psError(PS_ERR_UNKNOWN, false, "failed to print array");
    223187            psFree(output);
    … …  
    230194    }
    231195
    232     psString insert = NULL;             // Insertion query
    233     if (randomLimit > 0) {
    234         insert = pxDataGet("stacktool_definebyquery_insert_random_part1.sql");
    235     } else {
    236         insert = pxDataGet("stacktool_definebyquery_insert.sql");
    237     }
    238     if (!insert) {
     196    psString inputsSQL = pxDataGet("staticskytool_definebyquery_inputs.sql");
     197    if (!inputsSQL) {
    239198        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    240199        psFree(where);
    … …  
    242201    }
    243202
    244     if (psListLength(where->list)) {
    245         psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    246         psStringAppend(&insert, " AND %s", whereClause);
    247         psFree(whereClause);
    248     }
    249     psFree(where);
    250 
    251     if (randomLimit > 0) {
    252         psString part2 = pxDataGet("stacktool_definebyquery_insert_random_part2.sql");
    253         if (!part2) {
    254             psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    255             psFree(insert);
    256             return false;
    257         }
    258         psStringAppend(&insert, "%s", part2);
    259         psFree(part2);
    260     }
    261 
    262     if (!psDBTransaction(config->dbh)) {
    263         psError(PS_ERR_UNKNOWN, false, "database error");
    264         psFree(where);
    265         return false;
    266     }
    267 
    268     psArray *list = psArrayAllocEmpty(16); // List of runs, to print
    269203    for (long i = 0; i < output->n; i++) {
    270204        psMetadata *row = output->data[i]; // Row from select
    … …  
    276210            psError(PS_ERR_UNKNOWN, false, "failed to lookup skycell_id");
    277211            psFree(output);
    278             psFree(insert);
    279             psFree(list);
     212            psFree(inputsSQL);
    280213            if (!psDBRollback(config->dbh)) {
    281214                psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    288221            psError(PS_ERR_UNKNOWN, false, "failed to lookup tess_id");
    289222            psFree(output);
    290             psFree(insert);
    291             psFree(list);
     223            psFree(inputsSQL);
    292224            if (!psDBRollback(config->dbh)) {
    293225                psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    296228        }
    297229
    298         psString filter = psMetadataLookupStr(&status, row, "filter");
    299         if (!status) {
    300             psError(PS_ERR_UNKNOWN, false, "failed to lookup filter");
     230        // query for the inputs
     231        if (!p_psDBRunQueryF(config->dbh, inputsSQL, tess_id, skycell_id, where)) {
     232            psError(PS_ERR_UNKNOWN, false, "database error");
    301233            psFree(output);
    302             psFree(insert);
    303             psFree(list);
    304             if (!psDBRollback(config->dbh)) {
    305                 psError(PS_ERR_UNKNOWN, false, "database error");
    306             }
    307             return false;
    308         }
    309 
    310         // create a new stackRun for this stack
    311         stackRunRow *run = stackRunRowAlloc(
    312             0,                          // ID
    313             "new",                      // state
    314             workdir,
    315             label,
    316             data_group ? data_group : label,
    317             dist_group,
    318             reduction,
    319             dvodb,
    320             registered,
    321             skycell_id,
    322             tess_id,
    323             filter,
    324             note);
    325 
    326         if (!stackRunInsertObject(config->dbh, run)) {
    327             if (!psDBRollback(config->dbh)) {
    328                 psError(PS_ERR_UNKNOWN, false, "database error");
    329             }
    330             psError(PS_ERR_UNKNOWN, false, "database error");
     234            psFree(inputsSQL);
     235            return false;
     236        }
     237       
     238        psArray *inputs = p_psDBFetchResult(config->dbh);
     239        if (!inputs) {
     240            psErrorCode err = psErrorCodeLast();
     241            switch (err) {
     242              case PS_ERR_DB_CLIENT:
     243                psError(PXTOOLS_ERR_SYS, false, "database error");
     244              case PS_ERR_DB_SERVER:
     245                psError(PXTOOLS_ERR_PROG, false, "database error");
     246              default:
     247                psError(PXTOOLS_ERR_PROG, false, "unknown error");
     248            }
     249            psFree(inputs);
    331250            psFree(output);
    332             psFree(run);
    333             psFree(insert);
    334             psFree(list);
    335             if (!psDBRollback(config->dbh)) {
    336                 psError(PS_ERR_UNKNOWN, false, "database error");
    337             }
    338             return false;
    339         }
    340 
    341         // figure out the new stack_id
    342         psS64 stack_id = psDBLastInsertID(config->dbh);
    343         run->stack_id = stack_id;
    344 
    345         psArrayAdd(list, list->n, run);
    346         psFree(run);
    347 
    348         // Create a suitable insertion query for this run
    349         psString thisInsert = psStringCopy(insert);
    350         psString idString = NULL;
    351         psStringAppend(&idString, "%" PRId64, stack_id);
    352         psStringSubstitute(&thisInsert, idString, "@STACK_ID@");
    353         psFree(idString);
    354 
    355         // replace @FILTER@, @SKYCELL_ID@, @RANDOM_LIMIT@
    356         psStringSubstitute(&thisInsert, filter, "@FILTER@");
    357         psStringSubstitute(&thisInsert, skycell_id, "@SKYCELL_ID@");
    358 
    359         if (randomLimit > 0) {
    360           psString limString = NULL;
    361           psStringAppend(&limString, "%d", randomLimit);
    362           psStringSubstitute(&thisInsert, limString, "@RANDOM_LIMIT@");
    363           psFree(limString);
    364         }
    365 
    366         // XXX this insert uses a select to generate the list of warp_ids for the stack,
    367         // we have applied a set of criteria above (WHERE) to select the relevant warps
    368         // this insert needs to use exactly the same restrictions (race condition is probably not critical)
    369         // the insert below seems to only restrict matches to the skycell, tess, and filter
    370         if (!p_psDBRunQuery(config->dbh, thisInsert)) {
    371             psError(PS_ERR_UNKNOWN, false, "database error");
    372             psFree(thisInsert);
    373             psFree(insert);
     251            psFree(inputsSQL);
     252            return false;
     253        }
     254        if (!psArrayLength(inputs)) {
     255            psWarning("staticskytool ERROR: no rows found for known tess_id, skycell_id?");
     256            continue;
     257        }
     258
     259        // XXX if we are unable to guarantee that all selected inputs have all and only the
     260        // requested filters, see the code at the bottom of this file (ifdef'ed out for now)
     261
     262        // insert a new staticsky entry and find its new id
     263        if (!psDBTransaction(config->dbh)) {
     264            psError(PS_ERR_UNKNOWN, false, "database error");
     265            psFree(inputs);
    374266            psFree(output);
    375             psFree(list);
    376             if (!psDBRollback(config->dbh)) {
    377                 psError(PS_ERR_UNKNOWN, false, "database error");
    378             }
    379             return false;
    380         }
    381         psFree(thisInsert);
    382 
    383 # if (0)
    384         {
    385           psArray *output = p_psDBFetchResult(config->dbh);
    386           if (!output) {
    387             psErrorCode err = psErrorCodeLast();
    388             switch (err) {
    389             case PS_ERR_DB_CLIENT:
    390               psError(PXTOOLS_ERR_SYS, false, "database error");
    391             case PS_ERR_DB_SERVER:
    392               psError(PXTOOLS_ERR_PROG, false, "database error");
    393             default:
    394               psError(PXTOOLS_ERR_PROG, false, "unknown error");
    395             }
    396             psFree(where);
    397             return false;
    398           }
    399           if (!psArrayLength(output)) {
    400             psWarning("stacktool (definebyquery, insert): no rows found");
     267            psFree(inputsSQL);
     268            return false;
     269        }
     270
     271        // create a chipRun
     272        if (!staticskyRunInsert(config->dbh,
     273                                0x0,         // sky_id
     274                                "new",       // state
     275                                workdir,
     276                                label,
     277                                data_group,
     278                                dist_group,
     279                                reduction,
     280                                registered,
     281                                note
     282                )
     283            ) {
     284            if (!psDBRollback(config->dbh)) {
     285                psError(PS_ERR_UNKNOWN, false, "database error failed to rollback transaction");
     286            }
     287            psError(PS_ERR_UNKNOWN, false, "database error");
     288            psFree(inputs);
    401289            psFree(output);
    402             psFree(where);
    403             return true;
    404           }
    405           // negative simple so the default is true
    406           if (!ippdbPrintMetadatas(stdout, output, "stackSkycells", !simple)) {
    407             psError(PS_ERR_UNKNOWN, false, "failed to print array");
    408             psFree(output);
    409             psFree(where);
    410             return false;
    411           }
    412           psFree(output);
    413           psFree(where);
    414           return true;
    415         }
    416 # endif
    417 
    418     }
     290            psFree(inputsSQL);
     291            return false;
     292        }
     293
     294        psS64 sky_id =  psDBLastInsertID(config->dbh);
     295
     296        // loop over the possible inputs and record only the valid ones
     297        for (int j = 0; j < inputs->n; j++) {
     298            psMetadata *inputRow = inputs->data[j]; // Row from select
     299           
     300            // pull out the skycell_id, tess_id, filter
     301            psS64 stack_id = psMetadataLookupS64(&status, inputRow, "stack_id");
     302            psAssert(status, "failed to find stack_id?");
     303           
     304            // add a staticskyInput entry
     305            if (!staticskyInputInsert(config->dbh, sky_id, stack_id)) {
     306                if (!psDBRollback(config->dbh)) {
     307                    psError(PS_ERR_UNKNOWN, false, "database error failed to rollback transaction");
     308                }
     309                psError(PS_ERR_UNKNOWN, false, "database error");
     310                psFree(inputs);
     311                psFree(output);
     312                psFree(inputsSQL);
     313                return false;
     314            }
     315        }
     316        psFree (inputs);
     317       
     318        if (!psDBCommit(config->dbh)) {
     319            psError(PS_ERR_UNKNOWN, false, "database error");
     320            psFree(output);
     321            psFree(inputsSQL);
     322            return false;
     323        }
     324    }
     325    psFree(inputsSQL);
    419326    psFree(output);
    420 
    421     if (!psDBCommit(config->dbh)) {
    422         psError(PS_ERR_UNKNOWN, false, "database error");
    423         psFree(list);
    424         return false;
    425     }
    426 
    427     if (!stackRunPrintObjects(stdout, list, !simple)) {
    428         psError(PS_ERR_UNKNOWN, false, "failed to print object");
    429         psFree(list);
    430         return false;
    431     }
    432     psFree(list);
    433327    return true;
    434328}
    … …  
    438332    PS_ASSERT_PTR_NON_NULL(config, false);
    439333
    440 #ifdef notdef
    441     PXOPT_LOOKUP_S64(stack_id, config->args, "-stack_id", false, false);
    442     PXOPT_LOOKUP_STR(state, config->args, "-state", true, false);
    443     PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
    444 #endif
    445334    psMetadata *where = psMetadataAlloc();
    446     PXOPT_COPY_S64(config->args, where, "-stack_id",  "stack_id",   "==");
    447     PXOPT_COPY_STR(config->args, where, "-label",     "label",     "==");
    448     PXOPT_COPY_STR(config->args, where, "-state",     "state",     "==");
     335    PXOPT_COPY_S64(config->args, where, "-sky_id",  "sky_id",   "==");
     336    PXOPT_COPY_STR(config->args, where, "-label",   "label",    "==");
     337    PXOPT_COPY_STR(config->args, where, "-state",   "state",    "==");
    449338    if (!psListLength(where->list)) {
    450339        psFree(where);
    … …  
    453342    }
    454343
    455     psString query = psStringCopy("UPDATE stackRun");
     344    psString query = psStringCopy("UPDATE staticskyRun");
    456345
    457346    // pxUpdateRun gets parameters from config->args and updates
    458     bool result = pxUpdateRun(config, where, &query, "stackRun", "stack_id", "stackSumSkyfile", true);
    459 
     347    bool result = pxUpdateRun(config, where, &query, "staticskyRun", "sky_id", "staticskyResult", true);
    460348    psFree(query);
    461349    psFree(where);
    462350
    463351    return result;
    464 
    465 #ifdef notdef
    466     // Hack-y work around to make stacktool more like the other tools, without breaking other stuff (hopefully).
    467 
    468     if ((state)&&(stack_id)) {
    469         // set detRun.state to state
    470         return setstackRunState(config, stack_id, state);
    471     }
    472 
    473     if ((state)&&(label)) {
    474       return setstackRunStateByLabel(config, label, state);
    475     }
    476 
    477     psError(PS_ERR_UNKNOWN, false, "Required options not found.");
    478     return false;
    479 #endif
    480352}
    481353
    … …  
    485357    PS_ASSERT_PTR_NON_NULL(config, false);
    486358
    487     // XXX require at least a stack id (add better search options)
    488     PXOPT_LOOKUP_S64(stack_id, config->args, "-stack_id", true, false);
     359    // XXX require at least a sky id (add better search options)
     360    PXOPT_LOOKUP_S64(sky_id, config->args, "-sky_id", true, false);
    489361
    490362    psMetadata *where = psMetadataAlloc();
    491     PXOPT_COPY_S64(config->args, where, "-warp_id", "warp_id", "==");
    492     PXOPT_COPY_S64(config->args, where, "-stack_id", "stack_id", "==");
     363    PXOPT_COPY_S64(config->args, where, "-sky_id", "sky_id", "==");
    493364
    494365    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    495366    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    496367
    497     psString query = pxDataGet("stacktool_inputskyfile.sql");
     368    psString query = pxDataGet("staticskytool_inputs.sql");
    498369    if (!query) {
    499370        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    … …  
    502373
    503374    if (psListLength(where->list)) {
    504         psString whereClause = psDBGenerateWhereConditionSQL(where, "stackInputSkyfile");
    505         psStringAppend(&query, " AND %s", whereClause);
     375        psString whereClause = psDBGenerateWhereConditionSQL(where, "staticskyInput");
     376        psStringAppend(&query, " WHERE %s", whereClause);
    506377        psFree(whereClause);
    507378    }
    … …  
    537408    }
    538409    if (!psArrayLength(output)) {
    539         psTrace("stacktool", PS_LOG_INFO, "no rows found");
     410        psTrace("staticskytool", PS_LOG_INFO, "no rows found");
    540411        psFree(output);
    541412        return true;
    … …  
    544415    if (psArrayLength(output)) {
    545416        // negative simple so the default is true
    546         if (!ippdbPrintMetadatas(stdout, output, "stackInputSkyfile", !simple)) {
     417        if (!ippdbPrintMetadatas(stdout, output, "staticskyInput", !simple)) {
    547418            psError(PS_ERR_UNKNOWN, false, "failed to print array");
    548419            psFree(output);
    … …  
    561432    PS_ASSERT_PTR_NON_NULL(config, false);
    562433
    563     psMetadata *where = psMetadataAlloc();
    564     PXOPT_COPY_S64(config->args, where, "-warp_id", "warp_id", "==");
    565     PXOPT_COPY_S64(config->args, where, "-stack_id", "stack_id", "==");
    566     pxAddLabelSearchArgs (config, where, "-label", "stackRun.label", "==");
     434    psMetadata *whereMD = psMetadataAlloc();
     435    PXOPT_COPY_S64(config->args, whereMD, "-sky_id", "sky_id", "==");
     436    pxAddLabelSearchArgs (config, whereMD, "-label", "staticskyRun.label", "==");
    567437
    568438    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    569439    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    570440
    571     psString query = pxDataGet("stacktool_tosum.sql");
     441    psString query = pxDataGet("staticskytool_todo.sql");
    572442    if (!query) {
    573443        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    … …  
    575445    }
    576446
    577     if (psListLength(where->list)) {
    578         psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    579         psStringAppend(&query, " AND %s", whereClause);
    580         psFree(whereClause);
    581     }
    582     psFree(where);
     447    if (!psListLength(whereMD->list)) {
     448        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     449        psFree(whereMD);
     450        return false;
     451    }
     452
     453    psString where = NULL;
     454    psString whereClause = psDBGenerateWhereConditionSQL(whereMD, NULL);
     455    psStringAppend(&where, "\n AND %s", whereClause);
     456    psFree(whereClause);
     457    psFree(whereMD);
    583458
    584459    // treat limit == 0 as "no limit"
    … …  
    589464    }
    590465
    591     if (!p_psDBRunQuery(config->dbh, query)) {
     466    // the where clause is required and matches the WHERE hook format string
     467    if (!p_psDBRunQueryF(config->dbh, query, where)) {
    592468        psError(PS_ERR_UNKNOWN, false, "database error");
    593469        psFree(query);
    … …  
    611487    }
    612488    if (!psArrayLength(output)) {
    613         psTrace("stacktool", PS_LOG_INFO, "no rows found");
     489        psTrace("staticskytool", PS_LOG_INFO, "no rows found");
    614490        psFree(output);
    615491        return true;
    … …  
    618494    if (psArrayLength(output)) {
    619495        // negative simple so the default is true
    620         if (!ippdbPrintMetadatas(stdout, output, "stackSumSkyfile", !simple)) {
     496        if (!ippdbPrintMetadatas(stdout, output, "staticskyResult", !simple)) {
    621497            psError(PS_ERR_UNKNOWN, false, "failed to print array");
    622498            psFree(output);
    … …  
    626502
    627503    psFree(output);
    628 
    629504    return true;
    630505}
    631506
    632 
    633507static bool addresultMode(pxConfig *config)
    634508{
    … …  
    636510
    637511    // required
    638     PXOPT_LOOKUP_S64(stack_id, config->args, "-stack_id", true, false);
     512    PXOPT_LOOKUP_S64(sky_id, config->args, "-sky_id", true, false);
    639513
    640514    // optional
    641     PXOPT_LOOKUP_STR(uri, config->args, "-uri", false, false);
    642515    PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", false, false);
    643     PXOPT_LOOKUP_F64(bg, config->args, "-bg", false, false);
    644     PXOPT_LOOKUP_F64(bg_stdev, config->args, "-bg_stdev", false, false);
    645     PXOPT_LOOKUP_F32(dtime_stack, config->args, "-dtime_stack", false, false);
    646     PXOPT_LOOKUP_F32(dtime_match_mean, config->args, "-dtime_match_mean", false, false);
    647     PXOPT_LOOKUP_F32(dtime_match_stdev, config->args, "-dtime_match_stdev", false, false);
    648     PXOPT_LOOKUP_F32(dtime_initial, config->args, "-dtime_initial", false, false);
    649     PXOPT_LOOKUP_F32(dtime_reject, config->args, "-dtime_reject", false, false);
    650     PXOPT_LOOKUP_F32(dtime_final, config->args, "-dtime_final", false, false);
    651516    PXOPT_LOOKUP_F32(dtime_phot, config->args, "-dtime_phot", false, false);
    652517    PXOPT_LOOKUP_F32(dtime_script, config->args, "-dtime_script", false, false);
    653     PXOPT_LOOKUP_F32(match_mean, config->args, "-match_mean", false, false);
    654     PXOPT_LOOKUP_F32(match_stdev, config->args, "-match_stdev", false, false);
    655     PXOPT_LOOKUP_F32(match_rms, config->args, "-match_rms", false, false);
    656     PXOPT_LOOKUP_F32(stamps_mean, config->args, "-stamps_mean", false, false);
    657     PXOPT_LOOKUP_F32(stamps_stdev, config->args, "-stamps_stdev", false, false);
    658     PXOPT_LOOKUP_S32(stamps_min, config->args, "-stamps_min", false, false);
    659     PXOPT_LOOKUP_S32(reject_images, config->args, "-reject_images", false, false);
    660     PXOPT_LOOKUP_F32(reject_pix_mean, config->args, "-reject_pix_mean", false, false);
    661     PXOPT_LOOKUP_F32(reject_pix_stdev, config->args, "-reject_pix_stdev", false, false);
    662518    PXOPT_LOOKUP_S32(sources, config->args, "-sources", false, false);
    663519    PXOPT_LOOKUP_STR(hostname, config->args, "-hostname", false, false);
    664520    PXOPT_LOOKUP_F32(good_frac, config->args, "-good_frac", false, false);
     521    PXOPT_LOOKUP_S32(num_inputs, config->args, "-num_inputs", false, false);
    665522
    666523    // default values
    … …  
    668525    PXOPT_LOOKUP_S16(quality, config->args, "-quality", false, false);
    669526
     527    // XXX not sure we need a transaction here...
    670528    if (!psDBTransaction(config->dbh)) {
    671529        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    673531    }
    674532
    675     // XXX need to validate the stack_id here
    676     // XXX instead of validiting it here we should just use forgein key
    677     // constrants
    678     if (!stackSumSkyfileInsert(config->dbh,
    679                                stack_id,
    680                                uri,
     533    if (!staticskyResultInsert(config->dbh,
     534                               sky_id,
    681535                               path_base,
    682                                bg,
    683                                bg_stdev,
    684                                dtime_stack,
    685                                dtime_match_mean,
    686                                dtime_match_stdev,
    687                                dtime_initial,
    688                                dtime_reject,
    689                                dtime_final,
    690536                               dtime_phot,
    691537                               dtime_script,
    692                                match_mean,
    693                                match_stdev,
    694                                match_rms,
    695                                stamps_mean,
    696                                stamps_stdev,
    697                                stamps_min,
    698                                reject_images,
    699                                reject_pix_mean,
    700                                reject_pix_stdev,
    701538                               sources,
     539                               num_inputs,
    702540                               hostname,
    703541                               good_frac,
    … …  
    712550    }
    713551
    714     if (fault == 0) {
    715         if (!setstackRunState(config, stack_id, "full")) {
    716             if (!psDBRollback(config->dbh)) {
    717                 psError(PS_ERR_UNKNOWN, false, "database error");
    718             }
    719             psError(PS_ERR_UNKNOWN, false, "failed to change stackRun's state");
    720             return false;
    721         }
    722     }
    723 
    724552    // point of no return
    725553    if (!psDBCommit(config->dbh)) {
    … …  
    731559}
    732560
    733 
     561// XXX what is this used by?  what filters are needed?
    734562static bool resultMode(pxConfig *config)
    735563{
    … …  
    737565
    738566    psMetadata *where = psMetadataAlloc();
    739     PXOPT_COPY_S64(config->args, where, "-stack_id", "stackSumSkyfile.stack_id", "==");
    740     PXOPT_COPY_STR(config->args, where, "-tess_id", "stackRun.tess_id", "==");
    741     PXOPT_COPY_STR(config->args, where, "-skycell_id", "stackRun.skycell_id", "==");
    742     PXOPT_COPY_STR(config->args, where, "-filter", "stackRun.filter", "LIKE");
    743     PXOPT_COPY_STR(config->args, where, "-label", "stackRun.label", "==");
    744     PXOPT_COPY_STR(config->args, where, "-data_group", "stackRun.data_group", "LIKE");
    745     PXOPT_COPY_S16(config->args, where, "-fault", "stackSumSkyfile.fault", "==");
    746 
    747 //  The following three selectors are incompatible with the sql so omit them
    748 //    PXOPT_COPY_S64(config->args, where, "-warp_id", "warpRun.warp_id", "==");
    749 //     PXOPT_COPY_S64(config->args, where, "-exp_id", "rawExp.exp_id", "==");
    750 //    PXOPT_COPY_STR(config->args, where, "-exp_name", "rawExp.exp_name", "==");
     567    PXOPT_COPY_S64(config->args, where, "-sky_id",     "staticskyRun.sky_id", "==");
     568    PXOPT_COPY_STR(config->args, where, "-label",      "staticskyRun.label", "==");
     569    PXOPT_COPY_STR(config->args, where, "-data_group", "staticskyRun.data_group", "LIKE");
     570    PXOPT_COPY_S16(config->args, where, "-fault",      "staticskyResult.fault", "==");
    751571
    752572    PXOPT_LOOKUP_BOOL(all, config->args, "-all", false);
    … …  
    755575    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    756576
    757     psString query = pxDataGet("stacktool_sumskyfile.sql");
     577    psString query = pxDataGet("staticskytool_result.sql");
    758578    if (!query) {
    759579        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    … …  
    801621    }
    802622    if (!psArrayLength(output)) {
    803         psTrace("stacktool", PS_LOG_INFO, "no rows found");
     623        psTrace("staticskytool", PS_LOG_INFO, "no rows found");
    804624        psFree(output);
    805625        return true;
    … …  
    807627
    808628    if (psArrayLength(output)) {
    809         if (!ippdbPrintMetadatas(stdout, output, "stackSumSkyfile", !simple)) {
     629        if (!ippdbPrintMetadatas(stdout, output, "staticskyResult", !simple)) {
    810630            psError(PS_ERR_UNKNOWN, false, "failed to print array");
    811631            psFree(output);
    … …  
    819639}
    820640
    821 
    822641static bool revertMode(pxConfig *config)
    823642{
    824643    PS_ASSERT_PTR_NON_NULL(config, false);
    825644
     645# if (0)
    826646    psMetadata *where = psMetadataAlloc();
    827647    PXOPT_COPY_S64(config->args, where, "-stack_id", "stackSumSkyfile.stack_id", "==");
    … …  
    836656
    837657    // Delete product
    838     psString delete = pxDataGet("stacktool_revertsumskyfile_delete.sql");
     658    psString delete = pxDataGet("staticskytool_revertsumskyfile_delete.sql");
    839659    if (!delete) {
    840660        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    … …  
    857677
    858678    int numRows = psDBAffectedRows(config->dbh); // Number of row affected
    859     psLogMsg("stacktool", PS_LOG_INFO, "Deleted %d rows", numRows);
     679    psLogMsg("staticskytool", PS_LOG_INFO, "Deleted %d rows", numRows);
    860680
    861681    psFree(where);
     682# endif
    862683
    863684    return true;
    864685}
    865686
    866 
    867 static bool updateresultState(pxConfig *config, psS64 stack_id, const char *state)
    868 {
    869     PS_ASSERT_PTR_NON_NULL(state, false);
    870 
     687# if (0)
     688static bool updateresultState(pxConfig *config)
     689{
    871690    // check that state is a valid string value
    872691    if (!pxIsValidState(state)) {
    … …  
    881700        return false;
    882701    }
    883 
    884702    return true;
    885703}
    886 
    887 static bool updateresultMode(pxConfig *config)
     704# endif
     705
     706static bool updateresult(pxConfig *config)
    888707{
    889708    PS_ASSERT_PTR_NON_NULL(config, false);
    890709
     710# if (0)
    891711    PXOPT_LOOKUP_S16(fault, config->args, "-fault", true, false);
    892712
    … …  
    901721    psFree (where);
    902722
     723# endif
    903724    return true;
    904725}
    … …  
    906727bool exportrunMode(pxConfig *config)
    907728{
     729# if (0)
    908730  typedef struct ExportTable {
    909731    char tableName[80];
    … …  
    934756
    935757  ExportTable tables [] = {
    936     {"stackRun", "stacktool_export_run.sql"},
    937     {"stackInputSkyfile", "stacktool_export_input_skyfile.sql"},
    938     {"stackSumSkyfile", "stacktool_export_sum_skyfile.sql"},
     758    {"stackRun", "staticskytool_export_run.sql"},
     759    {"stackInputSkyfile", "staticskytool_export_input_skyfile.sql"},
     760    {"stackSumSkyfile", "staticskytool_export_sum_skyfile.sql"},
    939761  };
    940762
    … …  
    999821    fclose (f);
    1000822
     823# endif
    1001824    return true;
    1002825}
    … …  
    1004827bool importrunMode(pxConfig *config)
    1005828{
     829# if (0)
    1006830  unsigned int nFail;
    1007831
    … …  
    1072896  }
    1073897
     898# endif
    1074899  return true;
    1075900}
     901
     902# if (0)
     903        // now we need to loop over all requested filters and check that each is found
     904        // XXX is this needed?  haven't we required that we only match the requested filters
     905        // and that N unique filters are found?
     906
     907        psVector *found = psVectorAlloc(inputs->n, PS_TYPE_U8);
     908        psVectorInit (found, 0);
     909
     910        psMetadataItem *filter = NULL;
     911        psListIterator *iter = psListIteratorAlloc (filters->data.list, PS_LIST_HEAD, false);
     912        while ((filter = psListGetAndIncrement(iter))) {
     913
     914            bool foundOne = false;
     915
     916            psAssert (filter->type == PS_DATA_STR, "filter is not a string?");
     917            for (int j = 0; !foundOne && (j < inputs->n); j++) {
     918                if (found->data.U8[j]) continue;
     919                psMetadata *inputRow = inputs->data[j]; // Row from select
     920
     921                // pull out the skycell_id, tess_id, filter
     922                psString inFilter = psMetadataLookupStr(&status, row, "filter");
     923                psAssert (status);
     924
     925                found->data.U8[j] = true;
     926                foundOne = true;
     927            }
     928            if (!foundOne) {
     929                // this required filter was not found in the inputs, skip the entry
     930                skip();
     931            }
     932        }           
     933# endif
     934

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

    r27963 r28164  
    5252    psMetadataAddF32(definebyqueryArgs,  PS_LIST_TAIL, "-select_good_frac_min", 0, "define min good_frac", 0.0);
    5353    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);
     54    psMetadataAddStr(definebyqueryArgs,  PS_LIST_TAIL, "-select_filter", PS_META_DUPLICATE_OK, "search by filter (LIKE comparison, multiple required)", NULL);
    5555    psMetadataAddStr(definebyqueryArgs,  PS_LIST_TAIL, "-set_workdir", 0, "define workdir (required)", NULL);
    5656    psMetadataAddStr(definebyqueryArgs,  PS_LIST_TAIL, "-set_label", 0, "define label", NULL);
    … …  
    8989    // -addresult
    9090    psMetadata *addresultArgs = psMetadataAlloc();
    91     psMetadataAddS64(addresultArgs, PS_LIST_TAIL, "-sky_id", 0, "define stack ID (required)", 0);
     91    psMetadataAddS64(addresultArgs, PS_LIST_TAIL, "-sky_id", 0, "define sky ID (required)", 0);
    9292    psMetadataAddStr(addresultArgs, PS_LIST_TAIL, "-path_base", 0, "define base output location", 0);
    9393    psMetadataAddF32(addresultArgs, PS_LIST_TAIL, "-dtime_phot", 0, "define photometry time", NAN);
    9494    psMetadataAddF32(addresultArgs, PS_LIST_TAIL, "-dtime_script", 0, "define elapsed time in script (seconds)", NAN);
    9595    psMetadataAddS32(addresultArgs, PS_LIST_TAIL, "-sources", 0, "number of sources", 0);
     96    psMetadataAddS32(addresultArgs, PS_LIST_TAIL, "-num_inputs", 0, "number of inputs", 0);
    9697    psMetadataAddStr(addresultArgs, PS_LIST_TAIL, "-hostname", 0, "define hostname", 0);
    9798    psMetadataAddF32(addresultArgs, PS_LIST_TAIL, "-good_frac", 0, "define fraction of good pixels", NAN);
    98     psMetadataAddS16(addresultArgs, PS_LIST_TAIL, "-quality", 0, "set quality", 0)
     99    psMetadataAddS16(addresultArgs, PS_LIST_TAIL, "-quality", 0, "set quality", 0);
    99100    psMetadataAddS16(addresultArgs, PS_LIST_TAIL, "-fault", 0, "set fault code", 0);
    100101
    … …  
    102103    psMetadata *resultArgs= psMetadataAlloc();
    103104    psMetadataAddS64(resultArgs, PS_LIST_TAIL, "-sky_id", 0, "search by staticsky ID", 0);
    104     psMetadataAddStr(resultArgs, PS_LIST_TAIL, "-tess_id", 0, "search by tess ID", 0);
    105     psMetadataAddStr(resultArgs, PS_LIST_TAIL, "-skycell_id", 0, "search by skycell ID", 0);
     105    // psMetadataAddStr(resultArgs, PS_LIST_TAIL, "-tess_id", 0, "search by tess ID", 0);
     106    // psMetadataAddStr(resultArgs, PS_LIST_TAIL, "-skycell_id", 0, "search by skycell ID", 0);
    106107    psMetadataAddStr(resultArgs, PS_LIST_TAIL, "-label", 0, "search by label", NULL);
    107108    psMetadataAddStr(resultArgs, PS_LIST_TAIL, "-data_group", 0, "search by data_group (LIKE comparison)", NULL);
    … …  
    109110    psMetadataAddU64(resultArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
    110111    psMetadataAddBool(resultArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
     112    psMetadataAddBool(resultArgs, PS_LIST_TAIL, "-all", 0, "allow no search terms", false);
    111113
    112114    // -revert
    … …  
    143145    PXOPT_ADD_MODE("-inputs",        "Get inputs",           STATICSKYTOOL_MODE_INPUTS,        inputsArgs);
    144146    PXOPT_ADD_MODE("-todo",          "Get runs to do",       STATICSKYTOOL_MODE_TODO,          todoArgs);
    145     PXOPT_ADD_MODE("-addresult",     "Add result of run",    STATICSKYTOOL_MODE_ADDRESULT,     addresultsArgs);
     147    PXOPT_ADD_MODE("-addresult",     "Add result of run",    STATICSKYTOOL_MODE_ADDRESULT,     addresultArgs);
    146148    PXOPT_ADD_MODE("-result",        "Get result of run",    STATICSKYTOOL_MODE_RESULT,        resultArgs);
    147149    PXOPT_ADD_MODE("-revert",        "Revert failed run",    STATICSKYTOOL_MODE_REVERT,        revertArgs);

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

    r28043 r28164  
    4848static bool maskedMode(pxConfig *config);
    4949static bool unblockMode(pxConfig *config);
     50static bool tosummaryMode(pxConfig *config);
     51static bool addsummaryMode(pxConfig *config);
    5052static bool pendingcleanuprunMode(pxConfig *config);
    5153static bool pendingcleanupwarpMode(pxConfig *config);
    … …  
    101103        MODECASE(WARPTOOL_MODE_MASKED,             maskedMode);
    102104        MODECASE(WARPTOOL_MODE_UNBLOCK,            unblockMode);
     105        MODECASE(WARPTOOL_MODE_TOSUMMARY,          tosummaryMode);
     106        MODECASE(WARPTOOL_MODE_ADDSUMMARY,         addsummaryMode);
    103107        MODECASE(WARPTOOL_MODE_PENDINGCLEANUPRUN,  pendingcleanuprunMode);
    104108        MODECASE(WARPTOOL_MODE_PENDINGCLEANUPSKYFILE, pendingcleanupwarpMode);
    … …  
    408412    PXOPT_COPY_STR(config->args, where, "-reduction", "warpRun.reduction", "==");
    409413    PXOPT_COPY_STR(config->args, where, "-state",     "warpRun.state",     "==");
    410     PXOPT_COPY_STR(config->args, where, "-data_group","warpRun.data_group","==");
    411     PXOPT_COPY_STR(config->args, where, "-dist_group","warpRun.dist_group","==");
    412     pxAddLabelSearchArgs(config,  where, "-label",    "warpRun.label",     "==");
     414    PXOPT_COPY_STR(config->args, where, "-data_group","warpRun.data_group","LIKE");
     415    PXOPT_COPY_STR(config->args, where, "-dist_group","warpRun.dist_group","LIKE");
     416    pxAddLabelSearchArgs(config,  where, "-label",    "warpRun.label",     "LIKE");
    413417
    414418    PXOPT_COPY_TIME(config->args, where, "-registered_begin", "warpRun.registered",  ">=");
    … …  
    940944
    941945    // treat limit == 0 as "no limit"
    942     psString limitString = psStringCopy("\n");
     946    psString limitString = psStringCopy("\nORDER BY priority DESC, warp_id");
    943947    if (limit) {
    944         // We apply the limit to both sides of the UNION
    945         // to avoid slow queries and to the query itself
    946         // to satisfy the user's requested limit
     948        // We apply the limit to both sides of the UNION to avoid slow queries
     949        // and to the query itself to satisfy the user's requested limit
    947950        psStringAppend(&limitString, "%s", psDBGenerateLimitSQL(limit));
    948951        psStringAppend(&query, " %s", limitString);
    949952    }
    950953
    951 #define TWO_WHERES
    952 #ifdef TWO_WHERES
    953954    if (!p_psDBRunQueryF(config->dbh, query, whereStr, limitString, whereStr,  limitString)) {
    954955        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    956957        return false;
    957958    }
    958 #else
    959     if (!p_psDBRunQueryF(config->dbh, query, whereStr)) {
    960         psError(PS_ERR_UNKNOWN, false, "database error");
    961         psFree(query);
    962         return false;
    963     }
    964 #endif
    965959    psFree(limitString);
    966960    psFree(whereStr);
    … …  
    11631157
    11641158        psString software_ver = NULL;
    1165         psS32 maskfrac_npix = 0;
     1159        psS64 maskfrac_npix = 0;
    11661160        psF32 maskfrac_static = 0;
    11671161        psF32 maskfrac_dynamic = 0;
    … …  
    11811175          return(false);
    11821176        }
    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");
     1177        // Set warpRun.software_ver to the appropriate value    if (
     1178        if (software_ver) {
     1179          if (!pxSetRunSoftware(config, "warpRun", "warp_id", warp_id, software_ver)) {
     1180            psError(PS_ERR_UNKNOWN, false, "failed to set warpRun.software_ver for warp_id: %" PRId64,
     1181                    warp_id);
     1182            psFree(output);
     1183            if (!psDBRollback(config->dbh)) {
     1184              psError(PS_ERR_UNKNOWN, false, "database error");
     1185            }
     1186            return(false);
    11901187          }
    1191           return(false);
    11921188        }
    11931189        // 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");
     1190        if (maskfrac_npix) {
     1191          if (!pxSetRunMaskfrac(config, "warpRun", "warp_id", warp_id, maskfrac_npix, maskfrac_static,
     1192                                maskfrac_dynamic, maskfrac_magic, maskfrac_advisory)) {
     1193            psError(PS_ERR_UNKNOWN, false, "failed to set warpRun.software_ver for warp_id: %" PRId64,
     1194                    warp_id);
     1195            psFree(output);
     1196            if (!psDBRollback(config->dbh)) {
     1197              psError(PS_ERR_UNKNOWN, false, "database error");
     1198            }
     1199            return(false);
    12011200          }
    1202           return(false);
    1203         }       
     1201        }
    12041202
    12051203       
    … …  
    15541552}
    15551553
     1554static bool tosummaryMode(pxConfig *config) {
     1555  PS_ASSERT_PTR_NON_NULL(config, NULL);
     1556 
     1557  psMetadata *where = psMetadataAlloc();
     1558  PXOPT_COPY_S64(config->args, where, "-warp_id",    "warpSkyfile.warp_id", "==");
     1559  PXOPT_COPY_STR(config->args, where, "-tess_id",    "warpSkyfile.tess_id", "==");
     1560  PXOPT_COPY_STR(config->args, where, "-state",      "warpRun.state", "==");
     1561  PXOPT_COPY_S64(config->args, where, "-exp_id",     "rawExp.exp_id", "==");
     1562  PXOPT_COPY_STR(config->args, where, "-exp_name",   "rawExp.exp_name", "==");
     1563  PXOPT_COPY_S64(config->args, where, "-fake_id",    "fakeRun.fake_id", "==");
     1564  PXOPT_COPY_TIME(config->args, where, "-dateobs_begin", "rawExp.dateobs",  ">=");
     1565  PXOPT_COPY_TIME(config->args, where, "-dateobs_end",   "rawExp.dateobs",  "<=");
     1566  PXOPT_COPY_STR(config->args, where, "-filter",    "rawExp.filter", "LIKE");
     1567  PXOPT_COPY_S64(config->args, where, "-magicked", "warpSkyfile.magicked", "==");
     1568  pxAddLabelSearchArgs (config, where, "-label",   "warpRun.label", "LIKE");
     1569  pxAddLabelSearchArgs (config, where, "-data_group",   "warpRun.data_group", "LIKE");
     1570
     1571  PXOPT_LOOKUP_BOOL(all, config->args, "-all", false);
     1572
     1573  PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1574  PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1575 
     1576  // find all rawImfiles matching the default query
     1577  psString query = pxDataGet("warptool_tosummary.sql");
     1578  if (!query) {
     1579    psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1580    return false;
     1581  }
     1582
     1583  // generate where strings for arguments that require extra processing
     1584  // beyond PXOPT_COPY*
     1585  psString where2 = NULL;
     1586  if (!pxmagicAddWhere(config, &where2, "warpSkyfile")) {
     1587    psError(psErrorCodeLast(), false, "pxMagicAddWhere failed");
     1588    return false;
     1589  }
     1590 
     1591  if (psListLength(where->list)) {
     1592    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1593    psStringAppend(&query, " AND %s", whereClause);
     1594    psFree(whereClause);
     1595  } else if (!all && !where2) {
     1596    psError(PXTOOLS_ERR_CONFIG, true, "search parameters or -all are required");
     1597    return false;
     1598  }
     1599 
     1600  if (where2) {
     1601    psStringAppend(&query, " %s", where2);
     1602  }
     1603  psFree(where);
     1604
     1605  // treat limit == 0 as "no limit"
     1606  if (limit) {
     1607    psString limitString = psDBGenerateLimitSQL(limit);
     1608    psStringAppend(&query, " %s", limitString);
     1609    psFree(limitString);
     1610  }
     1611 
     1612  if (!p_psDBRunQuery(config->dbh, query)) {
     1613    psError(PS_ERR_UNKNOWN, false, "database error");
     1614    psFree(query);
     1615    return false;
     1616  }
     1617  psFree(query);
     1618
     1619  psArray *output = p_psDBFetchResult(config->dbh);
     1620  if (!output) {
     1621    psErrorCode err = psErrorCodeLast();
     1622    switch (err) {
     1623    case PS_ERR_DB_CLIENT:
     1624      psError(PXTOOLS_ERR_SYS, false, "database error");
     1625    case PS_ERR_DB_SERVER:
     1626      psError(PXTOOLS_ERR_PROG, false, "database error");
     1627    default:
     1628      psError(PXTOOLS_ERR_PROG, false, "unknown error");
     1629    }
     1630   
     1631    return false;
     1632  }
     1633  if (!psArrayLength(output)) {
     1634    psTrace("warptool", PS_LOG_INFO, "no rows found");
     1635    psFree(output);
     1636    return true;
     1637  }
     1638 
     1639  if (psArrayLength(output)) {
     1640    // negative simple so the default is true
     1641    if (!ippdbPrintMetadatas(stdout, output, "warpRun", !simple)) {
     1642      psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1643      psFree(output);
     1644      return false;
     1645    }
     1646  }
     1647 
     1648  psFree(output);
     1649  return(true);
     1650}
     1651static bool addsummaryMode(pxConfig *config) {
     1652  PS_ASSERT_PTR_NON_NULL(config, NULL);
     1653
     1654  PXOPT_LOOKUP_S64(warp_id, config->args, "-warp_id", true, false);
     1655  PXOPT_LOOKUP_STR(tangent_plane, config->args, "-tangent_plane", true, false);
     1656  PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", true, false);
     1657
     1658  psString query = pxDataGet("warptool_addsummary.sql");
     1659  if (!query) {
     1660    psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1661    return(false);
     1662  }
     1663  if (!p_psDBRunQueryF(config->dbh, query, warp_id, tangent_plane, path_base)) {
     1664    psError(PS_ERR_UNKNOWN, false, "database error");
     1665    psFree(query);
     1666    return(false);
     1667  }
     1668  psS64 numUpdated = psDBAffectedRows(config->dbh);
     1669 
     1670  if (numUpdated != 1) {
     1671    psError(PS_ERR_UNKNOWN, false, "should have affected 1 row");
     1672    psFree(query);
     1673    return false;
     1674  }
     1675 
     1676  psFree(query);
     1677
     1678  // Print anything here?
     1679 
     1680  return(true);
     1681}
     1682
    15561683static bool pendingcleanuprunMode(pxConfig *config)
    15571684{

  • branches/czw_branch/20100519/ippTools/src/warptool.h

    r27737 r28164  
    4444    WARPTOOL_MODE_MASKED,
    4545    WARPTOOL_MODE_UNBLOCK,
     46    WARPTOOL_MODE_TOSUMMARY,
     47    WARPTOOL_MODE_ADDSUMMARY,
    4648    WARPTOOL_MODE_PENDINGCLEANUPRUN,
    4749    WARPTOOL_MODE_PENDINGCLEANUPSKYFILE,

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

    r28043 r28164  
    136136    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-reduction", 0,  "search by warpRun reduction class", NULL);
    137137    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,      "search by warpRun state", NULL);
    138     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by warpRun label", NULL);
    139     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-data_group", 0, "search by warpRun data_group", NULL);
    140     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-dist_group", 0, "search by warpRun dist_group", NULL);
     138    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by warpRun label (LIKE comparison)", NULL);
     139    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-data_group", 0, "search by warpRun data_group (LIKE comparison)", NULL);
     140    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-dist_group", 0, "search by warpRun dist_group (LIKE comparison)", NULL);
    141141    psMetadataAddTime(updaterunArgs, PS_LIST_TAIL, "-registered_begin", 0, "search for runs by registration time (>=)", NULL);
    142142    psMetadataAddTime(updaterunArgs, PS_LIST_TAIL, "-registered_end", 0, "search for runs by registration time (<)", NULL);
    … …  
    321321    psMetadataAddStr(unblockArgs, PS_LIST_TAIL, "-label",  0,            "name of a label to unmask (required)", NULL);
    322322
     323    // -tosummary
     324    psMetadata *tosummaryArgs = psMetadataAlloc();
     325    psMetadataAddS64(tosummaryArgs, PS_LIST_TAIL, "-warp_id", 0,         "search by warp ID", 0);
     326    psMetadataAddStr(tosummaryArgs, PS_LIST_TAIL,  "-tess_id",  0,          "search by tessellation ID", NULL);
     327    psMetadataAddStr(tosummaryArgs, PS_LIST_TAIL, "-state",  0,            "search by state", NULL);
     328    psMetadataAddS64(tosummaryArgs, PS_LIST_TAIL, "-exp_id", 0,            "search by exposure tag", 0);
     329    psMetadataAddStr(tosummaryArgs, PS_LIST_TAIL, "-exp_name", 0,          "search by exposure tag", 0);
     330    psMetadataAddS64(tosummaryArgs, PS_LIST_TAIL, "-fake_id", 0,           "search by phase 3 version of exposure tag", 0);
     331    psMetadataAddTime(tosummaryArgs, PS_LIST_TAIL, "-dateobs_begin", 0,    "search for exposures by time (>=)", NULL);
     332    psMetadataAddTime(tosummaryArgs, PS_LIST_TAIL, "-dateobs_end", 0,      "search for exposures by time (<=)", NULL);
     333    psMetadataAddStr(tosummaryArgs, PS_LIST_TAIL,  "-filter", 0,           "search for exposures by filter", NULL);
     334    psMetadataAddS64(tosummaryArgs, PS_LIST_TAIL,  "-magicked", 0,         "search by magic id", 0);
     335    psMetadataAddStr(tosummaryArgs, PS_LIST_TAIL,  "-label",  PS_META_DUPLICATE_OK, "search by warpRun label", NULL);
     336    psMetadataAddStr(tosummaryArgs, PS_LIST_TAIL,  "-data_group",  PS_META_DUPLICATE_OK, "search by warpRun data_group", NULL);
     337    psMetadataAddStr(tosummaryArgs, PS_LIST_TAIL,  "-dist_group",  PS_META_DUPLICATE_OK, "search by warpRun dist_group", NULL);
     338    psMetadataAddBool(updaterunArgs, PS_LIST_TAIL, "-destreaked", 0, "search for runs that have been destreaked", false);
     339    psMetadataAddBool(updaterunArgs, PS_LIST_TAIL, "-not_destreaked", 0, "search for runs that have not been destreaked", false);
     340   
     341    psMetadataAddBool(tosummaryArgs, PS_LIST_TAIL, "-all",  0,             "search without arguments", false);
     342    psMetadataAddU64(tosummaryArgs, PS_LIST_TAIL,  "-limit",  0,            "limit result set to N items", 0);
     343    psMetadataAddBool(tosummaryArgs, PS_LIST_TAIL, "-simple",  0,          "use the simple output format", false);
     344
     345    // -addsummary
     346    psMetadata *addsummaryArgs = psMetadataAlloc();
     347    psMetadataAddS64(addsummaryArgs, PS_LIST_TAIL, "-warp_id", 0,         "set warp ID", 0);
     348    psMetadataAddStr(addsummaryArgs, PS_LIST_TAIL, "-tangent_plane", 0,   "set tangent plane", NULL);
     349    psMetadataAddStr(addsummaryArgs, PS_LIST_TAIL, "-path_base", 0,       "set summary path base", NULL);
     350   
    323351    // -pendingcleanuprun
    324352    psMetadata *pendingcleanuprunArgs = psMetadataAlloc();
    … …  
    430458    PXOPT_ADD_MODE("-updateskyfile", "update fault code for skyfile", WARPTOOL_MODE_UPDATESKYFILE, updateskyfileArgs);
    431459    PXOPT_ADD_MODE("-setskyfiletoupdate", "set cleaned skyfile to be updated", WARPTOOL_MODE_SETSKYFILETOUPDATE, setskyfiletoupdateArgs);
     460    PXOPT_ADD_MODE("-tosummary",            "show runs that can be summarized", WARPTOOL_MODE_TOSUMMARY, tosummaryArgs);
     461    PXOPT_ADD_MODE("-addsummary",           "add entry to the summary table", WARPTOOL_MODE_ADDSUMMARY, addsummaryArgs);
     462
    432463    PXOPT_ADD_MODE("-exportrun",            "export run for import on other database", WARPTOOL_MODE_EXPORTRUN, exportrunArgs);
    433464    PXOPT_ADD_MODE("-importrun",            "import run from metadata file",           WARPTOOL_MODE_IMPORTRUN, importrunArgs);
Note: See TracChangeset for help on using the changeset viewer.