IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Dec 6, 2012, 6:32:19 PM (14 years ago)
Author:
watersc1
Message:

merge from trunk. Preliminary versions of stacktool/warptool updates and regenerate_background.pl script. The warp code is finished and tested, and I still need to get the stack version resolved.

Location:
branches/czw_branch/20120906/ippTools/src
Files:
14 edited

Legend:

Unmodified
Added
Removed

  • branches/czw_branch/20120906/ippTools/src

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

    r34081 r34772  
    970970    psFree(where);
    971971
     972    int numDeleted = psDBAffectedRows(config->dbh);
    972973    if (!psDBCommit(config->dbh)) {
    973974        psError(PS_ERR_UNKNOWN, false, "database error");
    974975        return false;
    975976    }
     977    psLogMsg("camtool", PS_LOG_INFO, "Deleted %d camProcessedExps", numDeleted);
    976978
    977979    return true;

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

    r34081 r34772  
    20662066    PXOPT_COPY_STR(config->args, where, "-reduction", "chipRun.reduction", "==");
    20672067    PXOPT_COPY_STR(config->args, where, "-state", "chipRun.state", "==");
     2068    PXOPT_COPY_STR(config->args, where, "-tess_id", "chipRun.tess_id", "LIKE");
    20682069    pxAddLabelSearchArgs (config, where, "-label", "chipRun.label", "LIKE");
    20692070    pxAddLabelSearchArgs (config, where, "-data_group", "chipRun.data_group", "LIKE");

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

    r33617 r34772  
    254254    psMetadataAddStr(listrunArgs,  PS_LIST_TAIL, "-label",  PS_META_DUPLICATE_OK, "search by chipRun label (LIKE comparison)", NULL);
    255255    psMetadataAddStr(listrunArgs,  PS_LIST_TAIL, "-state",              0, "search by chipRun state", NULL);
     256    psMetadataAddStr(listrunArgs,  PS_LIST_TAIL, "-tess_id",            0, "search by chipRun tess_id (LIKE comparison)", NULL);
    256257    psMetadataAddStr(listrunArgs,  PS_LIST_TAIL, "-data_group",  PS_META_DUPLICATE_OK, "search by chipRun data_group (LIKE comparison)", NULL);
    257258    psMetadataAddStr(listrunArgs,  PS_LIST_TAIL, "-dist_group",  PS_META_DUPLICATE_OK, "search by chipRun dist_group (LIKE comparison)", NULL);

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

    r34081 r34772  
    9797        MODECASE(DIFFTOOL_MODE_DEFINEWARPWARP,        definewarpwarpMode);
    9898        MODECASE(DIFFTOOL_MODE_DEFINESTACKSTACK,      definestackstackMode);
    99         MODECASE(DIFFTOOL_MODE_TOSUMMARY,             tosummaryMode);
    100         MODECASE(DIFFTOOL_MODE_ADDSUMMARY,            addsummaryMode);
     99        MODECASE(DIFFTOOL_MODE_TOSUMMARY,             tosummaryMode);
     100        MODECASE(DIFFTOOL_MODE_ADDSUMMARY,            addsummaryMode);
    101101        MODECASE(DIFFTOOL_MODE_PENDINGCLEANUPRUN,     pendingcleanuprunMode);
    102102        MODECASE(DIFFTOOL_MODE_PENDINGCLEANUPSKYFILE, pendingcleanupskyfileMode);
    … …  
    170170            exposure,
    171171            false,
    172             NULL, // software version
    173             0,    // mask stat npix
    174             NAN,    // static
    175             NAN,    // dynamic
    176             NAN,    // magic
    177             NAN,    // advisory
     172            NULL, // software version
     173            0,    // mask stat npix
     174            NAN,    // static
     175            NAN,    // dynamic
     176            NAN,    // magic
     177            NAN,    // advisory
    178178            diff_mode,
    179179            note
    … …  
    579579    PXOPT_LOOKUP_F32(maskfrac_magic, config->args, "-maskfrac_magic", false, false);
    580580    PXOPT_LOOKUP_F32(maskfrac_advisory, config->args, "-maskfrac_advisory", false, false);
    581    
     581
    582582    psTrace("czw.test",1,"Received versions: pslib %s psmodules %s psphot %s ppstats %s ppsub %s streaks %s\n",
    583             ver_pslib,ver_psmodules,ver_psphot,ver_ppstats,ver_ppsub,ver_streaks);
     583            ver_pslib,ver_psmodules,ver_psphot,ver_ppstats,ver_ppsub,ver_streaks);
    584584    psString ver_code = NULL;
    585585    if ((ver_pslib)&&(ver_psmodules)) {
    … …  
    631631                           fault,
    632632                           quality,
    633                            magicked,
    634                            ver_code,
    635                            maskfrac_npix,
    636                            maskfrac_static,
    637                            maskfrac_dynamic,
    638                            maskfrac_magic,
    639                            maskfrac_advisory
     633                           magicked,
     634                           ver_code,
     635                           maskfrac_npix,
     636                           maskfrac_static,
     637                           maskfrac_dynamic,
     638                           maskfrac_magic,
     639                           maskfrac_advisory
    640640          )) {
    641641        if (!psDBRollback(config->dbh)) {
    … …  
    726726        psS64 magicked = psMetadataLookupS64(NULL, row, "magicked");
    727727
    728         psString software_ver = NULL;
    729         psS64 maskfrac_npix = 0;
    730         psF32 maskfrac_static = 0;
    731         psF32 maskfrac_dynamic = 0;
    732         psF32 maskfrac_magic = 0;
    733         psF32 maskfrac_advisory = 0;
    734 
    735         // Calculate run level masking and software state
    736         if (!pxCoalesceRunStatus(config,"difftool_coalesce_run.sql",diff_id,
    737                                 &software_ver,&maskfrac_npix,
    738                                 &maskfrac_static,&maskfrac_dynamic,
    739                                 &maskfrac_magic,&maskfrac_advisory)) {
    740           psError(PS_ERR_UNKNOWN, false, "failed to generate run level statistics");
    741           psFree(output);
    742           if (!psDBRollback(config->dbh)) {
    743             psError(PS_ERR_UNKNOWN, false, "database error");
    744           }
    745           return(false);
    746         }
    747         // Set diffRun.software_ver to the appropriate value
    748         if (software_ver) {
    749           if (!pxSetRunSoftware(config, "diffRun", "diff_id", diff_id, software_ver)) {
    750             psError(PS_ERR_UNKNOWN, false, "failed to set diffRun.software_ver for diff_id: %" PRId64,
    751                     diff_id);
    752             psFree(output);
    753             if (!psDBRollback(config->dbh)) {
    754               psError(PS_ERR_UNKNOWN, false, "database error");
    755             }
    756             return(false);
    757           }
    758         }
    759         // Set diffRun.maskfrac* to the appropriate values.
    760         if (maskfrac_npix) {
    761           if (!pxSetRunMaskfrac(config, "diffRun", "diff_id", diff_id, maskfrac_npix, maskfrac_static,
    762                                 maskfrac_dynamic, maskfrac_magic, maskfrac_advisory)) {
    763             psError(PS_ERR_UNKNOWN, false, "failed to set diffRun.software_ver for diff_id: %" PRId64,
    764                     diff_id);
    765             psFree(output);
    766             if (!psDBRollback(config->dbh)) {
    767               psError(PS_ERR_UNKNOWN, false, "database error");
    768             }
    769             return(false);
    770           }
    771         }
     728        psString software_ver = NULL;
     729        psS64 maskfrac_npix = 0;
     730        psF32 maskfrac_static = 0;
     731        psF32 maskfrac_dynamic = 0;
     732        psF32 maskfrac_magic = 0;
     733        psF32 maskfrac_advisory = 0;
     734
     735        // Calculate run level masking and software state
     736        if (!pxCoalesceRunStatus(config,"difftool_coalesce_run.sql",diff_id,
     737                                &software_ver,&maskfrac_npix,
     738                                &maskfrac_static,&maskfrac_dynamic,
     739                                &maskfrac_magic,&maskfrac_advisory)) {
     740          psError(PS_ERR_UNKNOWN, false, "failed to generate run level statistics");
     741          psFree(output);
     742          if (!psDBRollback(config->dbh)) {
     743            psError(PS_ERR_UNKNOWN, false, "database error");
     744          }
     745          return(false);
     746        }
     747        // Set diffRun.software_ver to the appropriate value
     748        if (software_ver) {
     749          if (!pxSetRunSoftware(config, "diffRun", "diff_id", diff_id, software_ver)) {
     750            psError(PS_ERR_UNKNOWN, false, "failed to set diffRun.software_ver for diff_id: %" PRId64,
     751                    diff_id);
     752            psFree(output);
     753            if (!psDBRollback(config->dbh)) {
     754              psError(PS_ERR_UNKNOWN, false, "database error");
     755            }
     756            return(false);
     757          }
     758        }
     759        // Set diffRun.maskfrac* to the appropriate values.
     760        if (maskfrac_npix) {
     761          if (!pxSetRunMaskfrac(config, "diffRun", "diff_id", diff_id, maskfrac_npix, maskfrac_static,
     762                                maskfrac_dynamic, maskfrac_magic, maskfrac_advisory)) {
     763            psError(PS_ERR_UNKNOWN, false, "failed to set diffRun.software_ver for diff_id: %" PRId64,
     764                    diff_id);
     765            psFree(output);
     766            if (!psDBRollback(config->dbh)) {
     767              psError(PS_ERR_UNKNOWN, false, "database error");
     768            }
     769            return(false);
     770          }
     771        }
    772772        // set diffRun.state to 'full'
    773773        if (!setdiffRunState(config, diff_id, "full", magicked)) {
    … …  
    857857        }
    858858    }
    859            
     859
    860860    // treat limit == 0 as "no limit"
    861861    if (limit) {
    … …  
    10921092            false,
    10931093            0,       // magicked
    1094             NULL, // software version
    1095             0,    // mask stat npix
    1096             NAN,    // static
    1097             NAN,    // dynamic
    1098             NAN,    // magic
    1099             NAN,    // advisory
     1094            NULL, // software version
     1095            0,    // mask stat npix
     1096            NAN,    // static
     1097            NAN,    // dynamic
     1098            NAN,    // magic
     1099            NAN,    // advisory
    11001100            diff_mode, // diff_mode
    11011101            note
    … …  
    14751475        }
    14761476
    1477         psString warp_data_group = psMetadataLookupStr(&mdok, row, "data_group");
    1478         if (!mdok) {
    1479           psError(PXTOOLS_ERR_PROG, false, "warp data_group not found");
    1480           psFree(warp2Query);
    1481           psFree(stackQuery);
    1482           psFree(skycell_query);
    1483           if (!psDBRollback(config->dbh)) {
    1484             psError(PS_ERR_UNKNOWN, false, "database error");
    1485           }
    1486           return false;
    1487         }
    1488         if (warp_data_group) {
    1489           data_group = warp_data_group;
    1490         }
    1491        
     1477        psString warp_data_group = psMetadataLookupStr(&mdok, row, "data_group");
     1478        if (!mdok) {
     1479          psError(PXTOOLS_ERR_PROG, false, "warp data_group not found");
     1480          psFree(warp2Query);
     1481          psFree(stackQuery);
     1482          psFree(skycell_query);
     1483          if (!psDBRollback(config->dbh)) {
     1484            psError(PS_ERR_UNKNOWN, false, "database error");
     1485          }
     1486          return false;
     1487        }
     1488        if (!data_group && warp_data_group) {
     1489          data_group = warp_data_group;
     1490        }
     1491
    14921492        if (!p_psDBRunQueryF(config->dbh, skycell_query, stackQuery, warp_id, filter, warp2Query)) {
    14931493            psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    15151515        // ok we've got one create the diffRun
    15161516        diffRunRow *run = diffRunRowAlloc(
    1517                 0,            // ID
    1518                 "reg",        // state
     1517                0,            // ID
     1518                "reg",        // state
    15191519                workdir,
    15201520                label,
    … …  
    15221522                dist_group,
    15231523                reduction,
    1524                 NULL,         // dvodb
     1524                NULL,         // dvodb
    15251525                registered,
    15261526                tess_id,
    15271527                bothways,     // bothways (default is false)
    1528                 true,         // exposure
    1529                 0,            // magicked
    1530                 NULL,         // software version
    1531                 0,            // mask stat npix
    1532                 NAN,          // static
    1533                 NAN,          // dynamic
    1534                 NAN,          // magic
    1535                 NAN,          // advisory
     1528                true,         // exposure
     1529                0,            // magicked
     1530                NULL,         // software version
     1531                0,            // mask stat npix
     1532                NAN,          // static
     1533                NAN,          // dynamic
     1534                NAN,          // magic
     1535                NAN,          // advisory
    15361536                IPP_DIFF_MODE_WARP_STACK,
    15371537                note
    … …  
    15621562        psFree(query);
    15631563        query = NULL;
    1564         psStringAppend(&query, "INSERT INTO diffInputSkyfile SELECT * from skycellsToDiff");
     1564        psStringAppend(&query,
     1565                       "INSERT INTO diffInputSkyfile(diff_id, skycell_id, warp1, stack1, warp2, stack2, tess_id) SELECT diff_id, skycell_id, warp1, stack1, warp2, stack2, tess_id from skycellsToDiff");
    15651566        if (!p_psDBRunQuery(config->dbh, query)) {
    15661567            psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    18681869        const char *template = psMetadataLookupStr(NULL, row, "template_warp_id");
    18691870        const char *tess_id = psMetadataLookupStr(NULL, row, "tess_id");
    1870         psString input_data_group = psMetadataLookupStr(NULL, row, "input_data_group");
    1871         if (!data_group) {
    1872           data_group = input_data_group;
    1873         }
     1871        psString input_data_group = psMetadataLookupStr(NULL, row, "input_data_group");
     1872        if (!data_group) {
     1873          data_group = input_data_group;
     1874        }
    18741875
    18751876        if (!input_id || !template || !tess_id) {
    … …  
    18831884            return false;
    18841885        }
    1885        
     1886
    18861887        diffRunRow *run = diffRunRowAlloc(0,
    18871888                                          "reg",
    … …  
    18971898                                          true,  // exposure
    18981899                                          false, // magicked
    1899                                           NULL, // software version
    1900                                           0,    // mask stat npix
    1901                                           NAN,    // static
    1902                                           NAN,    // dynamic
    1903                                           NAN,    // magic
    1904                                           NAN,    // advisory                                   
     1900                                          NULL, // software version
     1901                                          0,    // mask stat npix
     1902                                          NAN,    // static
     1903                                          NAN,    // dynamic
     1904                                          NAN,    // magic
     1905                                          NAN,    // advisory
    19051906                                          IPP_DIFF_MODE_WARP_WARP,
    19061907                                          note); // Run to insert
    … …  
    19581959            // seem to be a way to pass in NULL for skycell_id, stack1 and stack2
    19591960            psString dummyQuery = NULL;
    1960             psStringAppend(&dummyQuery, 
     1961            psStringAppend(&dummyQuery,
    19611962              "INSERT INTO diffInputSkyfile VALUES(%" PRId64 ", NULL, %s, NULL, %s, NULL, '%s', 0)",
    1962                     run->diff_id, 
     1963                    run->diff_id,
    19631964                    input,                      // warp1
    19641965                    template,                   // warp2
    … …  
    19801981            psFree(dummyQuery);
    19811982            psString finishQuery = NULL;
    1982             psStringAppend( &finishQuery, 
     1983            psStringAppend( &finishQuery,
    19831984                "UPDATE diffRun set state ='full', dist_group = NULL, note = 'dummy run - no overlap' WHERE diff_id = %" PRId64,
    19841985                run->diff_id);
    … …  
    20632064
    20642065    if (!(label)) {
    2065         PXOPT_LOOKUP_STR(label,config->args, "-input_label",true,false);
     2066        PXOPT_LOOKUP_STR(label,config->args, "-input_label",true,false);
    20662067    }
    20672068
    … …  
    20712072
    20722073    if (psListLength(stack1Where->list)) {
    2073         psString whereClause = psDBGenerateWhereConditionSQL(stack1Where, NULL);
    2074         psStringAppend(&stack1Query, "AND %s", whereClause);
    2075         psFree(whereClause);
    2076     } 
     2074        psString whereClause = psDBGenerateWhereConditionSQL(stack1Where, NULL);
     2075        psStringAppend(&stack1Query, "AND %s", whereClause);
     2076        psFree(whereClause);
     2077    }
    20772078    psFree(stack1Where);
    20782079
    20792080    if (psListLength(stack2Where->list)) {
    2080         psString whereClause = psDBGenerateWhereConditionSQL(stack2Where, NULL);
    2081         psStringAppend(&stack2Query, "AND %s", whereClause);
    2082         psFree(whereClause);
    2083     } 
     2081        psString whereClause = psDBGenerateWhereConditionSQL(stack2Where, NULL);
     2082        psStringAppend(&stack2Query, "AND %s", whereClause);
     2083        psFree(whereClause);
     2084    }
    20842085    psFree(stack2Where);
    2085  
     2086
    20862087    // don't queue for stacks that have already been diffed unless requested
    20872088    psString diffQuery0 = NULL;
    20882089    psString diffQuery1 = NULL;
    20892090    if (! (reRun || newTemplates) ) {
    2090         psStringAppend(&diffQuery0, "AND diffExp.diff_id IS NULL");
    2091         psStringAppend(&diffQuery1, "HAVING n_diff = 0");
    2092     } 
     2091        psStringAppend(&diffQuery0, "AND diffExp.diff_id IS NULL");
     2092        psStringAppend(&diffQuery1, "HAVING n_diff = 0");
     2093    }
    20932094
    20942095    // find the distinct set of data_groups and filters
    20952096    psString query = pxDataGet("difftool_definestackstack_part0.sql");
    20962097    if (!query) {
    2097         psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    2098         return(false);
     2098        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     2099        return(false);
    20992100    }
    21002101    psTrace("difftool",1,query,stack2Query,stack1Query,diffQuery0,stack1Query);
    21012102
    21022103    if (!psDBTransaction(config->dbh)) {
    2103         psError(PS_ERR_UNKNOWN, false, "database error");
    2104         return(false);
     2104        psError(PS_ERR_UNKNOWN, false, "database error");
     2105        return(false);
    21052106    }
    21062107
    … …  
    21102111
    21112112    if (!p_psDBRunQuery(config->dbh, query)) {
    2112         psError(PS_ERR_UNKNOWN, false, "database error");
    2113         psFree(query);
    2114         if (!psDBRollback(config->dbh)) {
    2115             psError(PS_ERR_UNKNOWN, false, "database error");
    2116         }
    2117         return false;
     2113        psError(PS_ERR_UNKNOWN, false, "database error");
     2114        psFree(query);
     2115        if (!psDBRollback(config->dbh)) {
     2116            psError(PS_ERR_UNKNOWN, false, "database error");
     2117        }
     2118        return false;
    21182119    }
    21192120
    … …  
    21222123    psArray *output = p_psDBFetchResult(config->dbh);
    21232124    if (!output) {
    2124         psErrorCode err = psErrorCodeLast();
    2125         switch (err) {
    2126           case PS_ERR_DB_CLIENT:
    2127             psError(PXTOOLS_ERR_SYS, false, "database error");
    2128             break;
    2129           case PS_ERR_DB_SERVER:
    2130             psError(PXTOOLS_ERR_PROG, false, "database error");
    2131             break;
    2132           default:
    2133             psError(PXTOOLS_ERR_PROG, false, "unknown error");
    2134             break;
    2135         }
    2136         if (!psDBRollback(config->dbh)) {
    2137             psError(PS_ERR_UNKNOWN, false, "database error");
    2138         }
    2139         return false;
     2125        psErrorCode err = psErrorCodeLast();
     2126        switch (err) {
     2127          case PS_ERR_DB_CLIENT:
     2128            psError(PXTOOLS_ERR_SYS, false, "database error");
     2129            break;
     2130          case PS_ERR_DB_SERVER:
     2131            psError(PXTOOLS_ERR_PROG, false, "database error");
     2132            break;
     2133          default:
     2134            psError(PXTOOLS_ERR_PROG, false, "unknown error");
     2135            break;
     2136        }
     2137        if (!psDBRollback(config->dbh)) {
     2138            psError(PS_ERR_UNKNOWN, false, "database error");
     2139        }
     2140        return false;
    21402141    }
    21412142    if (!psArrayLength(output)) {
    2142         psTrace("difftool", PS_LOG_INFO, "no rows found");
    2143         psFree(output);
    2144         if (!psDBCommit(config->dbh)) {
    2145             psError(PS_ERR_UNKNOWN, false, "database error");
    2146             return false;
    2147         }
    2148         return true;
    2149     }
    2150 
    2151    
     2143        psTrace("difftool", PS_LOG_INFO, "no rows found");
     2144        psFree(output);
     2145        if (!psDBCommit(config->dbh)) {
     2146            psError(PS_ERR_UNKNOWN, false, "database error");
     2147            return false;
     2148        }
     2149        return true;
     2150    }
     2151
     2152
    21522153    if (pretend) {
    2153         // negative simple so the default is true
    2154         if (!ippdbPrintMetadatas(stdout, output, "diffRunTemp", !simple)) {
    2155             psError(PS_ERR_UNKNOWN, false, "failed to print array");
    2156             psFree(output);
    2157             return false;
    2158         }
    2159         psFree(output);
    2160         return true;
     2154        // negative simple so the default is true
     2155        if (!ippdbPrintMetadatas(stdout, output, "diffRunTemp", !simple)) {
     2156            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     2157            psFree(output);
     2158            return false;
     2159        }
     2160        psFree(output);
     2161        return true;
    21612162    }
    21622163
    … …  
    21652166      query = pxDataGet("difftool_definestackstack_part1.sql");
    21662167
    2167    
    2168         psMetadata *row = output->data[i]; // Output row from query
    2169         bool mdok;                      // Status of MD lookup
    2170 
    2171         // psMetadataPrint(stderr, row, 1);
    2172 
    2173         psString tess_id = psMetadataLookupStr(&mdok,row,"INPUT_tess_id");
    2174         psString this_data_group = psMetadataLookupStr(&mdok,row,"INPUT_data_group");
    2175         psString this_dist_group = psMetadataLookupStr(&mdok,row,"INPUT_dist_group");
    2176         psString this_label = psMetadataLookupStr(&mdok,row,"INPUT_label");
    2177 
    2178         psString this_stack1Query = psStringCopy(stack1Query);
    2179 
    2180         psString thisWhere = psDBGenerateWhereConditionSQL(row,NULL);
    2181         psStringSubstitute(&thisWhere,"stackRun.","INPUT_");
    2182         psStringAppend(&this_stack1Query,"AND %s", thisWhere);
    2183         psFree(thisWhere);
    2184 
    2185         psStringSubstitute(&query, this_stack1Query, "@STACK1_QUERY@");
    2186         psStringSubstitute(&query, stack2Query,      "@STACK2_QUERY@");
    2187         psStringSubstitute(&query, diffQuery1,       "@DIFF1_QUERY@");
    2188 
    2189         psTrace("difftool", 1, "%s", query);
    2190         if (!psDBTransaction(config->dbh)) {
    2191             psError(PS_ERR_UNKNOWN, false, "database error");
    2192             return(false);
    2193         }
    2194 
    2195         if (!p_psDBRunQuery(config->dbh, query)) {
    2196             psError(PS_ERR_UNKNOWN, false, "database error");
    2197             psFree(query);
    2198             if (!psDBRollback(config->dbh)) {
    2199                 psError(PS_ERR_UNKNOWN, false, "database error");
    2200             }
    2201             return false;
    2202         }
    2203         psFree(this_stack1Query);
    2204 
    2205         psArray *diff_id_output = p_psDBFetchResult(config->dbh);
    2206         if (!diff_id_output) {
    2207             psErrorCode err = psErrorCodeLast();
    2208             switch (err) {
    2209               case PS_ERR_DB_CLIENT:
    2210                 psError(PXTOOLS_ERR_SYS, false, "database error");
    2211                 break;
    2212               case PS_ERR_DB_SERVER:
    2213                 psError(PXTOOLS_ERR_PROG, false, "database error");
    2214                 break;
    2215               default:
    2216                 psError(PXTOOLS_ERR_PROG, false, "unknown error");
    2217                 break;
    2218             }
    2219             if (!psDBRollback(config->dbh)) {
    2220                 psError(PS_ERR_UNKNOWN, false, "database error");
    2221             }
    2222             return false;
    2223         }
    2224         if (!psArrayLength(diff_id_output)) {
    2225             psTrace("difftool", PS_LOG_INFO, "no rows found");
    2226             psFree(diff_id_output);
    2227             if (!psDBCommit(config->dbh)) {
    2228                 psError(PS_ERR_UNKNOWN, false, "database error");
    2229                 return false;
    2230             }
    2231             return true;
    2232         }
    2233 
    2234         // ok we've got one create the diffRun
    2235         diffRunRow *run = diffRunRowAlloc(
    2236             0,          // ID
    2237             "reg",      // state
    2238             workdir,
    2239             label ? label : this_label,
    2240             data_group ? data_group : this_data_group,
    2241             dist_group ? dist_group : this_dist_group,
    2242             reduction,
    2243             NULL,       // dvodb
    2244             registered,
    2245             tess_id,
    2246             bothways,               // bothways
    2247             false,                 // exposure
    2248             0,       // magicked
    2249             NULL, // software version
    2250             0,    // mask stat npix
    2251             NAN,    // static
    2252             NAN,    // dynamic
    2253             NAN,    // magic
    2254             NAN,    // advisory                             
    2255             IPP_DIFF_MODE_STACK_STACK, // diff_mode
    2256             note
    2257             );
    2258         // Commit to database
    2259         if (!diffRunInsertObject(config->dbh, run)) {
    2260             psError(PS_ERR_UNKNOWN, false, "database error");
    2261             psFree(run);
    2262             if (!psDBRollback(config->dbh)) {
    2263                 psError(PS_ERR_UNKNOWN, false, "database error");
    2264             }
    2265             return false;
    2266         }
    2267         // diffRunPrintObject(stdout,run,1);
    2268         run->diff_id = psDBLastInsertID(config->dbh);
    2269 
    2270         for (long j = 0; j < diff_id_output->n; j++) {
    2271             psMetadata *input_row = diff_id_output->data[j]; // Output row from query
    2272             bool mdok;
    2273             psString in_skycell_id  = psMetadataLookupStr(&mdok,input_row,"skycell_id");
    2274             psS64 in_input_stack_id = psMetadataLookupS64(&mdok,input_row,"stack_id");
    2275             psS64 in_template_stack_id = psMetadataLookupS64(&mdok,input_row,"max_stack_id");
    2276             psString in_tess_id = psMetadataLookupStr(&mdok,input_row,"tess_id");
    2277             psTrace("difftool",1,"%s %" PRId64 " %" PRId64 " %s\n",
    2278                     in_skycell_id, in_input_stack_id, in_template_stack_id, in_tess_id);
    2279             diffInputSkyfileRow *input = diffInputSkyfileRowAlloc(
    2280                 run->diff_id,   // ID
    2281                 in_skycell_id,
    2282                 PS_MAX_S64, // warp1_id -> NULL
    2283                 in_input_stack_id, // stack1
    2284                 PS_MAX_S64, // warp2_id -> NULL
    2285                 in_template_stack_id, // stack2
    2286                 in_tess_id,
    2287                 0 // diff_skyfile_id
    2288                 );
    2289 
    2290             // Commit to database the input
    2291             if (!diffInputSkyfileInsertObject(config->dbh, input)) {
    2292                 psError(PS_ERR_UNKNOWN, false, "database error");
    2293                 psFree(input);
    2294                 if (!psDBRollback(config->dbh)) {
    2295                     psError(PS_ERR_UNKNOWN, false, "database error");
    2296                 }
    2297                 return false;
    2298             }
     2168
     2169        psMetadata *row = output->data[i]; // Output row from query
     2170        bool mdok;                      // Status of MD lookup
     2171
     2172        // psMetadataPrint(stderr, row, 1);
     2173
     2174        psString tess_id = psMetadataLookupStr(&mdok,row,"INPUT_tess_id");
     2175        psString this_data_group = psMetadataLookupStr(&mdok,row,"INPUT_data_group");
     2176        psString this_dist_group = psMetadataLookupStr(&mdok,row,"INPUT_dist_group");
     2177        psString this_label = psMetadataLookupStr(&mdok,row,"INPUT_label");
     2178
     2179        psString this_stack1Query = psStringCopy(stack1Query);
     2180
     2181        psString thisWhere = psDBGenerateWhereConditionSQL(row,NULL);
     2182        psStringSubstitute(&thisWhere,"stackRun.","INPUT_");
     2183        psStringAppend(&this_stack1Query,"AND %s", thisWhere);
     2184        psFree(thisWhere);
     2185
     2186        psStringSubstitute(&query, this_stack1Query, "@STACK1_QUERY@");
     2187        psStringSubstitute(&query, stack2Query,      "@STACK2_QUERY@");
     2188        psStringSubstitute(&query, diffQuery1,       "@DIFF1_QUERY@");
     2189
     2190        psTrace("difftool", 1, "%s", query);
     2191        if (!psDBTransaction(config->dbh)) {
     2192            psError(PS_ERR_UNKNOWN, false, "database error");
     2193            return(false);
     2194        }
     2195
     2196        if (!p_psDBRunQuery(config->dbh, query)) {
     2197            psError(PS_ERR_UNKNOWN, false, "database error");
     2198            psFree(query);
     2199            if (!psDBRollback(config->dbh)) {
     2200                psError(PS_ERR_UNKNOWN, false, "database error");
     2201            }
     2202            return false;
     2203        }
     2204        psFree(this_stack1Query);
     2205
     2206        psArray *diff_id_output = p_psDBFetchResult(config->dbh);
     2207        if (!diff_id_output) {
     2208            psErrorCode err = psErrorCodeLast();
     2209            switch (err) {
     2210              case PS_ERR_DB_CLIENT:
     2211                psError(PXTOOLS_ERR_SYS, false, "database error");
     2212                break;
     2213              case PS_ERR_DB_SERVER:
     2214                psError(PXTOOLS_ERR_PROG, false, "database error");
     2215                break;
     2216              default:
     2217                psError(PXTOOLS_ERR_PROG, false, "unknown error");
     2218                break;
     2219            }
     2220            if (!psDBRollback(config->dbh)) {
     2221                psError(PS_ERR_UNKNOWN, false, "database error");
     2222            }
     2223            return false;
     2224        }
     2225        if (!psArrayLength(diff_id_output)) {
     2226            psTrace("difftool", PS_LOG_INFO, "no rows found");
     2227            psFree(diff_id_output);
     2228            if (!psDBCommit(config->dbh)) {
     2229                psError(PS_ERR_UNKNOWN, false, "database error");
     2230                return false;
     2231            }
     2232            return true;
     2233        }
     2234
     2235        // ok we've got one create the diffRun
     2236        diffRunRow *run = diffRunRowAlloc(
     2237            0,          // ID
     2238            "reg",      // state
     2239            workdir,
     2240            label ? label : this_label,
     2241            data_group ? data_group : this_data_group,
     2242            dist_group ? dist_group : this_dist_group,
     2243            reduction,
     2244            NULL,       // dvodb
     2245            registered,
     2246            tess_id,
     2247            bothways,               // bothways
     2248            false,                 // exposure
     2249            0,       // magicked
     2250            NULL, // software version
     2251            0,    // mask stat npix
     2252            NAN,    // static
     2253            NAN,    // dynamic
     2254            NAN,    // magic
     2255            NAN,    // advisory
     2256            IPP_DIFF_MODE_STACK_STACK, // diff_mode
     2257            note
     2258            );
     2259        // Commit to database
     2260        if (!diffRunInsertObject(config->dbh, run)) {
     2261            psError(PS_ERR_UNKNOWN, false, "database error");
     2262            psFree(run);
     2263            if (!psDBRollback(config->dbh)) {
     2264                psError(PS_ERR_UNKNOWN, false, "database error");
     2265            }
     2266            return false;
     2267        }
     2268        // diffRunPrintObject(stdout,run,1);
     2269        run->diff_id = psDBLastInsertID(config->dbh);
     2270
     2271        for (long j = 0; j < diff_id_output->n; j++) {
     2272            psMetadata *input_row = diff_id_output->data[j]; // Output row from query
     2273            bool mdok;
     2274            psString in_skycell_id  = psMetadataLookupStr(&mdok,input_row,"skycell_id");
     2275            psS64 in_input_stack_id = psMetadataLookupS64(&mdok,input_row,"stack_id");
     2276            psS64 in_template_stack_id = psMetadataLookupS64(&mdok,input_row,"max_stack_id");
     2277            psString in_tess_id = psMetadataLookupStr(&mdok,input_row,"tess_id");
     2278            psTrace("difftool",1,"%s %" PRId64 " %" PRId64 " %s\n",
     2279                    in_skycell_id, in_input_stack_id, in_template_stack_id, in_tess_id);
     2280            diffInputSkyfileRow *input = diffInputSkyfileRowAlloc(
     2281                run->diff_id,   // ID
     2282                in_skycell_id,
     2283                PS_MAX_S64, // warp1_id -> NULL
     2284                in_input_stack_id, // stack1
     2285                PS_MAX_S64, // warp2_id -> NULL
     2286                in_template_stack_id, // stack2
     2287                in_tess_id,
     2288                0 // diff_skyfile_id
     2289                );
     2290
     2291            // Commit to database the input
     2292            if (!diffInputSkyfileInsertObject(config->dbh, input)) {
     2293                psError(PS_ERR_UNKNOWN, false, "database error");
     2294                psFree(input);
     2295                if (!psDBRollback(config->dbh)) {
     2296                    psError(PS_ERR_UNKNOWN, false, "database error");
     2297                }
     2298                return false;
     2299            }
    22992300
    23002301/*       diffInputSkyfilePrintObject(stdout,input,1); */
    2301             psFree(input);
    2302         }
    2303 
    2304         if (!setdiffRunState(config, run->diff_id, "new", false)) {
    2305             psError(PS_ERR_UNKNOWN, false, "failed to change diffRun.state for diff_id: %" PRId64, run->diff_id);
    2306             psFree(stack1Query);
    2307             psFree(stack2Query);
    2308             psFree(diffQuery0);
    2309             psFree(diffQuery1);
    2310             psFree(run);
    2311             psFree(list);
    2312             if (!psDBRollback(config->dbh)) {
    2313                 psError(PS_ERR_UNKNOWN, false, "database error");
    2314             }
    2315             return false;
    2316         }
    2317         psArrayAdd(list, list->n, run);
    2318         psFree(run);
     2302            psFree(input);
     2303        }
     2304
     2305        if (!setdiffRunState(config, run->diff_id, "new", false)) {
     2306            psError(PS_ERR_UNKNOWN, false, "failed to change diffRun.state for diff_id: %" PRId64, run->diff_id);
     2307            psFree(stack1Query);
     2308            psFree(stack2Query);
     2309            psFree(diffQuery0);
     2310            psFree(diffQuery1);
     2311            psFree(run);
     2312            psFree(list);
     2313            if (!psDBRollback(config->dbh)) {
     2314                psError(PS_ERR_UNKNOWN, false, "database error");
     2315            }
     2316            return false;
     2317        }
     2318        psArrayAdd(list, list->n, run);
     2319        psFree(run);
    23192320    }
    23202321
    23212322    if (!psDBCommit(config->dbh)) {
    2322         psError(PS_ERR_UNKNOWN, false, "database error");
    2323         psFree(list);
    2324         return false;
     2323        psError(PS_ERR_UNKNOWN, false, "database error");
     2324        psFree(list);
     2325        return false;
    23252326    }
    23262327
    23272328    if (!diffRunPrintObjects(stdout, list, !simple)) {
    2328         psError(PS_ERR_UNKNOWN, false, "failed to print object");
    2329         psFree(list);
    2330         return false;
     2329        psError(PS_ERR_UNKNOWN, false, "failed to print object");
     2330        psFree(list);
     2331        return false;
    23312332    }
    23322333
    … …  
    23402341
    23412342    if (!psDBCommit(config->dbh)) {
    2342         psError(PS_ERR_UNKNOWN, false, "database error");
    2343         psFree(list);
    2344         return false;
     2343        psError(PS_ERR_UNKNOWN, false, "database error");
     2344        psFree(list);
     2345        return false;
    23452346    }
    23462347
    … …  
    23502351static bool tosummaryMode(pxConfig *config) {
    23512352  PS_ASSERT_PTR_NON_NULL(config, NULL);
    2352  
     2353
    23532354  psMetadata *where = psMetadataAlloc();
    23542355  PXOPT_COPY_S64(config->args, where, "-warp_id",    "diffSkyfile.warp_id", "==");
    … …  
    23662367  PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    23672368  PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    2368  
     2369
    23692370  // find all rawImfiles matching the default query
    23702371  psString query = pxDataGet("difftool_tosummary.sql");
    … …  
    23812382    return false;
    23822383  }
    2383  
     2384
    23842385  if (psListLength(where->list)) {
    23852386    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    … …  
    23902391    return false;
    23912392  }
    2392  
     2393
    23932394  if (where2) {
    23942395    if (psListLength(where->list)) {
    … …  
    24062407    psFree(limitString);
    24072408  }
    2408  
     2409
    24092410  if (!p_psDBRunQuery(config->dbh, query)) {
    24102411    psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    24252426      psError(PXTOOLS_ERR_PROG, false, "unknown error");
    24262427    }
    2427    
     2428
    24282429    return false;
    24292430  }
    … …  
    24332434    return true;
    24342435  }
    2435  
     2436
    24362437  if (psArrayLength(output)) {
    24372438    // negative simple so the default is true
    … …  
    24422443    }
    24432444  }
    2444  
     2445
    24452446  psFree(output);
    24462447  return(true);
    … …  
    24642465  }
    24652466  psS64 numUpdated = psDBAffectedRows(config->dbh);
    2466  
     2467
    24672468  if (numUpdated != 1) {
    24682469    psError(PS_ERR_UNKNOWN, false, "should have affected 1 row");
    … …  
    24702471    return false;
    24712472  }
    2472  
     2473
    24732474  psFree(query);
    24742475
    24752476  // Print anything here?
    2476  
     2477
    24772478  return(true);
    24782479}
    … …  
    25142515        psString limitString = psDBGenerateLimitSQL(limit);
    25152516        psStringAppend(&query, " %s", limitString);
    2516         psStringSubstitute(&query,limitString,"@INNERLIMITS@");
     2517        psStringSubstitute(&query,limitString,"@INNERLIMITS@");
    25172518        psFree(limitString);
    25182519
    … …  
    30283029
    30293030    PXOPT_COPY_S64(config->args, where, "-template_exp_id", "rawTemplate.exp_id", "==");
    3030    
     3031
    30313032    PXOPT_LOOKUP_BOOL(template, config->args, "-template", false);
    30323033    if (!template) {
    … …  
    30833084        }
    30843085    }
    3085            
     3086
    30863087    // treat limit == 0 as "no limit"
    30873088    if (limit) {
    … …  
    31483149    PXOPT_LOOKUP_F64(mjd_obs_begin, config->args, "-mjd_obs_begin", false, false);
    31493150    PXOPT_LOOKUP_F64(mjd_obs_end, config->args, "-mjd_obs_end", false, false);
    3150    
     3151
    31513152    PXOPT_LOOKUP_BOOL(template, config->args, "-template", false);
    31523153
    … …  
    32003201        }
    32013202    }
    3202            
     3203
    32033204    // treat limit == 0 as "no limit"
    32043205    if (limit) {

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

    r32485 r34772  
    351351    psMetadataAddBool(definestackstackArgs, PS_LIST_TAIL, "-rerun", 0, "define new run even if one exists", false);
    352352    psMetadataAddBool(definestackstackArgs, PS_LIST_TAIL, "-available", 0, "define new run even if no stacks available for some skycells", false);
    353     psMetadataAddBool(definestackstackArgs, PS_LIST_TAIL, "-new-templates", 0, "also search for diffs with new template", false);
     353    psMetadataAddBool(definestackstackArgs, PS_LIST_TAIL, "-new-templates", 0, "also search for diffs with new template and same template label", false);
    354354    psMetadataAddBool(definestackstackArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    355355    psMetadataAddBool(definestackstackArgs, PS_LIST_TAIL, "-pretend", 0, "list results but do not queue", false);

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

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

    r34296 r34772  
    3737static bool inputskyfileMode(pxConfig *config);
    3838static bool tosumMode(pxConfig *config);
     39static bool tobkgMode(pxConfig *config);
    3940static bool addsumskyfileMode(pxConfig *config);
    4041static bool sumskyfileMode(pxConfig *config);
    … …  
    7677        MODECASE(STACKTOOL_MODE_INPUTSKYFILE,          inputskyfileMode);
    7778        MODECASE(STACKTOOL_MODE_TOSUM,                 tosumMode);
     79        MODECASE(STACKTOOL_MODE_TOBKG,                 tobkgMode);
    7880        MODECASE(STACKTOOL_MODE_ADDSUMSKYFILE,         addsumskyfileMode);
    7981        MODECASE(STACKTOOL_MODE_SUMSKYFILE,            sumskyfileMode);
    … …  
    748750    PXOPT_COPY_STR(config->args, where, "-state",     "stackRun.state",     "==");
    749751    PXOPT_COPY_S64(config->args, where, "-sass_id",   "stackAssociationMap.sass_id",  "==");
     752    PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
    750753    if (!psListLength(where->list)) {
    751754        psFree(where);
    … …  
    756759    //CZW join against stackAssociationMap
    757760    psString query = psStringCopy("UPDATE stackRun");
     761
     762    if (fault) {
     763        psStringAppend(&query, " JOIN stackSumSkyfile USING(stack_id)");
     764        PXOPT_COPY_S16(config->args, where, "-fault", "stackSumSkyfile.fault", "==");
     765    }
    758766
    759767    // pxUpdateRun gets parameters from config->args and updates
    … …  
    946954        // negative simple so the default is true
    947955        if (!ippdbPrintMetadatas(stdout, output, "stackSumSkyfile", !simple)) {
     956            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     957            psFree(output);
     958            return false;
     959        }
     960    }
     961
     962    psFree(output);
     963
     964    return true;
     965}
     966
     967static bool tobkgMode(pxConfig *config)
     968{
     969    PS_ASSERT_PTR_NON_NULL(config, false);
     970
     971    psMetadata *where = psMetadataAlloc();
     972    PXOPT_COPY_S64(config->args, where, "-stack_id", "stack_id", "==");
     973    pxAddLabelSearchArgs (config, where, "-label", "stackRun.label", "==");
     974
     975    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     976    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     977
     978    psString query = pxDataGet("stacktool_tobkg.sql");
     979    if (!query) {
     980        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     981        return false;
     982    }
     983
     984    psString whereClause = psStringCopy(""); // WHERE conditions to add
     985    if (psListLength(where->list)) {
     986        psString new = psDBGenerateWhereConditionSQL(where, NULL);
     987        psStringAppend(&whereClause, "\nAND %s", new);
     988        psFree(new);
     989    }
     990    psFree(where);
     991
     992    psStringAppend(&query, "\nORDER by priority DESC, stack_id");
     993
     994    // treat limit == 0 as "no limit"
     995    if (limit) {
     996        psString limitString = psDBGenerateLimitSQL(limit);
     997        psStringAppend(&query, " %s", limitString);
     998        psFree(limitString);
     999    }
     1000
     1001    if (!p_psDBRunQueryF(config->dbh, query, whereClause)) {
     1002        psError(PS_ERR_UNKNOWN, false, "database error");
     1003        psFree(query);
     1004        return false;
     1005    }
     1006    psFree(query);
     1007
     1008    psArray *output = p_psDBFetchResult(config->dbh);
     1009    if (!output) {
     1010        psErrorCode err = psErrorCodeLast();
     1011        switch (err) {
     1012            case PS_ERR_DB_CLIENT:
     1013                psError(PXTOOLS_ERR_SYS, false, "database error");
     1014            case PS_ERR_DB_SERVER:
     1015                psError(PXTOOLS_ERR_PROG, false, "database error");
     1016            default:
     1017                psError(PXTOOLS_ERR_PROG, false, "unknown error");
     1018        }
     1019
     1020        return false;
     1021    }
     1022    if (!psArrayLength(output)) {
     1023        psTrace("stacktool", PS_LOG_INFO, "no rows found");
     1024        psFree(output);
     1025        return true;
     1026    }
     1027
     1028    if (psArrayLength(output)) {
     1029        // negative simple so the default is true
     1030        if (!ippdbPrintMetadatas(stdout, output, "stackBkgSkyfile", !simple)) {
    9481031            psError(PS_ERR_UNKNOWN, false, "failed to print array");
    9491032            psFree(output);
    … …  
    10001083    PXOPT_LOOKUP_STR(ver_streaks, config->args, "-ver_streaks", false, false);
    10011084
     1085    PXOPT_LOOKUP_S16(background_model, config->args, "-background_model", false, false);
     1086   
    10021087    psTrace("czw.test",1,"Received versions: pslib %s psmodules %s psphot %s ppstats %s ppstack %s streaks %s\n",
    10031088            ver_pslib,ver_psmodules,ver_psphot,ver_ppstats,ver_ppstack,ver_streaks);
    … …  
    10611146                               fault,
    10621147                               software_ver,
     1148                               background_model,
    10631149                               quality
    10641150          )) {
    … …  
    11091195    PXOPT_COPY_STR(config->args, where, "-skycell_id", "stackRun.skycell_id", "==");
    11101196    PXOPT_COPY_STR(config->args, where, "-filter", "stackRun.filter", "LIKE");
     1197    PXOPT_COPY_STR(config->args, where, "-state", "stackRun.state", "==");
    11111198    pxAddLabelSearchArgs(config, where, "-label", "stackRun.label", "LIKE");
    11121199    pxAddLabelSearchArgs(config, where, "-data_group", "stackRun.data_group", "LIKE");
    … …  
    11141201    PXOPT_COPY_F64(config->args, where, "-mjd_obs_begin", "stackSumSkyfile.mjd_obs", ">=");
    11151202    PXOPT_COPY_F64(config->args, where, "-mjd_obs_end", "stackSumSkyfile.mjd_obs", "<=");
    1116 
     1203    PXOPT_COPY_S16(config->args, where, "-background_model","stackSumSkyfile.background_model", "==");
    11171204
    11181205//  The following three selectors are incompatible with the sql so omit them
    … …  
    16711758    PXOPT_LOOKUP_S16(fault, config->args, "-fault", true, false);
    16721759    PXOPT_LOOKUP_S16(quality, config->args, "-set_quality", false, false);
     1760    PXOPT_LOOKUP_S16(background_model, config->args, "-set_background_model", false, false);
    16731761
    16741762    psMetadata *where = psMetadataAlloc();
    16751763    PXOPT_COPY_S64(config->args, where, "-stack_id",   "stack_id",   "==");
    16761764
    1677     if (!pxSetFaultCode(config->dbh, "stackSumSkyfile", where, fault, quality)) {
     1765    if (background_model) {
     1766      psMetadata *values = psMetadataAlloc();
     1767      PXOPT_COPY_S16(config->args, values, "-set_background_model", "background_model", "==");
     1768      long rows = psDBUpdateRows(config->dbh,"warpSkyfile", where, values);
     1769      psFree(values);
     1770      if (!rows) {
     1771        // This maybe should rollback and error if rows != 1
     1772        psError(PS_ERR_UNKNOWN, true, "no rows changed");
     1773        return false;
     1774      }
     1775    }
     1776    else {   
     1777      if (!pxSetFaultCode(config->dbh, "stackSumSkyfile", where, fault, quality)) {
    16781778        psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag");
    16791779        psFree (where);
    16801780        return false;
     1781      }
    16811782    }
    16821783    psFree (where);

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

    r28375 r34772  
    3131    STACKTOOL_MODE_INPUTSKYFILE,
    3232    STACKTOOL_MODE_TOSUM,
     33    STACKTOOL_MODE_TOBKG,
    3334    STACKTOOL_MODE_ADDSUMSKYFILE,
    3435    STACKTOOL_MODE_SUMSKYFILE,

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

    r34296 r34772  
    121121    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,            "search by state", NULL);
    122122    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label", 0,            "search by label", 0);
    123     psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-sass_id", 0,           "search by stack association ID", 0);
     123    psMetadataAddS16(updaterunArgs, PS_LIST_TAIL, "-fault",  0,           "search by fault code", 0);
     124    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-sass_id", 0,          "search by stack association ID", 0);
    124125    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_label", 0,        "define new value for label", 0);
    125126    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_state", 0,        "define new state", NULL);
    … …  
    149150    psMetadataAddBool(tosumArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    150151
     152    // -tobkg
     153    psMetadata *tobkgArgs = psMetadataAlloc();
     154    psMetadataAddS64(tobkgArgs, PS_LIST_TAIL, "-stack_id", 0,            "search by stack ID", 0);
     155    psMetadataAddStr(tobkgArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by label", NULL);
     156    psMetadataAddU64(tobkgArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     157    psMetadataAddBool(tobkgArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     158   
    151159    // -addsumskyfile
    152160    psMetadata *addsumskyfileArgs = psMetadataAlloc();
    … …  
    189197    psMetadataAddStr(addsumskyfileArgs, PS_LIST_TAIL, "-ver_streaks", 0, "define streaksremove version", NULL);
    190198
     199    psMetadataAddS16(addsumskyfileArgs, PS_LIST_TAIL, "-background_model", 0, "define background model version", 0);
     200   
    191201    // -sumskyfile
    192202    psMetadata *sumskyfileArgs= psMetadataAlloc();
    … …  
    200210    psMetadataAddStr(sumskyfileArgs, PS_LIST_TAIL, "-exp_name", 0,          "search by exposure name", NULL);
    201211#endif
     212    psMetadataAddS16(sumskyfileArgs, PS_LIST_TAIL, "-background_model", 0, "search by background model version", 0);
    202213    psMetadataAddStr(sumskyfileArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK,             "search by stackRun.label", NULL);
    203214    psMetadataAddStr(sumskyfileArgs, PS_LIST_TAIL, "-data_group", PS_META_DUPLICATE_OK,        "search by stackRun.data_group (LIKE comparison)", NULL);
    … …  
    205216    psMetadataAddF64(sumskyfileArgs, PS_LIST_TAIL, "-mjd_obs_begin",  0,      "search by mjd_obs (average mjd_obs of inputs <=)", NAN);
    206217    psMetadataAddF64(sumskyfileArgs, PS_LIST_TAIL, "-mjd_obs_end",  0,      "search by mjd_obs (average mjd_obs of inputs>=)", NAN);
     218    psMetadataAddStr(sumskyfileArgs, PS_LIST_TAIL, "-state", 0,             "search by state", NULL);
    207219    psMetadataAddS16(sumskyfileArgs, PS_LIST_TAIL, "-fault",  0,            "search by fault code", 0);
    208220    psMetadataAddU64(sumskyfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    … …  
    275287    psMetadataAddS16(updatesumskyfileArgs, PS_LIST_TAIL, "-fault", 0,            "set fault code (required)", 0);
    276288    psMetadataAddS16(updatesumskyfileArgs, PS_LIST_TAIL, "-set_quality", 0,            "set quality", 0);
    277 
     289    psMetadataAddS16(updatesumskyfileArgs, PS_LIST_TAIL, "-set_background_model", 0,   "set background model", 0);
     290   
    278291    // -exportrun
    279292    psMetadata *exportrunArgs = psMetadataAlloc();
    … …  
    299312    PXOPT_ADD_MODE("-inputskyfile",    "", STACKTOOL_MODE_INPUTSKYFILE,    inputskyfileArgs);
    300313    PXOPT_ADD_MODE("-tosum",           "", STACKTOOL_MODE_TOSUM,          tosumArgs);
     314    PXOPT_ADD_MODE("-tobkg",           "", STACKTOOL_MODE_TOBKG,          tobkgArgs);
    301315    PXOPT_ADD_MODE("-addsumskyfile",   "", STACKTOOL_MODE_ADDSUMSKYFILE,   addsumskyfileArgs);
    302316    PXOPT_ADD_MODE("-sumskyfile",      "list results of stackRun", STACKTOOL_MODE_SUMSKYFILE,      sumskyfileArgs);

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

    r34286 r34772  
    132132    pxAddLabelSearchArgs(config, whereMD, "-select_data_group",    "stackRun.data_group",       "LIKE");
    133133    pxAddLabelSearchArgs(config, whereMD, "-select_filter",        "stackRun.filter",           "LIKE");
     134#ifdef notdef
    134135    PXOPT_COPY_F32(config->args, whereMD, "-select_glat_min",      "skycell.glat",              ">=");
    135136    PXOPT_COPY_F32(config->args, whereMD, "-select_glat_max",      "skycell.glat",              "<=");
     137    PXOPT_COPY_F32(config->args, whereMD, "-select_rahours_min",   "skycell.radeg/15",          ">=");
     138    PXOPT_COPY_F32(config->args, whereMD, "-select_rahours_max",   "skycell.radeg/15",          "<=");
     139    PXOPT_COPY_F32(config->args, whereMD, "-select_radeg_min",     "skycell.radeg",             ">=");
     140    PXOPT_COPY_F32(config->args, whereMD, "-select_radeg_max",     "skycell.radeg",             "<=");
     141    PXOPT_COPY_F32(config->args, whereMD, "-select_decdeg_min",    "skycell.decdeg",             ">=");
     142    PXOPT_COPY_F32(config->args, whereMD, "-select_decdeg_max",    "skycell.decdeg",             "<=");
     143#endif
     144    if (!pxskycellAddWhere(config, whereMD)) {
     145        psError(PXTOOLS_ERR_CONFIG, false, "failed to add skycell search arguments");
     146        return false;
     147    }
    136148
    137149    // find the number of requested filters:
    … …  
    12631275
    12641276    PXOPT_LOOKUP_STR(hostname, config->args,    "-hostname", false, false);
    1265 //    PXOPT_LOOKUP_S32(n_stars, config->args,     "-n_stars", false, false);
    12661277    PXOPT_LOOKUP_S32(n_astrom, config->args,    "-n_astrom", false, false);
     1278    PXOPT_LOOKUP_S32(n_detections, config->args,    "-n_detections", false, false);
     1279    PXOPT_LOOKUP_S32(n_extended, config->args,    "-n_extended", false, false);
    12671280
    12681281    PXOPT_LOOKUP_STR(path_base, config->args,   "-path_base", false, false);
    … …  
    13031316        sigma_dec,
    13041317        n_astrom,
     1318        n_detections,
     1319        n_extended,
    13051320        zpt_obs,
    13061321        zpt_stdev,

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

    r34168 r34772  
    5555    psMetadataAddStr(definebyqueryArgs,  PS_LIST_TAIL, "-select_data_group", PS_META_DUPLICATE_OK, "search by stackRun data_group (LIKE comparison, multiple OK)", NULL);
    5656    psMetadataAddStr(definebyqueryArgs,  PS_LIST_TAIL, "-select_filter", PS_META_DUPLICATE_OK, "search by filter (LIKE comparison, multiple OK)", NULL);
     57    pxskycellAddArguments(definebyqueryArgs);
     58#ifdef notdef
    5759    psMetadataAddF32(definebyqueryArgs,  PS_LIST_TAIL, "-select_glat_min", 0, "define min galactic latitude", NAN);
    5860    psMetadataAddF32(definebyqueryArgs,  PS_LIST_TAIL, "-select_glat_max", 0, "define max galactic latitude", NAN);
     61    psMetadataAddF32(definebyqueryArgs,  PS_LIST_TAIL, "-select_rahours_min", 0, "define min RA in hours", NAN);
     62    psMetadataAddF32(definebyqueryArgs,  PS_LIST_TAIL, "-select_rahours_max", 0, "define max RA in hours", NAN);
     63    psMetadataAddF32(definebyqueryArgs,  PS_LIST_TAIL, "-select_radeg_min", 0, "define min RA in degrees", NAN);
     64    psMetadataAddF32(definebyqueryArgs,  PS_LIST_TAIL, "-select_radeg_max", 0, "define max RA in degrees", NAN);
     65    psMetadataAddF32(definebyqueryArgs,  PS_LIST_TAIL, "-select_decdeg_min", 0, "define min DEC in degrees", NAN);
     66    psMetadataAddF32(definebyqueryArgs,  PS_LIST_TAIL, "-select_decdeg_max", 0, "define max DEC in degrees", NAN);
     67#endif
    5968    psMetadataAddStr(definebyqueryArgs,  PS_LIST_TAIL, "-set_workdir", 0, "define workdir (required)", NULL);
    6069    psMetadataAddStr(definebyqueryArgs,  PS_LIST_TAIL, "-set_label", 0, "define label (required)", NULL);
    … …  
    204213    // psMetadataAddS32(addskycalresultArgs, PS_LIST_TAIL, "-n_stars", 0,            "define number of stars", 0);
    205214    psMetadataAddS32(addskycalresultArgs, PS_LIST_TAIL, "-n_astrom", 0,            "define number of astrometry reference objects", 0);
     215    psMetadataAddS32(addskycalresultArgs, PS_LIST_TAIL, "-n_detections", 0,        "define number of detections", 0);
     216    psMetadataAddS32(addskycalresultArgs, PS_LIST_TAIL, "-n_extended", 0,          "define number of extended detections", 0);
    206217
    207218    psMetadataAddStr(addskycalresultArgs, PS_LIST_TAIL, "-path_base", 0,            "define base output location", NULL);

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

    r34081 r34772  
    11011101    PXOPT_LOOKUP_F32(maskfrac_advisory, config->args, "-maskfrac_advisory", false, false);
    11021102
     1103    PXOPT_LOOKUP_S16(background_model, config->args, "-background_model", false, false);
     1104   
    11031105    psTrace("czw.test",1,"Received versions: pslib %s psmodules %s psphot %s ppstats %s pswarp %s streaks %s\n",
    11041106            ver_pslib,ver_psmodules,ver_psphot,ver_ppstats,ver_pswarp,ver_streaks);
    … …  
    11591161                           maskfrac_dynamic,
    11601162                           maskfrac_magic,
    1161                            maskfrac_advisory
     1163                           maskfrac_advisory,
     1164                           background_model
    11621165        )) {
    11631166        if (!psDBRollback(config->dbh)) {
    … …  
    13921395    PXOPT_COPY_STR(config->args, where, "-filter",    "rawExp.filter", "LIKE");
    13931396    PXOPT_COPY_S64(config->args, where, "-magicked", "warpSkyfile.magicked", "==");
     1397    PXOPT_COPY_S16(config->args, where, "-background_model", "warpSkyfile.background_model", "==");
    13941398    pxAddLabelSearchArgs (config, where, "-label",   "warpRun.label", "LIKE");
    13951399    pxAddLabelSearchArgs (config, where, "-data_group",   "warpRun.data_group", "LIKE");
    … …  
    20532057        PXOPT_LOOKUP_S64(magicked, config->args, "-set_magicked", false, false);
    20542058        PXOPT_LOOKUP_S16(quality, config->args, "-set_quality", false, false);
     2059
    20552060        if (magicked) {
    20562061            psStringAppend(&set_magicked_skyfile, "\n , warpSkyfile.magicked = %" PRId64, magicked);
    … …  
    20592064        if (quality) {
    20602065          psStringAppend(&set_magicked_skyfile, "\n , warpSkyfile.quality = %"PRId16, quality);
     2066        }
     2067        PXOPT_LOOKUP_S16(background_model, config->args, "-set_background_model", false, false);
     2068        if (background_model) {
     2069          psStringAppend(&set_magicked_skyfile, "\n , warpSkyfile.background_model = %"PRId16, background_model);
    20612070        }
    20622071    } else if (!strcmp(data_state, "cleaned") || !strcmp(data_state, "purged")) {
    … …  
    21192128    // warp_id, skycell_id, fault are required
    21202129    PXOPT_LOOKUP_STR(state, config->args, "-set_state", false, false);
    2121 
    2122     if (!state) {
     2130    PXOPT_LOOKUP_S16(background_model, config->args, "-set_background_model", false, false);
     2131    if (background_model) {
     2132      // CZW 2012-12-06: I'm unclear why we don't use this form for all updates?
     2133      psMetadata *where = psMetadataAlloc();
     2134      psMetadata *values = psMetadataAlloc();
     2135      PXOPT_COPY_S64(config->args, where, "-warp_id", "warp_id", "==");
     2136      PXOPT_COPY_STR(config->args, where, "-skycell_id", "skycell_id", "==");
     2137      PXOPT_COPY_S16(config->args, values, "-set_background_model", "background_model", "==");
     2138      long rows = psDBUpdateRows(config->dbh,"warpSkyfile", where, values);
     2139      psFree(values);
     2140      psFree(where);
     2141      if (!rows) {
     2142        // This maybe should rollback and error if rows != 1
     2143        psError(PS_ERR_UNKNOWN, true, "no rows changed");
     2144        return false;
     2145      }
     2146    }
     2147    else if (!state) {
    21232148      psMetadata *where = psMetadataAlloc();
    21242149      PXOPT_COPY_S64(config->args, where, "-warp_id", "warp_id", "==");

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

    r32469 r34772  
    237237    psMetadataAddF32(addwarpedArgs, PS_LIST_TAIL, "-maskfrac_advisory", 0, "define advisory mask fraction", NAN);
    238238
     239    psMetadataAddS16(addwarpedArgs, PS_LIST_TAIL, "-background_model", 0, "define background model version", 0);
    239240   
    240241    // -warped
    … …  
    254255    psMetadataAddStr(warpedArgs, PS_LIST_TAIL,  "-data_group",  PS_META_DUPLICATE_OK, "search by warpRun data_group", NULL);
    255256    psMetadataAddStr(warpedArgs, PS_LIST_TAIL,  "-dist_group",  PS_META_DUPLICATE_OK, "search by warpRun dist_group", NULL);
     257    psMetadataAddS16(warpedArgs, PS_LIST_TAIL,  "-background_model", 0, "search by background model version", 0);
    256258    // add magic related arguments
    257259    pxmagicAddArguments(warpedArgs);
    … …  
    407409    psMetadataAddS16(updateskyfileArgs, PS_LIST_TAIL, "-set_quality",  0,"new quality value", 0);
    408410    psMetadataAddStr(updateskyfileArgs, PS_LIST_TAIL, "-set_state", 0,   "set state", 0);
    409 
     411    psMetadataAddS16(updateskyfileArgs, PS_LIST_TAIL, "-set_background_model", 0, "set the background_model value", 0);
    410412    // -exportrun
    411413    psMetadata *exportrunArgs = psMetadataAlloc();
Note: See TracChangeset for help on using the changeset viewer.