IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Mar 5, 2013, 2:24:05 PM (13 years ago)
Author:
eugene
Message:

merge changes from trunk

Location:
branches/eam_branches/ipp-20130207
Files:
17 edited

Legend:

Unmodified
Added
Removed

  • branches/eam_branches/ipp-20130207

  • branches/eam_branches/ipp-20130207/ippTools/src

  • branches/eam_branches/ipp-20130207/ippTools/src/addtool.c

    r34265 r35236  
    988988    if (strcmp (stage,"cam") == 0) {
    989989      query = pxDataGet("addtool_find_processedexp_cam.sql");
    990     }
    991     if (strcmp (stage,"stack") == 0) {
     990    } else if (strcmp (stage,"stack") == 0) {
    992991      query = pxDataGet("addtool_find_processedexp_stack.sql");
    993     }
    994     if (strcmp (stage,"staticsky") == 0) {
     992    } else if (strcmp (stage,"staticsky") == 0) {
    995993      query = pxDataGet("addtool_find_processedexp_staticsky_multi.sql");
    996     }
    997     if (strcmp (stage,"skycal") == 0) {
     994    } else if (strcmp (stage,"skycal") == 0) {
    998995      query = pxDataGet("addtool_find_processedexp_skycal.sql");
     996    } else {
     997        psFree(where);
     998        psError(PXTOOLS_ERR_CONFIG, false, "can't find sql file for stage %s", stage);
     999        return false;
    9991000    }
    10001001

  • branches/eam_branches/ipp-20130207/ippTools/src/addtoolConfig.c

    r34265 r35236  
    125125    psMetadataAddS64(processedexpArgs, PS_LIST_TAIL, "-add_id",   0,            "search by add_id", 0);
    126126    psMetadataAddS64(processedexpArgs, PS_LIST_TAIL, "-stage_id",   0,            "search by stage_id", 0);
    127     psMetadataAddStr(processedexpArgs, PS_LIST_TAIL, "-stage",             0, "set the stage", NULL);
     127    psMetadataAddStr(processedexpArgs, PS_LIST_TAIL, "-stage",             0, "set the stage", "cam");
    128128    pxcamSetSearchArgs(processedexpArgs);
    129129    psMetadataAddStr(processedexpArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by addRun label", NULL);

  • branches/eam_branches/ipp-20130207/ippTools/src/bgtool.c

    r35121 r35236  
    285285    psMetadata *where = psMetadataAlloc();
    286286    PXOPT_COPY_S64(config->args,   where, "-chip_id",            "chipRun.chip_id",       "==");
     287    PXOPT_COPY_S64(config->args,   where, "-cam_id",             "camRun.cam_id",         "==");
    287288    PXOPT_COPY_S64(config->args,   where, "-exp_id",             "rawExp.exp_id",         "==");
    288289    PXOPT_COPY_STR(config->args,   where, "-exp_name",           "rawExp.exp_name",       "==");
    … …  
    324325    PXOPT_COPY_F32(config->args,   where, "-sun_angle_min",      "rawExp.sun_angle",      ">=");
    325326    PXOPT_COPY_F32(config->args,   where, "-sun_angle_max",      "rawExp.sun_angle",      "<");
    326     pxAddLabelSearchArgs(config,   where, "-label",              "chipRun.label",         "==");
     327    PXOPT_COPY_STR(config->args,   where, "-label",              "chipRun.label",         "==");
     328    PXOPT_COPY_STR(config->args,   where, "-cam_label",          "camRun.label",          "==");
    327329
    328330    if (!psListLength(where->list)) {
    … …  
    343345    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    344346    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
     347    PXOPT_LOOKUP_STR(cam_label, config->args, "-cam_label", false, false);
     348    PXOPT_LOOKUP_S64(cam_id, config->args, "-cam_id", false, false);
     349    if (!cam_id && !cam_label) {
     350        psError(PXTOOLS_ERR_CONFIG, true, "either cam_id or cam_label is required");
     351        return false;
     352    }
    345353
    346354    // Get chip runs to promote to chipBackgroundRun
    … …  
    364372    }
    365373
     374    psString labelHook = psStringCopy("");
    366375    if (!rerun) {
    367         psStringAppend(&query, "\nAND chipBackgroundRun.chip_bg_id IS NULL");
    368376        if (label) {
    369             psStringAppend(&query,
    370                            "\nAND (chipBackgroundRun.label = '%s'"
    371                            " OR chipBackgroundRun.label IS NULL)",
    372                            label);
    373         }
    374         if (data_group) {
    375             psStringAppend(&query,
    376                            "\nAND (chipBackgroundRun.data_group = '%s'"
    377                            " OR chipBackgroundRun.data_group IS NULL)",
    378                            data_group);
    379         }
    380         if (dist_group) {
    381             psStringAppend(&query,
    382                            "\nAND (chipBackgroundRun.dist_group = '%s'"
    383                            " OR chipBackgroundRun.dist_group IS NULL)",
    384                            dist_group);
    385         }
     377            // check for run with the newly specified label
     378            psStringAppend(&labelHook, "\nAND (chipBackgroundRun.label = '%s')", label);
     379        }
     380        psStringAppend(&query, "\nAND chip_bg_id IS NULL");
    386381    }
    387382
    … …  
    391386    }
    392387
    393     if (!p_psDBRunQuery(config->dbh, query)) {
     388    if (!p_psDBRunQueryF(config->dbh, query, labelHook)) {
    394389        psError(psErrorCodeLast(), false, "database error");
    395390        psFree(query);
     391        psFree(labelHook);
    396392        if (!psDBRollback(config->dbh)) {
    397393            psError(psErrorCodeLast(), false, "database error");
    … …  
    400396    }
    401397    psFree(query);
     398    psFree(labelHook);
    402399
    403400    psArray *output = p_psDBFetchResult(config->dbh); // Matching rows
    … …  
    420417    if (pretend) {
    421418        // negative simple so the default is true
    422         if (!ippdbPrintMetadatas(stdout, output, "chipRun", !simple)) {
     419        if (!ippdbPrintMetadatas(stdout, output, "chipBackgroundRun", !simple)) {
    423420            psError(psErrorCodeLast(), false, "failed to print array");
    424421            psFree(output);
    … …  
    435432        psMetadata *md = output->data[i];
    436433
    437         chipRunRow *row = chipRunObjectFromMetadata(md);
     434        chipBackgroundRunRow *row = chipBackgroundRunObjectFromMetadata(md);
    438435        if (!row) {
    439436            psError(psErrorCodeLast(), false, "failed to convert metadata into fakeRun");
    … …  
    445442        }
    446443
    447         if (!chipBackgroundRunInsert(config->dbh, 0, row->chip_id, "new",
     444        if (!chipBackgroundRunInsert(config->dbh, 0, row->chip_id, row->cam_id, "new",
    448445                                     workdir     ? workdir    : row->workdir,
    449446                                     label       ? label      : row->label,
    … …  
    560557
    561558    if (psArrayLength(output)) {
    562         if (!ippdbPrintMetadatas(stdout, output, "chipBackgroundRun", !simple)) {
     559        if (!ippdbPrintMetadatas(stdout, output, "pendingchipBackgroundRun", !simple)) {
    563560            psError(psErrorCodeLast(), false, "failed to print array");
    564561            psFree(output);
    … …  
    621618        return true;
    622619    }
    623     if (!ippdbPrintMetadatas(stdout, output, "chipBackgroundImfile", !simple)) {
     620    if (!ippdbPrintMetadatas(stdout, output, "pendingchipBackgroundImfile", !simple)) {
    624621        psError(psErrorCodeLast(), false, "failed to print array");
    625622        psFree(output);
    … …  
    12951292    PXOPT_COPY_F32(config->args,   where, "-sun_angle_max",      "rawExp.sun_angle",      "<");
    12961293    pxAddLabelSearchArgs(config,   where, "-warp_label",         "warpRun.label",         "==");
    1297     pxAddLabelSearchArgs(config,   where, "-chip_label",         "chipBackgroundRun.label", "==");
     1294    pxAddLabelSearchArgs(config,   where, "-chip_bg_label",      "chipBackgroundRun.label", "==");
     1295    pxAddLabelSearchArgs(config,   where, "-chip_label",         "chipRun.label",         "==");
    12981296
    12991297    if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
    … …  
    13351333    }
    13361334
     1335    psString labelHook = psStringCopy("");
    13371336    if (!rerun) {
    1338         psStringAppend(&query, "\nAND warpBackgroundRun.warp_bg_id IS NULL");
    13391337        if (label) {
    1340             psStringAppend(&query,
    1341                            "\nAND (warpBackgroundRun.label = '%s'"
    1342                            " OR warpBackgroundRun.label IS NULL)",
    1343                            label);
    1344         }
    1345         if (data_group) {
    1346             psStringAppend(&query,
    1347                            "\nAND (warpBackgroundRun.data_group = '%s'"
    1348                            " OR warpBackgroundRun.data_group IS NULL)",
    1349                            data_group);
    1350         }
    1351         if (dist_group) {
    1352             psStringAppend(&query,
    1353                            "\nAND (warpBackgroundRun.dist_group = '%s'"
    1354                            " OR warpBackgroundRun.dist_group IS NULL)",
    1355                            dist_group);
    1356         }
     1338            // check for run with the newly specified label
     1339            psStringAppend(&labelHook, "\nAND (warpBackgroundRun.label = '%s')", label);
     1340        }
     1341        psStringAppend(&query, "\nAND warp_bg_id IS NULL");
    13571342    }
    13581343
    … …  
    13621347    }
    13631348
    1364     if (!p_psDBRunQuery(config->dbh, query)) {
    1365         psError(psErrorCodeLast(), false, "database error");
     1349    if (!p_psDBRunQueryF(config->dbh, query, labelHook)) {
     1350        psError(psErrorCodeLast(), false, "database error");
     1351        psFree(labelHook);
    13661352        psFree(query);
    13671353        if (!psDBRollback(config->dbh)) {
    … …  
    13701356        return false;
    13711357    }
     1358    psFree(labelHook);
    13721359    psFree(query);
    13731360
    … …  
    13911378    if (pretend) {
    13921379        // negative simple so the default is true
    1393         if (!ippdbPrintMetadatas(stdout, output, "warpRun", !simple)) {
     1380        if (!ippdbPrintMetadatas(stdout, output, "warpBackgroundRun", !simple)) {
    13941381            psError(psErrorCodeLast(), false, "failed to print array");
    13951382            psFree(output);
    … …  
    14081395        psS64 chip_bg_id = psMetadataLookupS64(NULL, md, "chip_bg_id");
    14091396
    1410         warpRunRow *row = warpRunObjectFromMetadata(md);
     1397       
     1398        warpBackgroundRunRow *row = warpBackgroundRunObjectFromMetadata(md);
    14111399        if (!row) {
    1412             psError(psErrorCodeLast(), false, "failed to convert metadata into fakeRun");
     1400            psError(psErrorCodeLast(), false, "failed to convert metadata into warpRun");
    14131401            psFree(output);
    14141402            if (!psDBRollback(config->dbh)) {
    … …  
    16651653
    16661654    psMetadata *where = psMetadataAlloc();
    1667     PXOPT_COPY_S64(config->args, where, "-warp_bg_id",    "warpBackgroundRun.warp_bg_id", "==");
    1668     PXOPT_COPY_STR(config->args, where, "-skycell_id", "warpBackgroundSkyfile.skycell_id", "==");
    1669     pxAddLabelSearchArgs(config, where, "-label",   "warpBackgroundRun.label", "LIKE");
     1655    PXOPT_COPY_S64(config->args, where, "-warp_bg_id",   "warpBackgroundRun.warp_bg_id", "==");
     1656    PXOPT_COPY_S64(config->args, where, "-warp_id",      "warpBackgroundRun.warp_id", "==");
     1657    PXOPT_COPY_S64(config->args, where, "-chip_bg_id",   "warpBackgroundRun.chip_bg_id", "==");
     1658    PXOPT_COPY_STR(config->args, where, "-skycell_id",   "warpBackgroundSkyfile.skycell_id", "==");
     1659    pxAddLabelSearchArgs(config, where, "-label",        "warpBackgroundRun.label", "LIKE");
    16701660    pxAddLabelSearchArgs(config, where, "-data_group",   "warpBackgroundRun.data_group", "LIKE");
    16711661    pxAddLabelSearchArgs(config, where, "-dist_group",   "warpBackgroundRun.data_group", "LIKE");

  • branches/eam_branches/ipp-20130207/ippTools/src/bgtoolConfig.c

    r35121 r35236  
    5050    psMetadata *definechipArgs = psMetadataAlloc();
    5151    psMetadataAddS64(definechipArgs, PS_LIST_TAIL, "-chip_id", 0, "search by chip_id", 0);
     52    psMetadataAddS64(definechipArgs, PS_LIST_TAIL, "-cam_id", 0, "choose cam_id", 0);
    5253    psMetadataAddS64(definechipArgs, PS_LIST_TAIL, "-exp_id", 0, "search by exp_id", 0);
    5354    psMetadataAddStr(definechipArgs, PS_LIST_TAIL, "-exp_name", 0, "search by exp_name", NULL);
    … …  
    8990    psMetadataAddF32(definechipArgs, PS_LIST_TAIL, "-sun_angle_min", 0, "search by min solar angle", NAN);
    9091    psMetadataAddF32(definechipArgs, PS_LIST_TAIL, "-sun_angle_max", 0, "search by max solar angle", NAN);
    91     psMetadataAddStr(definechipArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search on chipRun label", NULL);
     92    psMetadataAddStr(definechipArgs, PS_LIST_TAIL, "-label", 0, "search on chipRun label", NULL);
     93    psMetadataAddStr(definechipArgs, PS_LIST_TAIL, "-cam_label", 0, "search on camRun label", NULL);
    9294    psMetadataAddBool(definechipArgs, PS_LIST_TAIL, "-destreaked", 0, "search for runs that have been destreaked", false);
    9395    psMetadataAddBool(definechipArgs, PS_LIST_TAIL, "-rerun", 0, "re-run data?", false);
    … …  
    279281    psMetadataAddF32(definewarpArgs, PS_LIST_TAIL, "-sun_angle_max", 0, "search by max solar angle", NAN);
    280282    psMetadataAddStr(definewarpArgs, PS_LIST_TAIL, "-warp_label", PS_META_DUPLICATE_OK, "search on warpRun label", NULL);
    281     psMetadataAddStr(definewarpArgs, PS_LIST_TAIL, "-chip_label", PS_META_DUPLICATE_OK, "search on chipBackgroundRun label", NULL);
     283    psMetadataAddStr(definewarpArgs, PS_LIST_TAIL, "-chip_label", PS_META_DUPLICATE_OK, "search on chipRun label", NULL);
     284    psMetadataAddStr(definewarpArgs, PS_LIST_TAIL, "-chip_bg_label", PS_META_DUPLICATE_OK, "search on chipBackgroundRun label", NULL);
    282285    psMetadataAddBool(definewarpArgs, PS_LIST_TAIL, "-destreaked", 0, "search for runs that have been destreaked", false);
    283286    psMetadataAddBool(definewarpArgs, PS_LIST_TAIL, "-rerun", 0, "rerun data?", false);
    … …  
    352355    psMetadata *warpArgs = psMetadataAlloc();
    353356    psMetadataAddS64(warpArgs, PS_LIST_TAIL, "-warp_bg_id", 0, "search by warp_bg_id", 0);
     357    psMetadataAddS64(warpArgs, PS_LIST_TAIL, "-warp_id", 0, "search by warp_id", 0);
     358    psMetadataAddS64(warpArgs, PS_LIST_TAIL, "-chip_bg_id", 0, "search by chip_bg_id", 0);
    354359    psMetadataAddStr(warpArgs, PS_LIST_TAIL, "-skycell_id", 0, "search by skycell_id", NULL);
    355360    psMetadataAddS16(warpArgs, PS_LIST_TAIL, "-fault",  0, "search by fault code", 0);

  • branches/eam_branches/ipp-20130207/ippTools/src/camtool.c

    r34587 r35236  
    500500    PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
    501501    PXOPT_LOOKUP_S16(quality, config->args, "-quality", false, false);
    502 
     502    PXOPT_LOOKUP_S16(background_model, config->args, "-background_model", false, false);
     503   
    503504    PXOPT_LOOKUP_STR(ver_pslib, config->args, "-ver_pslib", false, false);
    504505    PXOPT_LOOKUP_STR(ver_psmodules, config->args, "-ver_psmodules", false, false);
    … …  
    520521    PXOPT_LOOKUP_F32(maskfrac_max_magic, config->args, "-maskfrac_max_magic", false, false);
    521522    PXOPT_LOOKUP_F32(maskfrac_max_advisory, config->args, "-maskfrac_max_advisory", false, false);
    522 
     523   
    523524    // we store actual detection efficiency by adding in zpt_obs
    524525    PXOPT_LOOKUP_F32(deteff_inst, config->args, "-deteff_inst", false, false);
    … …  
    542543    }
    543544
    544 /*     psTrace("czw.test",1,"Received versions: pslib %s psmodules %s psphot %s psastro %s ppstats %s ppImage %s streaks %s\n", */
    545 /*          ver_pslib,ver_psmodules,ver_psphot,ver_psastro,ver_ppstats,ver_ppimage,ver_streaks); */
    546545    psString software_ver = NULL;
    547546    if ((ver_pslib)&&(ver_psmodules)) {
    … …  
    692691        deteff_lq,
    693692        deteff_uq,
    694         quality
     693        quality,
     694        background_model
    695695        );
    696696
    … …  
    817817    pxAddLabelSearchArgs (config, where, "-data_group", "camRun.data_group",     "LIKE");
    818818    PXOPT_COPY_STR(config->args, where, "-reduction", "camRun.reduction", "==");
    819 
     819    PXOPT_COPY_S16(config->args, where, "-background_model", "camProcessedExp.background_model", "==");
     820   
    820821    psString where2 = NULL;
    821822    if (!pxspaceAddWhere(config, &where2, "rawExp")) {
    … …  
    987988    PXOPT_LOOKUP_S16(fault, config->args, "-fault", true, false);
    988989    PXOPT_LOOKUP_S16(quality, config->args, "-set_quality", false, false);
    989 
    990     psMetadata *where = psMetadataAlloc();
    991     PXOPT_COPY_S64(config->args, where, "-cam_id",   "cam_id",   "==");
    992     PXOPT_COPY_S64(config->args, where, "-chip_id",  "chip_id",  "==");
    993     PXOPT_COPY_STR(config->args, where, "-class",    "class",    "==");
    994     PXOPT_COPY_STR(config->args, where, "-class_id", "class_id", "==");
    995 
    996     if (!pxSetFaultCode(config->dbh, "camProcessedExp", where, fault, quality)) {
     990    PXOPT_LOOKUP_S16(background_model, config->args, "-set_background_model", false, false);
     991    if (background_model) {
     992      // CZW Copied from warptool.c
     993      psMetadata *where = psMetadataAlloc();
     994      psMetadata *values = psMetadataAlloc();
     995      PXOPT_COPY_S64(config->args, where, "-cam_id", "cam_id", "==");
     996      PXOPT_COPY_S16(config->args, values, "-set_background_model", "background_model", "==");
     997      long rows = psDBUpdateRows(config->dbh, "camProcessedExp", where, values);
     998      psFree(values);
     999      psFree(where);
     1000      if (!rows) {
     1001        psError(PS_ERR_UNKNOWN, true, "no rows changed");
     1002      }
     1003    }
     1004    else {
     1005      psMetadata *where = psMetadataAlloc();
     1006      PXOPT_COPY_S64(config->args, where, "-cam_id",   "cam_id",   "==");
     1007      PXOPT_COPY_S64(config->args, where, "-chip_id",  "chip_id",  "==");
     1008      PXOPT_COPY_STR(config->args, where, "-class",    "class",    "==");
     1009      PXOPT_COPY_STR(config->args, where, "-class_id", "class_id", "==");
     1010     
     1011      if (!pxSetFaultCode(config->dbh, "camProcessedExp", where, fault, quality)) {
    9971012        psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag");
    9981013        psFree (where);
    9991014        return false;
    1000     }
    1001     psFree (where);
    1002 
     1015      }
     1016      psFree (where);
     1017    }
    10031018    return true;
    10041019}

  • branches/eam_branches/ipp-20130207/ippTools/src/camtoolConfig.c

    r33111 r35236  
    204204    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-deteff_inst_lq", 0, "define deteff_lq", NAN);
    205205    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-deteff_inst_uq", 0, "define deteff_uq", NAN);
    206 
     206    psMetadataAddS16(addprocessedexpArgs, PS_LIST_TAIL, "-background_model", 0, "set background_model value", 0);
    207207
    208208    // -processedexp
    … …  
    222222    psMetadataAddBool(processedexpArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    223223    psMetadataAddBool(processedexpArgs, PS_LIST_TAIL, "-faulted", 0,            "only return imfiles with a fault status set", false);
     224    psMetadataAddS16(processedexpArgs, PS_LIST_TAIL, "-background_model", 0, "search by background_model value", 0);
    224225
    225226    // -revertprocessedexp
    … …  
    246247    psMetadataAddS16(updateprocessedexpArgs, PS_LIST_TAIL, "-fault",  0,            "set fault code (required)", INT16_MAX);
    247248    psMetadataAddS16(updateprocessedexpArgs, PS_LIST_TAIL, "-set_quality",  0,            "set quality", 0);
     249    psMetadataAddS16(updateprocessedexpArgs, PS_LIST_TAIL, "-set_background_model", 0, "set background_model value", 0);
    248250
    249251    // -block

  • branches/eam_branches/ipp-20130207/ippTools/src/difftool.c

    r34770 r35236  
    12261226}
    12271227
    1228 
     1228static bool definewarpstackMode(pxConfig *config)
     1229{
     1230  PS_ASSERT_PTR_NON_NULL(config, false);
     1231
     1232  psMetadata *where = psMetadataAlloc();
     1233
     1234  PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
     1235  PXOPT_COPY_STR(config->args, where, "-filter", "filter", "==");
     1236  PXOPT_COPY_STR(config->args, where, "-comment", "comment", "LIKE");
     1237  PXOPT_COPY_S64(config->args, where, "-warp_id", "warpRun.warp_id", "==");
     1238  PXOPT_COPY_STR(config->args, where, "-warp_label", "warpRun.label", "==");
     1239  PXOPT_COPY_STR(config->args, where, "-tess_id", "warpRun.tess_id", "==");
     1240  PXOPT_COPY_STR(config->args, where, "-data_group", "warpRun.data_group", "==");
     1241  PXOPT_COPY_STR(config->args, where, "-skycell_id", "warpSkyfile.skycell_id", "==");
     1242  PXOPT_COPY_F32(config->args, where,  "-good_frac", "warpSkyfile.good_frac", ">=");
     1243  PXOPT_COPY_STR(config->args, where, "-stack_label", "stackRun.label", "==");
     1244  PXOPT_COPY_STR(config->args, where, "-stack_data_group", "stackRun.data_group", "==");
     1245
     1246  PXOPT_LOOKUP_BOOL(bothways, config->args, "-bothways", false);
     1247 
     1248  PXOPT_LOOKUP_STR(workdir, config->args, "-set_workdir", true, false); // required option
     1249  PXOPT_LOOKUP_STR(reduction, config->args, "-set_reduction", false, false); // option
     1250  PXOPT_LOOKUP_STR(label, config->args, "-set_label", true, false); // option
     1251  PXOPT_LOOKUP_STR(data_group, config->args, "-set_data_group", false, false);
     1252  PXOPT_LOOKUP_STR(dist_group, config->args, "-set_dist_group", false, false);
     1253  PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
     1254  PXOPT_LOOKUP_TIME(registered, config->args, "-set_registered", false, false);
     1255 
     1256  PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1257  PXOPT_LOOKUP_BOOL(newTemplates, config->args, "-new-templates", false);
     1258  PXOPT_LOOKUP_BOOL(reRun, config->args, "-rerun", false);
     1259  PXOPT_LOOKUP_BOOL(available, config->args, "-available", false);
     1260  PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
     1261
     1262
     1263  // Get query file
     1264  psString query = pxDataGet("difftool_definewarpstack.sql");
     1265  if (!query) {
     1266    psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1267    return false;
     1268  }
     1269
     1270  psString whereClause = psDBGenerateWhereConditionSQL(where,NULL);
     1271 
     1272  // Don't queue things that already have diffs.
     1273  if (! (reRun || newTemplates) ) {
     1274    psStringAppend(&whereClause, "\nAND diff_id IS NULL\n");
     1275  }
     1276  // Append diff qualifiers, if we have them
     1277  if (label) {
     1278    psStringAppend(&whereClause, "\nAND ((diffRun.label = '%s') OR (diffRun.label IS NULL))",label);
     1279  }
     1280  if (data_group) {
     1281    psStringAppend(&whereClause, "\nAND ((diffRun.data_group = '%s') OR (diffRun.data_group IS NULL))",data_group);
     1282  }
     1283  if (reduction) {
     1284    psStringAppend(&whereClause, "\nAND ((diffRun.reduction = '%s') OR (diffRun.reduction IS NULL))",reduction);
     1285  }
     1286
     1287  psString whereClauseString = psStringCopy("");
     1288  psStringAppend(&whereClauseString, " \n AND %s ", whereClause);
     1289  //  fprintf(stderr,query,whereClauseString);
     1290
     1291  // This is just a simple query, so we don't need to do a transaction
     1292  if (!p_psDBRunQueryF(config->dbh, query, whereClauseString)) {
     1293    psError(PS_ERR_UNKNOWN, false, "database error");
     1294    psFree(query);
     1295    psFree(whereClause);
     1296    return(false);
     1297  }
     1298  psFree(query);
     1299  psFree(whereClause);
     1300  psFree(whereClauseString);
     1301 
     1302  psArray *output = p_psDBFetchResult(config->dbh);
     1303  if (!output) {
     1304    psErrorCode err = psErrorCodeLast();
     1305    switch (err) {
     1306    case PS_ERR_DB_CLIENT:
     1307      psError(PXTOOLS_ERR_SYS, false, "database error");
     1308      break;
     1309    case PS_ERR_DB_SERVER:
     1310      psError(PXTOOLS_ERR_PROG, false, "database error");
     1311      break;
     1312    default:
     1313      psError(PXTOOLS_ERR_PROG, false, "unknown error");
     1314      break;
     1315    }
     1316    return false;
     1317  }
     1318  if (!psArrayLength(output)) {
     1319    psTrace("difftool", PS_LOG_INFO, "no rows found");
     1320    psFree(output);
     1321    return true;
     1322  }
     1323  if (pretend) {
     1324    // negative simple so the default is true
     1325    if (!ippdbPrintMetadatas(stdout, output, "diffRun", !simple)) {
     1326      psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1327      psFree(output);
     1328      return false;
     1329    }
     1330    psFree(output);
     1331    return true;
     1332  }
     1333
     1334  psArray *list = psArrayAllocEmpty(16); // List of runs, to print
     1335  long numGood = 0;
     1336  psS64 last_exp_id = 0;
     1337  psS64 diff_id = 0;
     1338  for (long i = 0; i < output->n; i++) {
     1339    psMetadata *row = output->data[i];
     1340    bool mdok;
     1341
     1342    psS64 exp_id = psMetadataLookupS64(&mdok, row, "exp_id");
     1343    if (!mdok) {
     1344        psError(PXTOOLS_ERR_PROG, false, "exp_id not found");
     1345        if (!psDBRollback(config->dbh)) {
     1346          psError(PS_ERR_UNKNOWN, false, "database error");
     1347        }
     1348        return false;
     1349    }
     1350    if (exp_id != last_exp_id) {
     1351      if (diff_id != 0) { // We've added a run already, and are now switching to a new one.
     1352        // Set state to new
     1353        if (!setdiffRunState(config, diff_id, "new", false)) {
     1354          psError(PS_ERR_UNKNOWN, false, "failed to change diffRun.state for diff_id: %" PRId64, diff_id);
     1355          if (!psDBRollback(config->dbh)) {
     1356            psError(PS_ERR_UNKNOWN, false, "database error");
     1357          }
     1358          return false;
     1359        }
     1360        // Commit results
     1361        if (!psDBCommit(config->dbh)) {
     1362          psError(PS_ERR_UNKNOWN, false, "database error");
     1363          psFree(list);
     1364          return false;
     1365        }
     1366      }
     1367     
     1368      // Begin transaction
     1369      if (!psDBTransaction(config->dbh)) {
     1370        psError(PS_ERR_UNKNOWN, false, "database error");
     1371        return false;
     1372      }
     1373      // Add a new diffRun row
     1374      psString tess_id = psMetadataLookupStr(&mdok, row, "tess_id");
     1375      if (!mdok) {
     1376        psError(PXTOOLS_ERR_PROG, false, "tess_id not found");
     1377        if (!psDBRollback(config->dbh)) {
     1378          psError(PS_ERR_UNKNOWN, false, "database error");
     1379        }
     1380        return false;
     1381      }
     1382      diffRunRow *run = diffRunRowAlloc(
     1383                                        0,        // ID
     1384                                        "reg",    // state
     1385                                        workdir,
     1386                                        label,
     1387                                        data_group ? data_group : label,
     1388                                        dist_group,
     1389                                        reduction,
     1390                                        NULL,     // dvodb
     1391                                        registered,
     1392                                        tess_id,
     1393                                        bothways, // bothways (default is false)
     1394                                        true,     // exposure
     1395                                        0,        // magicked
     1396                                        NULL,     // software_version
     1397                                        0,        // mask stat npix
     1398                                        NAN,      // static
     1399                                        NAN,      // dynamic
     1400                                        NAN,      // magic
     1401                                        NAN,      // advisory
     1402                                        IPP_DIFF_MODE_WARP_STACK,
     1403                                        note
     1404                                        );
     1405      if (!diffRunInsertObject(config->dbh, run)) {
     1406        psError(PS_ERR_UNKNOWN, false, "database error");
     1407        psFree(run);
     1408        if (!psDBRollback(config->dbh)) {
     1409          psError(PS_ERR_UNKNOWN, false, "database error");
     1410        }
     1411      }
     1412      diff_id = psDBLastInsertID(config->dbh);
     1413      run->diff_id = diff_id;
     1414
     1415      psArrayAdd(list, list->n, run);
     1416      numGood++;
     1417     
     1418      last_exp_id = exp_id;                                     
     1419    } // End Adding diffRun
     1420   
     1421    if (exp_id == last_exp_id) {
     1422      psString skycell_id = psMetadataLookupStr(&mdok, row, "skycell_id");
     1423      if (!mdok) {
     1424        psError(PXTOOLS_ERR_PROG, false, "skycell_id not found");
     1425        if (!psDBRollback(config->dbh)) {
     1426          psError(PS_ERR_UNKNOWN, false, "database error");
     1427        }
     1428        return false;
     1429      }
     1430      psString tess_id = psMetadataLookupStr(&mdok, row, "tess_id");
     1431      if (!mdok) {
     1432        psError(PXTOOLS_ERR_PROG, false, "tess_id not found");
     1433        if (!psDBRollback(config->dbh)) {
     1434          psError(PS_ERR_UNKNOWN, false, "database error");
     1435        }
     1436        return false;
     1437      }
     1438      psS64 warp_id = psMetadataLookupS64(&mdok, row, "warp_id");
     1439      if (!mdok) {
     1440        psError(PXTOOLS_ERR_PROG, false, "warp_id not found");
     1441        if (!psDBRollback(config->dbh)) {
     1442          psError(PS_ERR_UNKNOWN, false, "database error");
     1443        }
     1444        return false;
     1445      }
     1446      psS64 stack_id = psMetadataLookupS64(&mdok, row, "stack_id");
     1447      if (!mdok) {
     1448        psError(PXTOOLS_ERR_PROG, false, "stack_id not found");
     1449        if (!psDBRollback(config->dbh)) {
     1450          psError(PS_ERR_UNKNOWN, false, "database error");
     1451        }
     1452        return false;
     1453      }
     1454
     1455      // Add a new skyfile row
     1456      diffInputSkyfileRow *skyfile = diffInputSkyfileRowAlloc(
     1457                                                              diff_id,   // ID
     1458                                                              skycell_id,
     1459                                                              warp_id, // warp1_id
     1460                                                              PS_MAX_S64, // stack1 -> NULL
     1461                                                              PS_MAX_S64, // warp2_id -> NULL
     1462                                                              stack_id, // stack2
     1463                                                              tess_id,
     1464                                                              0 // diff_skyfile_id
     1465                                                              );
     1466      //      fprintf(stderr,"%"PRId64 " %"PRId64 " %"PRId64 " %s %s\n",diff_id,warp_id,stack_id,skycell_id, tess_id);
     1467      if (!diffInputSkyfileInsertObject(config->dbh, skyfile)) {
     1468        psError(PS_ERR_UNKNOWN, false, "database error");
     1469        psFree(list);
     1470        if (!psDBRollback(config->dbh)) {
     1471          psError(PS_ERR_UNKNOWN, false, "database error");
     1472        }
     1473        return false;
     1474      }
     1475    } // End Adding skyfile
     1476  } // End parsing result set
     1477 
     1478  // Finish the last run's update and close the connection
     1479  if (diff_id != 0) {
     1480    if (!setdiffRunState(config, diff_id, "new", false)) {
     1481      psError(PS_ERR_UNKNOWN, false, "failed to change diffRun.state for diff_id: %" PRId64, diff_id);
     1482      if (!psDBRollback(config->dbh)) {
     1483        psError(PS_ERR_UNKNOWN, false, "database error");
     1484      }
     1485      return false;
     1486    }
     1487    // Commit results
     1488    if (!psDBCommit(config->dbh)) {
     1489      psError(PS_ERR_UNKNOWN, false, "database error");
     1490      psFree(list);
     1491      return false;
     1492    }
     1493  }
     1494 
     1495  if (numGood && !diffRunPrintObjects(stdout, list, !simple)) {
     1496    psError(PS_ERR_UNKNOWN, false, "failed to print object");
     1497    psFree(list);
     1498    return(false);
     1499  }
     1500  psFree(list);
     1501  // Free things
     1502  return true;
     1503} 
     1504
     1505#if (0)
    12291506static bool definewarpstackMode(pxConfig *config)
    12301507{
    … …  
    16141891    return true;
    16151892}
     1893#endif
    16161894
    16171895static bool definewarpwarpMode(pxConfig *config)

  • branches/eam_branches/ipp-20130207/ippTools/src/disttool.c

    r34235 r35236  
    143143    // optional
    144144    PXOPT_LOOKUP_BOOL(use_alternate, config->args, "-use_alternate", false);
    145     PXOPT_LOOKUP_BOOL(no_magic, config->args, "-no_magic", false);
     145    PXOPT_LOOKUP_BOOL(magic, config->args, "-magic", false);
    146146    PXOPT_LOOKUP_STR(set_label, config->args, "-set_label", false, false);
    147147    PXOPT_LOOKUP_STR(set_data_group, config->args, "-set_data_group", false, false);
    … …  
    175175            return false;
    176176        }
    177         if (no_magic) {
     177        if (!magic) {
    178178            psError(PXTOOLS_ERR_SYS, true, "no_magic forbidden with alternate inputs");
    179179            return false;
    … …  
    187187    // an interest)
    188188    // and exp_id to be supplied. We could add -exp_type and dateobs cuts to make it easier
    189     if (!strcmp(stage, "raw") && no_magic && !(exp_id && dist_group && exp_type)) {
     189    if (!strcmp(stage, "raw") && !magic && !(exp_id && dist_group && exp_type)) {
    190190        psError(PXTOOLS_ERR_SYS, true, "exp_id, exp_type, and dist_group are required for raw stage if no_magic");
    191191        return false;
    … …  
    204204            runJoinStr = "camRun.exp_id";
    205205        }
    206         if (!no_magic) {
     206        if (magic) {
    207207            query = pxDataGet("disttool_definebyquery_raw.sql");
    208208        } else {
    … …  
    215215        }
    216216
    217         if (!no_magic) {
     217        if (magic) {
    218218            if (label) {
    219219                psStringAppend(&query, " AND (magicDSRun.label = '%s')", label);
    … …  
    289289        }
    290290        // fake stage doesn't require magic
    291         no_magic = true;
     291        magic = false;
    292292    } else if (!strcmp(stage, "warp")) {
    293293        magicRunType = "warpRun";
    … …  
    357357        }
    358358        // stack stage doesn't require magic
    359         no_magic = true;
     359        magic = false;
    360360    } else if (!strcmp(stage, "sky")) {
    361361        magicRunType = "staticskyRun";
    … …  
    378378        }
    379379        // (static)sky stage doesn't require magic
    380         no_magic = true;
     380        magic = false;
    381381    } else if (!strcmp(stage, "SSdiff")) {
    382382      magicRunType = "diffRun";
    … …  
    396396      }
    397397
    398       no_magic = true;
     398      magic = false;
    399399    } else {
    400400        psError(PS_ERR_UNKNOWN, true, "unknown value for stage: %s", stage);
    … …  
    408408
    409409    if (!strcmp(stage, "raw")) {
    410         if (!no_magic) {
     410        if (magic) {
    411411            psStringAppend(&query, " AND (magicDSRun.re_place = %d)", !use_alternate);
    412412            psStringAppend(&query, " AND (camRun.state = 'full')");
    … …  
    426426    psString joinHook = NULL;
    427427
    428     if (!no_magic) {
     428    if (magic) {
    429429        psStringAppend(&query, " AND (%s.magicked > 0)", magicRunType);
    430430    }
    … …  
    517517                NULL,     // outdir
    518518                clean,
    519                 no_magic,
     519                !magic,
    520520                use_alternate,
    521521                "new",

  • branches/eam_branches/ipp-20130207/ippTools/src/disttoolConfig.c

    r33042 r35236  
    4848    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-workdir",   0, "define workdir (required)", NULL);
    4949
    50     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-no_magic", 0, "magic is not needed", false);
     50    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-no_magic", 0, "magic is not needed (ignored)", false);
     51    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-magic", 0, "magic is needed", false);
    5152    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-use_alternate", 0, "use alternate inputs", false);
    5253    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_label",    0, "define label for run", NULL);

  • branches/eam_branches/ipp-20130207/ippTools/src/magictool.c

    • Property svn:mergeinfo changed (with no actual effect on merging)

  • branches/eam_branches/ipp-20130207/ippTools/src/releasetool.c

    r35048 r35236  
    4141static bool listreleaseMode(pxConfig *config);
    4242static bool definerelexpMode(pxConfig *config);
     43static bool tocalibexpMode(pxConfig *config);
    4344static bool updaterelexpMode(pxConfig *config);
    4445static bool listrelexpMode(pxConfig *config);
     46static bool definerelstackMode(pxConfig *config);
     47static bool updaterelstackMode(pxConfig *config);
     48static bool listrelstackMode(pxConfig *config);
     49static bool definerelgroupMode(pxConfig *config);
     50static bool pendingrelgroupMode(pxConfig *config);
     51static bool updaterelgroupMode(pxConfig *config);
     52static bool listrelgroupMode(pxConfig *config);
    4553
    4654# define MODECASE(caseName, func) \
    … …  
    6674        MODECASE(RELEASETOOL_MODE_DEFINERELEASE,    definereleaseMode);
    6775        MODECASE(RELEASETOOL_MODE_UPDATERELEASE,    updatereleaseMode);
     76        MODECASE(RELEASETOOL_MODE_TOCALIBEXP,       tocalibexpMode);
    6877        MODECASE(RELEASETOOL_MODE_LISTRELEASE,      listreleaseMode);
    6978
    … …  
    7180        MODECASE(RELEASETOOL_MODE_UPDATERELEXP,     updaterelexpMode);
    7281        MODECASE(RELEASETOOL_MODE_LISTRELEXP,       listrelexpMode);
     82
     83        MODECASE(RELEASETOOL_MODE_DEFINERELSTACK,   definerelstackMode);
     84        MODECASE(RELEASETOOL_MODE_UPDATERELSTACK,   updaterelstackMode);
     85        MODECASE(RELEASETOOL_MODE_LISTRELSTACK,     listrelstackMode);
     86
     87        MODECASE(RELEASETOOL_MODE_DEFINERELGROUP,   definerelgroupMode);
     88        MODECASE(RELEASETOOL_MODE_UPDATERELGROUP,   updaterelgroupMode);
     89        MODECASE(RELEASETOOL_MODE_PENDINGRELGROUP,  pendingrelgroupMode);
     90        MODECASE(RELEASETOOL_MODE_LISTRELGROUP,     listrelgroupMode);
    7391        default:
    7492            psAbort("invalid option (this should not happen)");
    … …  
    163181
    164182    PXOPT_LOOKUP_S32(surveyID,    config->args, "-set_surveyID", true, false);
    165     PXOPT_LOOKUP_STR(releaseName, config->args, "-set_releaseName", true, false);
     183    PXOPT_LOOKUP_STR(release_name, config->args, "-set_release_name", true, false);
    166184    PXOPT_LOOKUP_STR(release_state, config->args, "-set_release_state",  true, false);
    167185    PXOPT_LOOKUP_S32(dataRelease, config->args, "-set_dataRelease", false, false);
    … …  
    171189        0,      // rel_id (auto_increment)
    172190        surveyID,
    173         releaseName,
     191        release_name,
    174192        release_state,
    175193        dataRelease,
    … …  
    187205    PS_ASSERT_PTR_NON_NULL(config, false);
    188206
    189     PXOPT_LOOKUP_STR(releaseName, config->args, "-releaseName", false, false);
     207    PXOPT_LOOKUP_STR(release_name, config->args, "-release_name", false, false);
    190208    PXOPT_LOOKUP_S32(rel_id, config->args,      "-rel_id", false, false);
    191209
    192     if (!releaseName && !rel_id) {
    193         psError(PXTOOLS_ERR_CONFIG, true, "either -releaseName or -rel_id is required\n");
    194         return false;
    195     }
    196     PXOPT_LOOKUP_STR(release_state,       config->args, "-set_release_state",  true, false);
     210    if (!release_name && !rel_id) {
     211        psError(PXTOOLS_ERR_CONFIG, true, "either -release_name or -rel_id is required\n");
     212        return false;
     213    }
     214    PXOPT_LOOKUP_STR(release_state,    config->args, "-set_release_state",  false, false);
     215    PXOPT_LOOKUP_S32(priority,         config->args, "-set_priority",  false, false);
     216    PXOPT_LOOKUP_S32(dataRelease,      config->args, "-set_dataRelease",  false, false);
     217    if (!release_state && priority == 0 && dataRelease == -1) {
     218        psError(PXTOOLS_ERR_CONFIG, true, "at least one of -set_release_state -set_priority and -set_dataRelease is required\n");
     219        return false;
     220    }
    197221
    198222    psMetadata *where = psMetadataAlloc();
    199223
    200224    PXOPT_COPY_S32(config->args, where, "-rel_id",  "rel_id", "==");
    201     PXOPT_COPY_STR(config->args, where, "-releaseName", "releaseName", "==");
    202 
    203     psString query = NULL;
    204     psStringAppend(&query, "UPDATE ippRelease SET release_state = '%s'", release_state);
     225    PXOPT_COPY_STR(config->args, where, "-release_name", "release_name", "==");
     226
     227    psString sep = "";
     228    psString comma = ", ";
     229    psString query = psStringCopy("UPDATE ippRelease SET");
     230    if (release_state) {
     231        psStringAppend(&query, "%s release_state = '%s'", sep, release_state);
     232        sep = comma;
     233    }
     234    if (priority != 0) {
     235        psStringAppend(&query, "%s priority = %d", sep, priority);
     236        sep = comma;
     237    }
     238    if (dataRelease != -1) {
     239        psStringAppend(&query, "%s dataRelease = %d", sep, dataRelease);
     240        sep = comma;
     241    }
    205242
    206243    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    … …  
    232269
    233270    PXOPT_COPY_STR(config->args, where, "-surveyName",  "surveyName", "LIKE");
    234     PXOPT_COPY_STR(config->args, where, "-releaseName", "releaseName", "LIKE");
     271    PXOPT_COPY_STR(config->args, where, "-release_name", "release_name", "LIKE");
    235272    PXOPT_COPY_STR(config->args, where, "-release_state", "release_state", "==");
    236273    PXOPT_COPY_S32(config->args, where, "-rel_id",  "rel_id", "==");
    … …  
    313350    // insure that at least one of these is supplied to select the release
    314351    PXOPT_LOOKUP_S64(rel_id, config->args,      "-rel_id", false, false);
    315     PXOPT_LOOKUP_STR(releaseName, config->args, "-releaseName", false, false);
    316     if (!rel_id && !releaseName) {
    317         psError(PXTOOLS_ERR_CONFIG, true, "either -rel_id or -releaseName is required");
    318         return false;
    319     }
    320 
    321     // limit query to the target release. (Note: this will select nothing of releaseName and rel_id don't match)
     352    PXOPT_LOOKUP_STR(release_name, config->args, "-release_name", false, false);
     353    if (!rel_id && !release_name) {
     354        psError(PXTOOLS_ERR_CONFIG, true, "either -rel_id or -release_name is required");
     355        return false;
     356    }
     357
     358    // limit query to the target release. (Note: this will select nothing if release_name and rel_id don't match)
    322359    // note: we add these after above to insure that search args are supplied
    323     PXOPT_COPY_STR(config->args, where, "-releaseName", "ippRelease.releaseName", "==");
     360    PXOPT_COPY_STR(config->args, where, "-release_name", "ippRelease.release_name", "==");
    324361    PXOPT_COPY_S32(config->args, where, "-rel_id", "ippRelease.rel_id", "==");
    325362
    … …  
    327364    PXOPT_LOOKUP_STR(state, config->args,     "-set_state", true, false);
    328365    PXOPT_LOOKUP_U32(flags, config->args,     "-set_flags", false, false);
     366    PXOPT_LOOKUP_F32(user_zpt_obs, config->args,   "-set_zpt_obs", false, false);
     367    PXOPT_LOOKUP_F32(user_zpt_stdev, config->args, "-set_zpt_stdev", false, false);
    329368    PXOPT_LOOKUP_STR(path_base, config->args, "-set_path_base", false, false);
     369    PXOPT_LOOKUP_S16(fault, config->args,     "-set_fault", false, false);
    330370
    331371    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
    … …  
    391431        psS64 chip_id = psMetadataLookupS64(&status, md, "chip_id");
    392432        psS64 cam_id = psMetadataLookupS64(&status, md, "cam_id");
    393         psF32 zpt_obs = psMetadataLookupF32(&status, md, "zpt_obs");
    394         psF32 zpt_stdev = psMetadataLookupF32(&status, md, "zpt_stdev");
     433
     434        // if zpt_obs or zpt_stdev were not supplied use the results from the camRun
     435        psF32 zpt_obs, zpt_stdev;
     436        if (!isfinite(user_zpt_obs)) {
     437            zpt_obs = psMetadataLookupF32(&status, md, "zpt_obs");
     438        } else {
     439            zpt_obs = user_zpt_obs;
     440        }
     441        if (!isfinite(user_zpt_stdev)) {
     442            zpt_stdev = psMetadataLookupF32(&status, md, "zpt_stdev");
     443        } else {
     444            zpt_stdev = user_zpt_stdev;
     445        }
    395446
    396447        if (!relExpInsert(config->dbh,
    … …  
    400451            chip_id,
    401452            cam_id,
     453            0,          // group_id
    402454            state,
    403455            flags,
    … …  
    405457            zpt_stdev,
    406458            path_base,
     459            fault,
    407460            now,       // registered
    408461            now        // time_stamp
    … …  
    430483static bool updaterelexpMode(pxConfig *config)
    431484{
    432     psError(PS_ERR_UNKNOWN, true, "not yet implemented");
    433     return false;
    434 }
    435 
    436 static bool listrelexpMode(pxConfig *config)
     485    PS_ASSERT_PTR_NON_NULL(config, false);
     486
     487    PXOPT_LOOKUP_STR(release_name, config->args, "-release_name", false, false);
     488    PXOPT_LOOKUP_S32(rel_id, config->args,      "-rel_id", false, false);
     489    PXOPT_LOOKUP_S32(relexp_id, config->args,   "-relexp_id", false, false);
     490
     491    if (!relexp_id && !release_name && !rel_id) {
     492        psError(PXTOOLS_ERR_CONFIG, true, "at least one of -relexp_id, -release_name, and -rel_id is required\n");
     493        return false;
     494    }
     495
     496    PXOPT_LOOKUP_STR(state,    config->args, "-set_state",  false, false);
     497    PXOPT_LOOKUP_U32(flags,    config->args, "-set_flags",  false, false);
     498    PXOPT_LOOKUP_STR(path_base, config->args, "-set_path_base", false, false);
     499    PXOPT_LOOKUP_F32(zpt_obs,  config->args, "-set_zpt_obs",  false, false);
     500    PXOPT_LOOKUP_F32(zpt_stdev,config->args, "-set_zpt_stdev",  false, false);
     501    PXOPT_LOOKUP_S16(fault,    config->args, "-set_fault",  false, false);
     502    PXOPT_LOOKUP_BOOL(clearfault, config->args, "-clearfault",  false);
     503    if (!state && !flags && !path_base && !isfinite(zpt_obs) && !isfinite(zpt_stdev) && !fault && !clearfault) {
     504        psError(PXTOOLS_ERR_CONFIG, true, "must set at least one column\n");
     505        return false;
     506    }
     507
     508    if (fault && clearfault) {
     509        psError(PXTOOLS_ERR_CONFIG, true, "cannot set and clear fault at same time\n");
     510        return false;
     511    }
     512
     513    psMetadata *where = psMetadataAlloc();
     514
     515    PXOPT_COPY_S64(config->args, where, "-exp_id", "relExp.exp_id", "==");
     516    PXOPT_COPY_S32(config->args, where, "-relexp_id", "relExp.relexp_id", "==");
     517    PXOPT_COPY_STR(config->args, where, "-exp_name", "rawExp.exp_name", "==");
     518    // make sure that we have enough parameters to identify the relExp to change
     519    if (!psListLength(where->list)){
     520        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required\n");
     521        psFree(where);
     522        return false;
     523    }
     524
     525    PXOPT_COPY_S32(config->args, where, "-rel_id",  "rel_id", "==");
     526    PXOPT_COPY_STR(config->args, where, "-release_name", "release_name", "==");
     527
     528    psString sep = "";
     529    psString comma = ", ";
     530    psString query = psStringCopy("UPDATE relExp JOIN ippRelease USING(rel_id) JOIN rawExp USING(exp_id) SET");
     531    if (state) {
     532        psStringAppend(&query, "%s relExp.state = '%s'", sep, state);
     533        sep = comma;
     534    }
     535    if (path_base) {
     536        psStringAppend(&query, "%s relExp.path_base = '%s'", sep, path_base);
     537        sep = comma;
     538    }
     539    if (flags) {
     540        psStringAppend(&query, "%s relExp.flags = %d", sep, flags);
     541        sep = comma;
     542    }
     543    if (isfinite(zpt_obs)) {
     544        psStringAppend(&query, "%s relExp.zpt_obs = %f", sep, zpt_obs);
     545        sep = comma;
     546    }
     547    if (isfinite(zpt_stdev)) {
     548        psStringAppend(&query, "%s relExp.zpt_stdev = %f", sep, zpt_stdev);
     549        sep = comma;
     550    }
     551    if (fault) {
     552        psStringAppend(&query, "%s relExp.fault = %d", sep, fault);
     553        sep = comma;
     554    }
     555    if (clearfault) {
     556        psStringAppend(&query, "%s relExp.fault = 0", sep);
     557        sep = comma;
     558    }
     559
     560    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     561    psStringAppend(&query, " WHERE %s", whereClause);
     562    psFree(whereClause);
     563
     564    if (!p_psDBRunQuery(config->dbh, query)) {
     565        psError(PS_ERR_UNKNOWN, false, "database error");
     566        psFree(query);
     567        return false;
     568    }
     569
     570    psU64 affected = psDBAffectedRows(config->dbh);
     571    psLogMsg("releasetool", PS_LOG_INFO, "Updated %" PRIu64 " ippReleases", affected);
     572
     573
     574    psFree(query);
     575
     576    return true;
     577}
     578
     579static bool tocalibexpMode(pxConfig *config)
    437580{
    438581    PS_ASSERT_PTR_NON_NULL(config, NULL);
    … …  
    440583    psMetadata *where = psMetadataAlloc();
    441584
    442     PXOPT_COPY_STR(config->args, where, "-releaseName", "ippRelease.releaseName", "LIKE");
     585    PXOPT_COPY_S64(config->args, where, "-relexp_id",   "relExp.relexp_id", "==");
     586    PXOPT_COPY_STR(config->args, where, "-release_name", "ippRelease.release_name", "LIKE");
     587#ifdef notdef
     588    PXOPT_COPY_S32(config->args, where, "-rel_id",      "relExp.rel_id", "==");
    443589    pxAddLabelSearchArgs(config, where, "-release_state","ippRelease.state", "==");
    444590    PXOPT_COPY_STR(config->args, where, "-state",       "relExp.state", "==");
    … …  
    458604
    459605    PXOPT_COPY_STR(config->args, where, "-surveyName",  "survey.surveyName", "LIKE");
     606
     607    PXOPT_LOOKUP_BOOL(priority_order, config->args, "-priority_order", false);
     608#endif
     609
     610    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     611    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     612
     613    psString query = pxDataGet("releasetool_tocalibexp.sql");
     614    if (!query) {
     615        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     616        return false;
     617    }
     618
     619    psString where2 = NULL;
     620#ifdef notdef
     621    if (!pxspaceAddWhere(config, &where2, "rawExp")) {
     622        psError(psErrorCodeLast(), false, "pxspaceAddWhere failed");
     623        return false;
     624    }
     625#endif
     626
     627    if (psListLength(where->list)) {
     628        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     629        psStringAppend(&query, "\nAND %s", whereClause);
     630        psFree(whereClause);
     631#ifdef notdef
     632    } else if (where2) {
     633        psStringAppend(&query, "\nAND ");
     634#endif
     635    } else {
     636        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required\n");
     637        psFree(where);
     638        return false;
     639    }
     640
     641    if (where2) {
     642        psStringAppend(&query, "\n%s", where2);
     643        psFree(where2);
     644    }
     645
     646    if (limit) {
     647        psString limitString = psDBGenerateLimitSQL(limit);
     648        psStringAppend(&query, " %s", limitString);
     649        psFree(limitString);
     650    }
     651
     652    if (!p_psDBRunQuery(config->dbh, query)) {
     653        psError(PS_ERR_UNKNOWN, false, "database error");
     654        psFree(query);
     655        return false;
     656    }
     657    psFree(query);
     658
     659    psArray *output = p_psDBFetchResult(config->dbh);
     660    if (!output) {
     661        psError(PS_ERR_UNKNOWN, false, "database error");
     662        return false;
     663    }
     664
     665    if (!psArrayLength(output)) {
     666        psTrace("releasetool", PS_LOG_INFO, "no rows found");
     667        psFree(output);
     668        return true;
     669    }
     670
     671    if (!ippdbPrintMetadatas(stdout, output, "relExp", !simple)) {
     672        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     673        psFree(output);
     674        return false;
     675    }
     676
     677    psFree(output);
     678
     679    return true;
     680}
     681static bool listrelexpMode(pxConfig *config)
     682{
     683    PS_ASSERT_PTR_NON_NULL(config, NULL);
     684
     685    psMetadata *where = psMetadataAlloc();
     686
     687    PXOPT_COPY_S64(config->args, where, "-relexp_id",   "relExp.relexp_id", "==");
     688    PXOPT_COPY_STR(config->args, where, "-release_name", "ippRelease.release_name", "LIKE");
     689    pxAddLabelSearchArgs(config, where, "-release_state","ippRelease.state", "==");
     690    PXOPT_COPY_STR(config->args, where, "-state",       "relExp.state", "==");
     691    PXOPT_COPY_STR(config->args, where, "-filter",      "rawExp.filter", "LIKE");
     692    PXOPT_COPY_TIME(config->args, where, "-dateobs_begin","rawExp.dateobs", ">=");
     693    PXOPT_COPY_TIME(config->args, where, "-dateobs_end", "rawExp.dateobs", "<=");
     694    PXOPT_COPY_F32(config->args, where, "-fwhm_min",    "camProcessedExp.fwhm_major", ">=");
     695    PXOPT_COPY_F32(config->args, where, "-fwhm_max",    "camProcessedExp.fwhm_major", "<=");
     696    PXOPT_COPY_STR(config->args, where, "-exp_name",    "rawExp.exp_name", "==");
     697    PXOPT_COPY_S64(config->args, where, "-exp_id",      "relExp.exp_id", "==");
     698    PXOPT_COPY_S64(config->args, where, "-chip_id",     "relExp.chip_id", "==");
     699    PXOPT_COPY_S64(config->args, where, "-cam_id",      "relExp.cam_id", "==");
     700    PXOPT_COPY_S64(config->args, where, "-warp_id",     "warpRun.warp_id", "==");
     701    PXOPT_COPY_STR(config->args, where, "-chip_data_group", "chipRun.data_group", "LIKE");
     702    PXOPT_COPY_STR(config->args, where, "-cam_data_group",  "camRun.data_group", "LIKE");
     703    PXOPT_COPY_STR(config->args, where, "-warp_data_group", "warpRun.data_group", "LIKE");
     704
     705    PXOPT_COPY_STR(config->args, where, "-surveyName",  "survey.surveyName", "LIKE");
    460706    PXOPT_COPY_S32(config->args, where, "-rel_id",      "relExp.rel_id", "==");
    461707
    … …  
    533779    return true;
    534780}
    535 
     781static bool definerelstackMode(pxConfig *config)
     782{
     783    PS_ASSERT_PTR_NON_NULL(config, NULL);
     784
     785    psMetadata *where = psMetadataAlloc();
     786
     787    bool includeSkycal = false;
     788
     789    PXOPT_COPY_S64(config->args, where, "-skycal_id",  "skycalRun.skycal_id", "==");
     790    PXOPT_COPY_STR(config->args, where, "-skycal_label", "skycalRun.label", "==");
     791    PXOPT_COPY_STR(config->args, where, "-skycal_data_group", "skycalRun.data_group", "==");
     792    if (psListLength(where->list)) {
     793        includeSkycal = true;
     794    }
     795
     796    PXOPT_COPY_STR(config->args, where, "-label",      "stackRun.label", "==");
     797    PXOPT_COPY_STR(config->args, where, "-data_group", "stackRun.data_group", "==");
     798    PXOPT_COPY_S64(config->args, where, "-stack_id",   "stackRun.stack_id", "==");
     799
     800    // Insure that at least one of the skycalRun selectors is supplied
     801    if (!psListLength(where->list)) {
     802        psFree(where);
     803        psError(PXTOOLS_ERR_CONFIG, false, "at least one of -label, -data_group, or -skycal_id is required");
     804        return false;
     805    }
     806
     807    // PXOPT_COPY_STR(config->args, where, "-tess_id",    "stackRun.tess_id", "==");
     808    // PXOPT_COPY_STR(config->args, where, "-skycell_id", "stackRun.skycell_id", "==");
     809
     810    // insure that at least one of these is supplied to select the release
     811    PXOPT_LOOKUP_S64(rel_id, config->args,      "-rel_id", false, false);
     812    PXOPT_LOOKUP_STR(release_name, config->args, "-release_name", false, false);
     813    if (!rel_id && !release_name) {
     814        psError(PXTOOLS_ERR_CONFIG, true, "either -rel_id or -release_name is required");
     815        return false;
     816    }
     817
     818    // limit query to the target release. (Note: this will select nothing if release_name and rel_id don't match)
     819    // note: we add these after above to insure that search args are supplied
     820    PXOPT_COPY_STR(config->args, where, "-release_name", "ippRelease.release_name", "==");
     821    PXOPT_COPY_S32(config->args, where, "-rel_id", "ippRelease.rel_id", "==");
     822
     823
     824    PXOPT_LOOKUP_STR(state, config->args,     "-set_state", true, false);
     825    PXOPT_LOOKUP_STR(stack_type, config->args,"-set_stack_type", true, false);
     826    PXOPT_LOOKUP_U32(flags, config->args,     "-set_flags", false, false);
     827    PXOPT_LOOKUP_F32(zpt_obs, config->args,   "-set_zpt_obs", false, false);
     828    PXOPT_LOOKUP_F32(zpt_stdev, config->args, "-set_zpt_stdev", false, false);
     829    PXOPT_LOOKUP_STR(path_base, config->args, "-set_path_base", false, false);
     830    PXOPT_LOOKUP_S16(fault, config->args,     "-set_fault", false, false);
     831
     832    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
     833    PXOPT_LOOKUP_BOOL(simple, config->args,  "-simple", false);
     834
     835    // find the parameters of all the exposures that we want to add to the release
     836    psString query;
     837   
     838    if (includeSkycal) {
     839        query = pxDataGet("releasetool_definerelstack_with_skycal.sql");
     840    } else {
     841        query = pxDataGet("releasetool_definerelstack.sql");
     842    }
     843    if (!query) {
     844        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     845        psFree(where);
     846        return false;
     847    }
     848
     849    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     850    psStringAppend(&query, " AND %s", whereClause);
     851    psFree(whereClause);
     852
     853    psFree(where);
     854
     855    if (!p_psDBRunQuery(config->dbh, query)) {
     856        psError(PS_ERR_UNKNOWN, false, "database error");
     857        psFree(query);
     858        return false;
     859    }
     860    psFree(query);
     861
     862    psArray *output = p_psDBFetchResult(config->dbh);
     863    if (!output) {
     864        psError(PS_ERR_UNKNOWN, false, "database error");
     865        return false;
     866    }
     867    if (!psArrayLength(output)) {
     868        psTrace("releasetool", PS_LOG_INFO, "no rows found");
     869        psFree(output);
     870        return true;
     871    }
     872
     873    if (pretend) {
     874        // negative simple so the default is true
     875        if (!ippdbPrintMetadatas(stdout, output, "relstack", !simple)) {
     876            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     877            psFree(output);
     878            return false;
     879        }
     880        psFree(output);
     881        return true;
     882    }
     883
     884    if (!psDBTransaction(config->dbh)) {
     885        psError(PS_ERR_UNKNOWN, false, "database error");
     886        psFree(output);
     887        return false;
     888    }
     889
     890    psTime *now = psTimeGetNow(PS_TIME_TAI);
     891    // loop over our list of  exposures
     892    for (long i = 0; i < psArrayLength(output); i++) {
     893        psMetadata *md = output->data[i];
     894
     895        bool status = true;
     896        psS32 rel_id = psMetadataLookupS32(&status, md, "rel_id");
     897        psS64 stack_id = psMetadataLookupS64(&status, md, "stack_id");
     898        psS64 skycal_id = psMetadataLookupS64(&status, md, "skycal_id");
     899        psString skycell_id = psMetadataLookupStr(&status, md, "skycell_id");
     900        psString tess_id = psMetadataLookupStr(&status, md, "tess_id");
     901        psString filter = psMetadataLookupStr(&status, md, "filter");
     902
     903        // use skycal zero point measurement if not supplied with arguments
     904        psF32 sc_zpt_obs = psMetadataLookupF32(&status, md, "zpt_obs");
     905        psF32 sc_zpt_stdev = psMetadataLookupF32(&status, md, "zpt_stdev");
     906        psF32 stack_mjd_obs = psMetadataLookupF32(&status, md, "mjd_obs");
     907
     908        psU32 mjd_obs = 0;
     909        if (!strcmp(stack_type, "nightly")) {
     910            // only for nightly stacks do we set mjd_obs to a non zero value
     911            // We use integer day because this is part of the key that is used
     912            // to make sure entries are unique
     913            //      KEY (rel_id, tess_id, skycell_id, filter, mjd_obs),
     914            // 1 entry per release, skycell, filter and mjd_obs.
     915            // mjd_obs is zero for deep and reference stacks
     916            mjd_obs = (psU32) stack_mjd_obs;
     917        }
     918
     919        if (!relStackInsert(config->dbh,
     920            0,          // relstack_id (auto increment)
     921            rel_id,
     922            stack_id,
     923            skycal_id,
     924            skycell_id,
     925            tess_id,
     926            filter,
     927            state,
     928            flags,
     929            stack_type,
     930            isfinite(zpt_obs)   ? zpt_obs   : sc_zpt_obs,
     931            isfinite(zpt_stdev) ? zpt_stdev : sc_zpt_stdev,
     932            mjd_obs,
     933            path_base,
     934            fault,
     935            now,       // registered
     936            now        // time_stamp
     937        )) {
     938            if (!psDBRollback(config->dbh)) {
     939                psError(PS_ERR_UNKNOWN, false, "database error");
     940            }
     941            psError(PS_ERR_UNKNOWN, false,
     942                    "failed to trying to insert relStack for stack_id %" PRId64, stack_id);
     943            psFree(output);
     944            psFree(now);
     945            return false;
     946        }
     947    }
     948    psFree(output);
     949
     950    if (!psDBCommit(config->dbh)) {
     951        psError(PS_ERR_UNKNOWN, false, "database error");
     952        return false;
     953    }
     954
     955    return true;
     956}
     957
     958static bool updaterelstackMode(pxConfig *config)
     959{
     960    psError(PS_ERR_UNKNOWN, true, "not yet implemented");
     961    return false;
     962}
     963
     964static bool listrelstackMode(pxConfig *config)
     965{
     966    PS_ASSERT_PTR_NON_NULL(config, NULL);
     967
     968    psMetadata *where = psMetadataAlloc();
     969
     970    PXOPT_COPY_STR(config->args, where, "-release_name", "ippRelease.release_name", "LIKE");
     971    pxAddLabelSearchArgs(config, where, "-release_state","ippRelease.state", "==");
     972    PXOPT_COPY_STR(config->args, where, "-state",       "relExp.state", "==");
     973    PXOPT_COPY_STR(config->args, where, "-filter",      "rawExp.filter", "LIKE");
     974    PXOPT_COPY_TIME(config->args, where, "-dateobs_begin","rawExp.dateobs", ">=");
     975    PXOPT_COPY_TIME(config->args, where, "-dateobs_end", "rawExp.dateobs", "<=");
     976    PXOPT_COPY_F32(config->args, where, "-fwhm_min",    "skycalResult.fwhm_major", ">=");
     977    PXOPT_COPY_F32(config->args, where, "-fwhm_max",    "skycalresult.fwhm_major", "<=");
     978    PXOPT_COPY_STR(config->args, where, "-exp_name",    "rawExp.exp_ame", "==");
     979    PXOPT_COPY_S64(config->args, where, "-exp_id",      "relExp.exp_id", "==");
     980    PXOPT_COPY_S64(config->args, where, "-chip_id",     "relExp.chip_id", "==");
     981    PXOPT_COPY_S64(config->args, where, "-cam_id",      "relExp.cam_id", "==");
     982    PXOPT_COPY_S64(config->args, where, "-warp_id",     "warpRun.warp_id", "==");
     983    PXOPT_COPY_STR(config->args, where, "-chip_data_group", "chipRun.data_group", "LIKE");
     984    PXOPT_COPY_STR(config->args, where, "-cam_data_group",  "camRun.data_group", "LIKE");
     985    PXOPT_COPY_STR(config->args, where, "-warp_data_group", "warpRun.data_group", "LIKE");
     986
     987    PXOPT_COPY_STR(config->args, where, "-surveyName",  "survey.surveyName", "LIKE");
     988    PXOPT_COPY_S32(config->args, where, "-rel_id",      "relExp.rel_id", "==");
     989
     990    PXOPT_LOOKUP_BOOL(priority_order, config->args, "-priority_order", false);
     991
     992    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     993    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     994
     995    psString query = pxDataGet("releasetool_listrelexp.sql");
     996    if (!query) {
     997        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     998        return false;
     999    }
     1000
     1001    psString where2 = NULL;
     1002    if (!pxspaceAddWhere(config, &where2, "rawExp")) {
     1003        psError(psErrorCodeLast(), false, "pxspaceAddWhere failed");
     1004        return false;
     1005    }
     1006
     1007    if (psListLength(where->list)) {
     1008        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1009        psStringAppend(&query, "\nWHERE %s", whereClause);
     1010        psFree(whereClause);
     1011    } else if (where2) {
     1012        psStringAppend(&query, "\nWHERE ");
     1013    } else {
     1014        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required\n");
     1015        psFree(where);
     1016        return false;
     1017    }
     1018
     1019    if (where2) {
     1020        psStringAppend(&query, "\n%s", where2);
     1021        psFree(where2);
     1022    }
     1023
     1024    if (priority_order) {
     1025        psStringAppend(&query, "\nAND priority > 0 order by exp_id, priority");
     1026    }
     1027
     1028    if (limit) {
     1029        psString limitString = psDBGenerateLimitSQL(limit);
     1030        psStringAppend(&query, " %s", limitString);
     1031        psFree(limitString);
     1032    }
     1033
     1034    if (!p_psDBRunQuery(config->dbh, query)) {
     1035        psError(PS_ERR_UNKNOWN, false, "database error");
     1036        psFree(query);
     1037        return false;
     1038    }
     1039    psFree(query);
     1040
     1041    psArray *output = p_psDBFetchResult(config->dbh);
     1042    if (!output) {
     1043        psError(PS_ERR_UNKNOWN, false, "database error");
     1044        return false;
     1045    }
     1046
     1047    if (!psArrayLength(output)) {
     1048        psTrace("releasetool", PS_LOG_INFO, "no rows found");
     1049        psFree(output);
     1050        return true;
     1051    }
     1052
     1053    if (!ippdbPrintMetadatas(stdout, output, "relExp", !simple)) {
     1054        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1055        psFree(output);
     1056        return false;
     1057    }
     1058
     1059    psFree(output);
     1060
     1061    return true;
     1062}
     1063
     1064static bool definerelgroupMode(pxConfig *config)
     1065{
     1066    PS_ASSERT_PTR_NON_NULL(config, NULL);
     1067
     1068    PXOPT_LOOKUP_STR(group_type, config->args, "-set_group_type", true, false);
     1069    PXOPT_LOOKUP_STR(group_name, config->args, "-set_group_name", false, false);
     1070    PXOPT_LOOKUP_STR(label, config->args,     "-set_label", true, false);
     1071
     1072    PXOPT_LOOKUP_STR(state, config->args,     "-set_state", false, false);
     1073    PXOPT_LOOKUP_STR(exp_list_path, config->args, "-set_exp_list_path", false, false);
     1074    PXOPT_LOOKUP_S16(fault, config->args,     "-set_fault", false, false);
     1075
     1076    psString query = NULL;
     1077
     1078    psMetadata *where = psMetadataAlloc();
     1079
     1080    // select sql and paramters based on group type
     1081    bool type_lap = false;
     1082    if (!strcmp(group_type, "lap")) {
     1083        type_lap = true;
     1084        if (group_name) {
     1085            psError(PXTOOLS_ERR_CONFIG, true, "group_name is not allowed with group_type lap");
     1086            psFree(where);
     1087            return false;
     1088        }
     1089        PXOPT_COPY_S64(config->args, where, "-select_seq_id", "lapRun.seq_id", "==");
     1090        PXOPT_COPY_S64(config->args, where, "-select_lap_id", "lapRun.lap_id", "==");
     1091        query = pxDataGet("releasetool_definerelgroup_select_lap.sql");
     1092        if (!query) {
     1093            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1094            psFree(where);
     1095            return false;
     1096        }
     1097    } else {
     1098        if (!strcmp(group_type, "date")) {
     1099            // group_type ok
     1100        } else if (!strcmp(group_type, "data_group")) {
     1101            // group_type ok
     1102        } else {
     1103            psError(PXTOOLS_ERR_CONFIG, true, "%s is not valid group_type", group_type);
     1104            return false;
     1105        }
     1106        if (!group_name) {
     1107            psError(PXTOOLS_ERR_CONFIG, true, "group_name is required allowed with group_type %s", group_type);
     1108            psFree(where);
     1109            return false;
     1110        }
     1111        pxAddLabelSearchArgs (config, where, "-select_data_group", "camRun.data_group", "==");
     1112        query = pxDataGet("releasetool_definerelgroup_select_data_group.sql");
     1113        if (!query) {
     1114            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1115            psFree(where);
     1116            return false;
     1117        }
     1118    }
     1119
     1120    // Insure that at least one of the exposure selectors is supplied
     1121    if (!psListLength(where->list)) {
     1122        psFree(where);
     1123        psError(PXTOOLS_ERR_CONFIG, false, "search arguments are required");
     1124        return false;
     1125    }
     1126
     1127    // insure that at least one of these is supplied to select the release
     1128    PXOPT_LOOKUP_S64(rel_id, config->args,      "-rel_id", false, false);
     1129    PXOPT_LOOKUP_STR(release_name, config->args, "-release_name", false, false);
     1130    if (!rel_id && !release_name) {
     1131        psError(PXTOOLS_ERR_CONFIG, true, "either -rel_id or -release_name is required");
     1132        return false;
     1133    }
     1134
     1135    // limit query to the target release. (Note: this will select nothing if release_name and rel_id don't match)
     1136    // note: we add these after above to insure that search args are supplied
     1137    PXOPT_COPY_STR(config->args, where, "-release_name", "ippRelease.release_name", "==");
     1138    PXOPT_COPY_S32(config->args, where, "-rel_id", "ippRelease.rel_id", "==");
     1139
     1140    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
     1141    PXOPT_LOOKUP_BOOL(simple, config->args,  "-simple", false);
     1142
     1143    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1144    psStringAppend(&query, " AND %s", whereClause);
     1145    psFree(whereClause);
     1146
     1147    psFree(where);
     1148
     1149    if (!type_lap) {
     1150        psStringAppend(&query, "\nHAVING COUNT(exp_id) > 0");
     1151    }
     1152
     1153    if (!p_psDBRunQuery(config->dbh, query)) {
     1154        psError(PS_ERR_UNKNOWN, false, "database error");
     1155        psFree(query);
     1156        return false;
     1157    }
     1158    psFree(query);
     1159
     1160    psArray *output = p_psDBFetchResult(config->dbh);
     1161    if (!output) {
     1162        psError(PS_ERR_UNKNOWN, false, "database error");
     1163        return false;
     1164    }
     1165    if (!psArrayLength(output)) {
     1166        psTrace("releasetool", PS_LOG_INFO, "no rows found");
     1167        psFree(output);
     1168        return true;
     1169    }
     1170
     1171    if (pretend) {
     1172        // negative simple so the default is true
     1173        if (!ippdbPrintMetadatas(stdout, output, "relGroupToQueue", !simple)) {
     1174            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1175            psFree(output);
     1176            return false;
     1177        }
     1178        psFree(output);
     1179        return true;
     1180    }
     1181
     1182    if (!psDBTransaction(config->dbh)) {
     1183        psError(PS_ERR_UNKNOWN, false, "database error");
     1184        psFree(output);
     1185        return false;
     1186    }
     1187
     1188    psTime *now = psTimeGetNow(PS_TIME_TAI);
     1189    // loop over our list of  exposures
     1190    for (long i = 0; i < psArrayLength(output); i++) {
     1191        psMetadata *md = output->data[i];
     1192
     1193        bool status = true;
     1194        psS32 rel_id = psMetadataLookupS32(&status, md, "rel_id");
     1195        psS64 lap_id = 0;
     1196        if (type_lap) {
     1197            lap_id = psMetadataLookupS64(&status, md, "lap_id");
     1198        }
     1199
     1200        if (!relGroupInsert(config->dbh,
     1201            0,          // group_id (auto increment)
     1202            rel_id,
     1203            group_type,
     1204            lap_id,
     1205            group_name,
     1206            "reg",      // state
     1207            label,
     1208            exp_list_path,
     1209            fault,
     1210            now        // registered
     1211        )) {
     1212            if (!psDBRollback(config->dbh)) {
     1213                psError(PS_ERR_UNKNOWN, false, "database error");
     1214            }
     1215            psError(PS_ERR_UNKNOWN, false, "failed to trying to insert relGroup");
     1216            psFree(output);
     1217            psFree(now);
     1218            return false;
     1219        }
     1220        // Here's our new group_id
     1221        psS32 group_id = psDBLastInsertID(config->dbh);
     1222
     1223        psString query;
     1224        if (type_lap) {
     1225            query = pxDataGet("releasetool_definerelgroup_select_exp_lap.sql");
     1226            if (!query) {
     1227                psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1228                psFree(where);
     1229                return false;
     1230            }
     1231            psStringAppend(&query, " AND relExp.rel_id = %d AND lap_id = %" PRId64, rel_id, lap_id);
     1232        } else {
     1233            query = pxDataGet("releasetool_definerelgroup_select_exp_data_group.sql");
     1234            if (!query) {
     1235                psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1236                psFree(where);
     1237                return false;
     1238            }
     1239            psStringAppend(&query, " AND relExp.rel_id = %d", rel_id);
     1240
     1241            psMetadata *where = psMetadataAlloc();
     1242            pxAddLabelSearchArgs (config, where, "-select_data_group", "camRun.data_group", "==");
     1243            psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1244            psStringAppend(&query, " AND %s", whereClause);
     1245            psFree(whereClause);
     1246            psFree(where);
     1247        }
     1248
     1249        if (!p_psDBRunQuery(config->dbh, query)) {
     1250            psError(PS_ERR_UNKNOWN, false, "database error");
     1251            psFree(query);
     1252            psFree(output);
     1253            psFree(now);
     1254            if (!psDBRollback(config->dbh)) {
     1255                psError(PS_ERR_UNKNOWN, false, "database error");
     1256            }
     1257            return false;
     1258        }
     1259        psFree(query);
     1260
     1261        psArray *exposures = p_psDBFetchResult(config->dbh);
     1262        if (!exposures) {
     1263            psFree(now);
     1264            psFree(output);
     1265            psError(PS_ERR_UNKNOWN, false, "database error");
     1266            if (!psDBRollback(config->dbh)) {
     1267                psError(PS_ERR_UNKNOWN, false, "database error");
     1268            }
     1269            return false;
     1270        }
     1271        if (!psArrayLength(exposures)) {
     1272            psFree(now);
     1273            psFree(output);
     1274            psFree(exposures);
     1275            psError(PS_ERR_UNKNOWN, false, "no exposures found error");
     1276            if (!psDBRollback(config->dbh)) {
     1277                psError(PS_ERR_UNKNOWN, false, "database error");
     1278            }
     1279            return false;
     1280        }
     1281
     1282        // assign the relExps to this new group
     1283        char *updateQuery = "UPDATE relExp SET group_id = %d WHERE relexp_id = %" PRId64;
     1284        for (int j = 0; j < psArrayLength(exposures); j++) {
     1285            psMetadata *md = exposures->data[j];
     1286
     1287            bool status = true;
     1288            psS32 relexp_id = psMetadataLookupS32(&status, md, "relexp_id");
     1289            if (!p_psDBRunQueryF(config->dbh, updateQuery, group_id, relexp_id)) {
     1290                psError(PS_ERR_UNKNOWN, false, "database error");
     1291                psFree(now);
     1292                psFree(output);
     1293                psFree(exposures);
     1294
     1295                if (!psDBRollback(config->dbh)) {
     1296                    psError(PS_ERR_UNKNOWN, false, "database error");
     1297                }
     1298                return false;
     1299            }
     1300        }
     1301        psFree(exposures);
     1302
     1303        // set state of relGroup to 'new'
     1304        if (!p_psDBRunQueryF(config->dbh, "UPDATE relGroup set state = 'new' WHERE group_id = %d", group_id)) {
     1305            psError(PS_ERR_UNKNOWN, false, "database error");
     1306            psFree(now);
     1307            psFree(output);
     1308            if (!psDBRollback(config->dbh)) {
     1309                psError(PS_ERR_UNKNOWN, false, "database error");
     1310            }
     1311            return false;
     1312        }
     1313    }
     1314    psFree(output);
     1315    psFree(now);
     1316
     1317    if (!psDBCommit(config->dbh)) {
     1318        psError(PS_ERR_UNKNOWN, false, "database error");
     1319        return false;
     1320    }
     1321
     1322    return true;
     1323}
     1324
     1325static bool updaterelgroupMode(pxConfig *config)
     1326{
     1327    psError(PS_ERR_UNKNOWN, true, "not yet implemented");
     1328    return false;
     1329}
     1330
     1331static bool pendingrelgroupMode(pxConfig *config)
     1332{
     1333    PS_ASSERT_PTR_NON_NULL(config, NULL);
     1334
     1335    psMetadata *where = psMetadataAlloc();
     1336
     1337    pxAddLabelSearchArgs (config, where, "-label",      "relGroup.label", "==");
     1338    PXOPT_COPY_S32(config->args, where, "-group_id",    "relGroup.group_id", "==");
     1339    PXOPT_COPY_S32(config->args, where, "-rel_id",      "relExp.rel_id", "==");
     1340    PXOPT_COPY_STR(config->args, where, "-release_name", "ippRelease.release_name", "LIKE");
     1341
     1342    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1343    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1344
     1345    psString query = pxDataGet("releasetool_pendingrelgroup.sql");
     1346    if (!query) {
     1347        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1348        return false;
     1349    }
     1350
     1351    if (psListLength(where->list)) {
     1352        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1353        psStringAppend(&query, "\nAND %s", whereClause);
     1354        psFree(whereClause);
     1355    } else {
     1356        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required\n");
     1357        psFree(where);
     1358        return false;
     1359    }
     1360
     1361    if (limit) {
     1362        psString limitString = psDBGenerateLimitSQL(limit);
     1363        psStringAppend(&query, " %s", limitString);
     1364        psFree(limitString);
     1365    }
     1366
     1367    if (!p_psDBRunQuery(config->dbh, query)) {
     1368        psError(PS_ERR_UNKNOWN, false, "database error");
     1369        psFree(query);
     1370        return false;
     1371    }
     1372    psFree(query);
     1373
     1374    psArray *output = p_psDBFetchResult(config->dbh);
     1375    if (!output) {
     1376        psError(PS_ERR_UNKNOWN, false, "database error");
     1377        return false;
     1378    }
     1379
     1380    if (!psArrayLength(output)) {
     1381        psTrace("releasetool", PS_LOG_INFO, "no rows found");
     1382        psFree(output);
     1383        return true;
     1384    }
     1385
     1386    if (!ippdbPrintMetadatas(stdout, output, "pending_relGroup", !simple)) {
     1387        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1388        psFree(output);
     1389        return false;
     1390    }
     1391
     1392    psFree(output);
     1393
     1394    return true;
     1395}
     1396
     1397static bool listrelgroupMode(pxConfig *config)
     1398{
     1399    return false;
     1400#ifdef notdef
     1401    PS_ASSERT_PTR_NON_NULL(config, NULL);
     1402
     1403    psMetadata *where = psMetadataAlloc();
     1404
     1405    PXOPT_COPY_STR(config->args, where, "-release_name", "ippRelease.release_name", "LIKE");
     1406    pxAddLabelSearchArgs(config, where, "-release_state","ippRelease.state", "==");
     1407    PXOPT_COPY_STR(config->args, where, "-state",       "relExp.state", "==");
     1408    PXOPT_COPY_STR(config->args, where, "-filter",      "rawExp.filter", "LIKE");
     1409    PXOPT_COPY_TIME(config->args, where, "-dateobs_begin","rawExp.dateobs", ">=");
     1410    PXOPT_COPY_TIME(config->args, where, "-dateobs_end", "rawExp.dateobs", "<=");
     1411    PXOPT_COPY_F32(config->args, where, "-fwhm_min",    "skycalResult.fwhm_major", ">=");
     1412    PXOPT_COPY_F32(config->args, where, "-fwhm_max",    "skycalresult.fwhm_major", "<=");
     1413    PXOPT_COPY_STR(config->args, where, "-exp_name",    "rawExp.exp_ame", "==");
     1414    PXOPT_COPY_S64(config->args, where, "-exp_id",      "relExp.exp_id", "==");
     1415    PXOPT_COPY_S64(config->args, where, "-chip_id",     "relExp.chip_id", "==");
     1416    PXOPT_COPY_S64(config->args, where, "-cam_id",      "relExp.cam_id", "==");
     1417    PXOPT_COPY_S64(config->args, where, "-warp_id",     "warpRun.warp_id", "==");
     1418    PXOPT_COPY_STR(config->args, where, "-chip_data_group", "chipRun.data_group", "LIKE");
     1419    PXOPT_COPY_STR(config->args, where, "-cam_data_group",  "camRun.data_group", "LIKE");
     1420    PXOPT_COPY_STR(config->args, where, "-warp_data_group", "warpRun.data_group", "LIKE");
     1421
     1422    PXOPT_COPY_STR(config->args, where, "-surveyName",  "survey.surveyName", "LIKE");
     1423    PXOPT_COPY_S32(config->args, where, "-rel_id",      "relExp.rel_id", "==");
     1424
     1425    PXOPT_LOOKUP_BOOL(priority_order, config->args, "-priority_order", false);
     1426
     1427    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1428    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1429
     1430    psString query = pxDataGet("releasetool_listrelexp.sql");
     1431    if (!query) {
     1432        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1433        return false;
     1434    }
     1435
     1436    psString where2 = NULL;
     1437    if (!pxspaceAddWhere(config, &where2, "rawExp")) {
     1438        psError(psErrorCodeLast(), false, "pxspaceAddWhere failed");
     1439        return false;
     1440    }
     1441
     1442    if (psListLength(where->list)) {
     1443        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1444        psStringAppend(&query, "\nWHERE %s", whereClause);
     1445        psFree(whereClause);
     1446    } else if (where2) {
     1447        psStringAppend(&query, "\nWHERE ");
     1448    } else {
     1449        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required\n");
     1450        psFree(where);
     1451        return false;
     1452    }
     1453
     1454    if (where2) {
     1455        psStringAppend(&query, "\n%s", where2);
     1456        psFree(where2);
     1457    }
     1458
     1459    if (priority_order) {
     1460        psStringAppend(&query, "\nAND priority > 0 order by exp_id, priority");
     1461    }
     1462
     1463    if (limit) {
     1464        psString limitString = psDBGenerateLimitSQL(limit);
     1465        psStringAppend(&query, " %s", limitString);
     1466        psFree(limitString);
     1467    }
     1468
     1469    if (!p_psDBRunQuery(config->dbh, query)) {
     1470        psError(PS_ERR_UNKNOWN, false, "database error");
     1471        psFree(query);
     1472        return false;
     1473    }
     1474    psFree(query);
     1475
     1476    psArray *output = p_psDBFetchResult(config->dbh);
     1477    if (!output) {
     1478        psError(PS_ERR_UNKNOWN, false, "database error");
     1479        return false;
     1480    }
     1481
     1482    if (!psArrayLength(output)) {
     1483        psTrace("releasetool", PS_LOG_INFO, "no rows found");
     1484        psFree(output);
     1485        return true;
     1486    }
     1487
     1488    if (!ippdbPrintMetadatas(stdout, output, "relExp", !simple)) {
     1489        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1490        psFree(output);
     1491        return false;
     1492    }
     1493
     1494    psFree(output);
     1495
     1496    return true;
     1497#endif //notdef
     1498}
     1499

  • branches/eam_branches/ipp-20130207/ippTools/src/releasetool.h

    r34908 r35236  
    3232    RELEASETOOL_MODE_DEFINERELEXP,
    3333    RELEASETOOL_MODE_UPDATERELEXP,
     34    RELEASETOOL_MODE_TOCALIBEXP,
    3435    RELEASETOOL_MODE_LISTRELEXP,
     36    RELEASETOOL_MODE_DEFINERELSTACK,
     37    RELEASETOOL_MODE_UPDATERELSTACK,
     38    RELEASETOOL_MODE_TOCALIBSTACK,
     39    RELEASETOOL_MODE_LISTRELSTACK,
     40    RELEASETOOL_MODE_DEFINERELGROUP,
     41    RELEASETOOL_MODE_PENDINGRELGROUP,
     42    RELEASETOOL_MODE_UPDATERELGROUP,
     43    RELEASETOOL_MODE_LISTRELGROUP,
    3544} releasetoolMode;
    3645

  • branches/eam_branches/ipp-20130207/ippTools/src/releasetoolConfig.c

    r35048 r35236  
    6060    psMetadata *definereleaseArgs = psMetadataAlloc();
    6161    psMetadataAddS32(definereleaseArgs, PS_LIST_TAIL, "-set_surveyID", 0,      "define survey ID (required)", 0);
    62     psMetadataAddStr(definereleaseArgs, PS_LIST_TAIL, "-set_releaseName", 0,   "define release name (required)", NULL);
     62    psMetadataAddStr(definereleaseArgs, PS_LIST_TAIL, "-set_release_name", 0,   "define release name (required)", NULL);
    6363    psMetadataAddS32(definereleaseArgs, PS_LIST_TAIL, "-set_dataRelease", 0,   "define dataRelease", -1);
    6464    psMetadataAddStr(definereleaseArgs, PS_LIST_TAIL, "-set_release_state", 0, "define release state", NULL);
    65     psMetadataAddS32(definereleaseArgs, PS_LIST_TAIL, "-set_priority", 0,      "define release priority", -1);
     65    psMetadataAddS32(definereleaseArgs, PS_LIST_TAIL, "-set_priority", 0,      "define release priority", 0);
    6666
    6767    // -uptdaterelease
    6868    psMetadata *updatereleaseArgs = psMetadataAlloc();
    6969
    70     // releaseName and/or rel_id is required. This is handled in updatereleaseMode
    71     psMetadataAddStr(updatereleaseArgs, PS_LIST_TAIL, "-releaseName", 0,        "select by release name", NULL);
     70    // release_name and/or rel_id is required. This is handled in updatereleaseMode
     71    psMetadataAddStr(updatereleaseArgs, PS_LIST_TAIL, "-release_name", 0,        "select by release name", NULL);
    7272    psMetadataAddS32(updatereleaseArgs, PS_LIST_TAIL, "-rel_id", 0,             "select by release ID", 0);
    7373
    74     // Only support changing state and priority for now
    75     psMetadataAddStr(updatereleaseArgs, PS_LIST_TAIL, "-set_release_state", 0,  "define new release state(required)", NULL);
     74    psMetadataAddStr(updatereleaseArgs, PS_LIST_TAIL, "-set_release_state", 0,  "define new release state", NULL);
    7675    psMetadataAddS32(updatereleaseArgs, PS_LIST_TAIL, "-set_priority", 0,       "define new release priority", 0);
    77 
    78 //    psMetadataAddS32(updatereleaseArgs, PS_LIST_TAIL, "-set_surveyID", 0,       "define surveyID (required)", 0);
    79 //    psMetadataAddStr(updatereleaseArgs, PS_LIST_TAIL, "-set_releaseName", 0,    "define release name (required)", NULL);
    80 //    psMetadataAddS32(updatereleaseArgs, PS_LIST_TAIL, "-set_dataRelease", 0,    "define dataRelease", -1);
     76    psMetadataAddS32(updatereleaseArgs, PS_LIST_TAIL, "-set_dataRelease", 0,    "define data release", -1);
    8177
    8278
    … …  
    8480    psMetadata *listreleaseArgs = psMetadataAlloc();
    8581    psMetadataAddStr(listreleaseArgs,  PS_LIST_TAIL, "-surveyName", 0,  "select by survey name (LIKE comparision)", NULL);
    86     psMetadataAddStr(listreleaseArgs,  PS_LIST_TAIL, "-releaseName", 0, "select by release name (LIKE comparision)", NULL);
     82    psMetadataAddStr(listreleaseArgs,  PS_LIST_TAIL, "-release_name", 0, "select by release name (LIKE comparision)", NULL);
    8783    psMetadataAddStr(listreleaseArgs,  PS_LIST_TAIL, "-release_state",  0, "select by release state", NULL);
    8884    psMetadataAddS32(listreleaseArgs, PS_LIST_TAIL,  "-rel_id", 0,      "select by release ID", 0);
    … …  
    9591
    9692        // set the target release
    97     psMetadataAddStr(definerelexpArgs,  PS_LIST_TAIL, "-releaseName", 0, "define release name", NULL);
     93    psMetadataAddStr(definerelexpArgs,  PS_LIST_TAIL, "-release_name", 0, "define release name", NULL);
    9894    psMetadataAddS32(definerelexpArgs, PS_LIST_TAIL,  "-rel_id", 0,      "define release ID", 0);
    9995
    … …  
    109105        // parameters of the relExp
    110106    psMetadataAddStr(definerelexpArgs,  PS_LIST_TAIL, "-set_state", 0,      "define state (required)", NULL);
     107    psMetadataAddU32(definerelexpArgs,  PS_LIST_TAIL, "-set_flags", 0,      "define flags", 0);
     108    psMetadataAddF32(definerelexpArgs,  PS_LIST_TAIL, "-set_zpt_obs", 0,    "define zero point", NAN);
     109    psMetadataAddF32(definerelexpArgs,  PS_LIST_TAIL, "-set_zpt_stdev", 0,  "define zero point stdev", NAN);
    111110    psMetadataAddStr(definerelexpArgs,  PS_LIST_TAIL, "-set_path_base", 0,  "define state", NULL);
    112     psMetadataAddU32(definerelexpArgs,  PS_LIST_TAIL, "-set_flags", 0,      "define flags", 0);
    113 
    114     psMetadataAddBool(definerelexpArgs, PS_LIST_TAIL, "-pretend",  0, "do not actual modify the database", false);
    115     psMetadataAddBool(definerelexpArgs, PS_LIST_TAIL, "-simple",  0, "use the simpel output format", false);
    116 
    117 
     111    psMetadataAddS16(definerelexpArgs,  PS_LIST_TAIL, "-set_fault", 0,      "define fault", 0);
     112
     113    psMetadataAddBool(definerelexpArgs, PS_LIST_TAIL, "-pretend",  0, "do not actually modify the database", false);
     114    psMetadataAddBool(definerelexpArgs, PS_LIST_TAIL, "-simple",  0, "use the simple output format", false);
    118115
    119116    // -updaterelexp
    120117    psMetadata *updaterelexpArgs = psMetadataAlloc();
    121     psMetadataAddStr(updaterelexpArgs,  PS_LIST_TAIL, "-releaseName", 0, "select by release name (LIKE comparision)", NULL);
     118    psMetadataAddS64(updaterelexpArgs, PS_LIST_TAIL,  "-relexp_id", 0,   "select by released exposure ID", 0);
     119    psMetadataAddS64(updaterelexpArgs, PS_LIST_TAIL,  "-exp_id", 0,      "select by exposure ID", 0);
     120    psMetadataAddStr(updaterelexpArgs,  PS_LIST_TAIL, "-exp_name", 0,    "select by exposure name", NULL);
     121    psMetadataAddS32(updaterelexpArgs, PS_LIST_TAIL,  "-rel_id", 0,      "select by release ID", 0);
     122    psMetadataAddStr(updaterelexpArgs,  PS_LIST_TAIL, "-release_name", 0, "select by release name (LIKE comparision)", NULL);
     123
     124    psMetadataAddStr(updaterelexpArgs,  PS_LIST_TAIL, "-set_state", 0,      "define new state)", NULL);
     125    psMetadataAddU32(updaterelexpArgs,  PS_LIST_TAIL, "-set_flags", 0,      "define new flags", 0);
     126    psMetadataAddF32(updaterelexpArgs,  PS_LIST_TAIL, "-set_zpt_obs", 0,    "define new zero point", NAN);
     127    psMetadataAddF32(updaterelexpArgs,  PS_LIST_TAIL, "-set_zpt_stdev", 0,  "define new zero point stdev", NAN);
     128    psMetadataAddStr(updaterelexpArgs,  PS_LIST_TAIL, "-set_path_base", 0,  "define path_base", NULL);
     129    psMetadataAddS16(updaterelexpArgs,  PS_LIST_TAIL, "-set_fault", 0,      "define new fault", 0);
     130    psMetadataAddBool(updaterelexpArgs, PS_LIST_TAIL, "-clearfault",  0,   "set fault to zero", false);
     131
     132    // -tocalibexp
     133    psMetadata *tocalibexpArgs = psMetadataAlloc();
     134    psMetadataAddS64(tocalibexpArgs, PS_LIST_TAIL,  "-relexp_id", 0,   "select by released exposure ID", 0);
     135    psMetadataAddStr(tocalibexpArgs,  PS_LIST_TAIL, "-release_name", 0, "select by release name (LIKE comparision)", NULL);
     136
     137    psMetadataAddU64(tocalibexpArgs,  PS_LIST_TAIL, "-limit",       0, "limit result set to N items", 0);
     138    psMetadataAddBool(tocalibexpArgs, PS_LIST_TAIL, "-simple",      0, "use the simple output format", false);
    122139
    123140    // -listrelexp
    124141    psMetadata *listrelexpArgs = psMetadataAlloc();
    125     psMetadataAddStr(listrelexpArgs,  PS_LIST_TAIL, "-releaseName", 0,  "select by release name (LIKE comparision)", NULL);
     142    psMetadataAddS64(listrelexpArgs, PS_LIST_TAIL,  "-relexp_id", 0,   "select by released exposure ID", 0);
     143    psMetadataAddStr(listrelexpArgs,  PS_LIST_TAIL, "-release_name", 0, "select by release name (LIKE comparision)", NULL);
    126144    psMetadataAddStr(listrelexpArgs,  PS_LIST_TAIL, "-release_state", PS_META_DUPLICATE_OK, "select by release state", NULL);
    127145    psMetadataAddStr(listrelexpArgs,  PS_LIST_TAIL, "-state", 0,        "select by released exposure state", NULL);
    … …  
    155173    psMetadataAddBool(listrelexpArgs, PS_LIST_TAIL, "-simple",      0, "use the simple output format", false);
    156174
     175    // -definerelstack
     176    psMetadata *definerelstackArgs = psMetadataAlloc();
     177
     178        // set the target release
     179    psMetadataAddStr(definerelstackArgs,  PS_LIST_TAIL, "-release_name", 0, "define release name", NULL);
     180    psMetadataAddS32(definerelstackArgs, PS_LIST_TAIL,  "-rel_id", 0,      "define release ID", 0);
     181
     182        // select the processing
     183    psMetadataAddS64(definerelstackArgs, PS_LIST_TAIL,  "-stack_id", 0,    "select by stack ID", 0);
     184    psMetadataAddS64(definerelstackArgs, PS_LIST_TAIL,  "-skycal_id", 0,   "select by skycal ID", 0);
     185    psMetadataAddStr(definerelstackArgs,  PS_LIST_TAIL, "-label",  0,      "select by stackRun.label", NULL);
     186    psMetadataAddStr(definerelstackArgs,  PS_LIST_TAIL, "-data_group", 0,  "select by stackRun.data_group", NULL);
     187    psMetadataAddStr(definerelstackArgs,  PS_LIST_TAIL, "-skycal_label",  0, "select by skycalRun.label", NULL);
     188    psMetadataAddStr(definerelstackArgs,  PS_LIST_TAIL, "-skycal_data_group", 0,  "select by skycalRun.data_group", NULL);
     189
     190        // parameters of the relStack
     191    psMetadataAddStr(definerelstackArgs,  PS_LIST_TAIL, "-set_state", 0,      "define state (required)", NULL);
     192    psMetadataAddU32(definerelstackArgs,  PS_LIST_TAIL, "-set_flags", 0,      "define flags", 0);
     193    psMetadataAddStr(definerelstackArgs,  PS_LIST_TAIL, "-set_stack_type", 0, "define stack type (required)", NULL);
     194    psMetadataAddF32(definerelstackArgs,  PS_LIST_TAIL, "-set_zpt_obs", 0,    "define zero point", NAN);
     195    psMetadataAddF32(definerelstackArgs,  PS_LIST_TAIL, "-set_zpt_stdev", 0,  "define zero point stdev", NAN);
     196    psMetadataAddF32(definerelstackArgs,  PS_LIST_TAIL, "-set_fwhm_major", 0, "define fwhm_major", NAN);
     197    psMetadataAddStr(definerelstackArgs,  PS_LIST_TAIL, "-set_path_base", 0,  "define state (required)", NULL);
     198    psMetadataAddS16(definerelstackArgs,  PS_LIST_TAIL, "-set_fault", 0,      "define fault", 0);
     199
     200    psMetadataAddBool(definerelstackArgs, PS_LIST_TAIL, "-pretend",  0, "do not actually modify the database", false);
     201    psMetadataAddBool(definerelstackArgs, PS_LIST_TAIL, "-simple",  0, "use the simple output format", false);
     202
     203    // -definerelgroup
     204    psMetadata *definerelgroupArgs = psMetadataAlloc();
     205
     206        // set the target release
     207    psMetadataAddStr(definerelgroupArgs, PS_LIST_TAIL, "-release_name", 0, "define release name", NULL);
     208    psMetadataAddS32(definerelgroupArgs, PS_LIST_TAIL, "-rel_id", 0,      "define release ID", 0);
     209
     210        // select the members of the group
     211    psMetadataAddS64(definerelgroupArgs, PS_LIST_TAIL, "-select_seq_id", 0,  "select by LAP sequence ID", 0);
     212    psMetadataAddS64(definerelgroupArgs, PS_LIST_TAIL, "-select_lap_id", 0,  "select by LAP ID", 0);
     213    psMetadataAddStr(definerelgroupArgs, PS_LIST_TAIL, "-select_data_group", PS_META_DUPLICATE_OK,  "select by camRun.data_group", NULL);
     214    // do we want this?
     215    // psMetadataAddS64(definerelgroupArgs, PS_LIST_TAIL, "-lap_id", 0,  "select by LAP ID", NULL);
     216
     217        // parameters of the relGroup
     218    psMetadataAddStr(definerelgroupArgs, PS_LIST_TAIL, "-set_group_type", 0,  "define group_type (required)", NULL);
     219    psMetadataAddStr(definerelgroupArgs, PS_LIST_TAIL, "-set_group_name", 0,  "define group_name (required)", NULL);
     220    psMetadataAddStr(definerelgroupArgs, PS_LIST_TAIL, "-set_label", 0, "define relgroup label (required)", NULL);
     221    psMetadataAddStr(definerelgroupArgs,  PS_LIST_TAIL, "-set_state", 0,      "define state", NULL);
     222    psMetadataAddStr(definerelgroupArgs,  PS_LIST_TAIL, "-set_exp_list_path", 0, "define path in exposure list", NULL);
     223    psMetadataAddS16(definerelgroupArgs,  PS_LIST_TAIL, "-set_fault", 0,      "define fault", 0);
     224
     225        // options
     226    psMetadataAddBool(definerelgroupArgs, PS_LIST_TAIL, "-pretend",  0, "do not actually modify the database", false);
     227    psMetadataAddBool(definerelgroupArgs, PS_LIST_TAIL, "-simple",  0, "use the simple output format", false);
     228
     229    // -pendingrelgroup
     230    psMetadata *pendingrelgroupArgs = psMetadataAlloc();
     231
     232    psMetadataAddStr(pendingrelgroupArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK,  "search by relGroup.label", NULL);
     233    psMetadataAddS32(pendingrelgroupArgs, PS_LIST_TAIL, "-rel_id", 0,      "select by release ID", 0);
     234    psMetadataAddS32(pendingrelgroupArgs, PS_LIST_TAIL, "-group_id", 0,    "select by relGroup ID", 0);
     235    psMetadataAddStr(pendingrelgroupArgs, PS_LIST_TAIL, "-release_name", 0, "select by release name", 0);
     236    psMetadataAddBool(pendingrelgroupArgs, PS_LIST_TAIL, "-simple",  0, "use the simple output format", false);
     237    psMetadataAddU64(pendingrelgroupArgs, PS_LIST_TAIL,  "-limit",       0, "limit result set to N items", 0);
     238   
     239    // -updaterelgroup
     240    psMetadata *updaterelgroupArgs = psMetadataAlloc();
     241
     242        // set the target release
     243    psMetadataAddS32(updaterelgroupArgs,  PS_LIST_TAIL, "-group_id", 0,   "select by group ID (required)", 0);
     244
     245        // parameters of the relGroup
     246    psMetadataAddStr(updaterelgroupArgs,  PS_LIST_TAIL, "-set_state", 0,  "define state", NULL);
     247    psMetadataAddStr(updaterelgroupArgs,  PS_LIST_TAIL, "-set_exp_list_path", 0, "define path in exposure list", NULL);
     248    psMetadataAddStr(updaterelgroupArgs,  PS_LIST_TAIL, "-set_label", 0,  "define relgroup label", NULL);
     249    psMetadataAddS16(updaterelgroupArgs,  PS_LIST_TAIL, "-set_fault", 0,  "define fault", 0);
     250    psMetadataAddBool(updaterelgroupArgs, PS_LIST_TAIL, "-clearfault",  0, "set fault to zero", false);
     251
     252    psMetadata *listrelgroupArgs = psMetadataAlloc();
     253    psMetadataAddS32(listrelgroupArgs,  PS_LIST_TAIL, "-group_id", 0,   "select by group ID", 0);
     254    psMetadataAddS32(listrelgroupArgs,  PS_LIST_TAIL, "-rel_id", 0,   "select by release ID", 0);
     255    psMetadataAddStr(listrelgroupArgs, PS_LIST_TAIL,  "-release_name", 0, "select by release name", 0);
     256
     257    // ******************************************************************
     258
    157259    psMetadata *argSets = psMetadataAlloc();
    158260    psMetadata *modes = psMetadataAlloc();
    … …  
    160262    PXOPT_ADD_MODE("-definesurvey",     "define a survey",              RELEASETOOL_MODE_DEFINESURVEY,  definesurveyArgs);
    161263    PXOPT_ADD_MODE("-listsurvey",       "list skycell parameters",      RELEASETOOL_MODE_LISTSURVEY,    listsurveyArgs);
     264
    162265    PXOPT_ADD_MODE("-definerelease",    "define a release",             RELEASETOOL_MODE_DEFINERELEASE, definereleaseArgs);
    163266    PXOPT_ADD_MODE("-updaterelease",    "update a release",             RELEASETOOL_MODE_UPDATERELEASE, updatereleaseArgs);
    164267    PXOPT_ADD_MODE("-listrelease",      "list releases",                RELEASETOOL_MODE_LISTRELEASE,   listreleaseArgs);
     268
    165269    PXOPT_ADD_MODE("-definerelexp",     "define a released exposure",   RELEASETOOL_MODE_DEFINERELEXP,  definerelexpArgs);
    166270    PXOPT_ADD_MODE("-updaterelexp",     "update a released exposure",   RELEASETOOL_MODE_UPDATERELEXP,  updaterelexpArgs);
     271    PXOPT_ADD_MODE("-tocalibexp",       "list relExps pending calibration",  RELEASETOOL_MODE_TOCALIBEXP,  tocalibexpArgs);
    167272    PXOPT_ADD_MODE("-listrelexp",       "list released exposures",      RELEASETOOL_MODE_LISTRELEXP,    listrelexpArgs);
     273
     274    PXOPT_ADD_MODE("-definerelstack",     "define a released stack",    RELEASETOOL_MODE_DEFINERELSTACK,  definerelstackArgs);
     275
     276    PXOPT_ADD_MODE("-definerelgroup",     "define a group of exposures", RELEASETOOL_MODE_DEFINERELGROUP,  definerelgroupArgs);
     277    PXOPT_ADD_MODE("-pendingrelgroup",     "list relGroups pending processing",    RELEASETOOL_MODE_PENDINGRELGROUP,  pendingrelgroupArgs);
     278    PXOPT_ADD_MODE("-updaterelgroup",     "update a relGroup",          RELEASETOOL_MODE_UPDATERELGROUP,  updaterelgroupArgs);
     279    PXOPT_ADD_MODE("-listrelgroup",     "define a group of exposures", RELEASETOOL_MODE_LISTRELGROUP,  listrelgroupArgs);
     280
     281
    168282
    169283    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {

  • branches/eam_branches/ipp-20130207/ippTools/src/staticskytool.c

    r35120 r35236  
    12811281    PXOPT_LOOKUP_F32(zpt_obs, config->args,   "-zpt_obs", false, false);
    12821282    PXOPT_LOOKUP_F32(zpt_stdev, config->args, "-zpt_stdev", false, false);
     1283    PXOPT_LOOKUP_F32(fwhm_major, config->args, "-fwhm_major", false, false);
     1284    PXOPT_LOOKUP_F32(fwhm_minor, config->args, "-fwhm_minor", false, false);
    12831285
    12841286
    … …  
    13341336        zpt_obs,
    13351337        zpt_stdev,
     1338        fwhm_major,
     1339        fwhm_minor,
    13361340        quality,
    13371341        software_ver,

  • branches/eam_branches/ipp-20130207/ippTools/src/staticskytoolConfig.c

    r35120 r35236  
    211211    psMetadataAddF32(addskycalresultArgs, PS_LIST_TAIL, "-sigma_ra", 0,            "define exposure E ra", NAN);
    212212    psMetadataAddF32(addskycalresultArgs, PS_LIST_TAIL, "-sigma_dec", 0,            "define exposure E dec", NAN);
    213     psMetadataAddF32(addskycalresultArgs, PS_LIST_TAIL, "-zpt_obs", 0,   "define observed zero point", 0);
    214     psMetadataAddF32(addskycalresultArgs, PS_LIST_TAIL, "-zpt_stdev", 0,   "define observed zero point stdandard deviation", 0);
     213    psMetadataAddF32(addskycalresultArgs, PS_LIST_TAIL, "-zpt_obs", 0,   "define observed zero point", NAN);
     214    psMetadataAddF32(addskycalresultArgs, PS_LIST_TAIL, "-zpt_stdev", 0,   "define observed zero point stdandard deviation", NAN);
     215    psMetadataAddF32(addskycalresultArgs, PS_LIST_TAIL, "-fwhm_major", 0,   "define fwhm (major axis; pixels)", NAN);
     216    psMetadataAddF32(addskycalresultArgs, PS_LIST_TAIL, "-fwhm_minor", 0,   "define fwhm (minor axis; pixels)", NAN);
    215217
    216218    psMetadataAddF32(addskycalresultArgs, PS_LIST_TAIL, "-dtime_script", 0, "define elapsed time in script (seconds)", NAN);
Note: See TracChangeset for help on using the changeset viewer.