IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 26912


Ignore:
Timestamp:
Feb 11, 2010, 11:24:30 AM (16 years ago)
Author:
Paul Price
Message:

Adding new mode for magicdstool: definecopy. This should allow us to use the magic mask created for one exposure on the chip run of a different exposure. This is to support distribution of un-pattern-corrected exposures, such as M31.

Location:
trunk/ippTools
Files:
1 added
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/ippTools/share/Makefile.am

    r26378 r26912  
    195195     magicdstool_definebyquery_warp.sql \
    196196     magicdstool_definebyquery_diff.sql \
     197     magicdstool_definecopy_chip.sql \
    197198     magicdstool_getrunids.sql \
    198199     magicdstool_getskycells.sql \

  • trunk/ippTools/src/magicdstool.c

    r26567 r26912  
    3333
    3434static bool definebyqueryMode(pxConfig *config);
     35static bool definecopyMode(pxConfig *config);
    3536static bool updaterunMode(pxConfig *config);
    3637static bool todestreakMode(pxConfig *config);
    … …  
    6566    switch (config->mode) {
    6667        MODECASE(MAGICDSTOOL_MODE_DEFINEBYQUERY,       definebyqueryMode);
     68        MODECASE(MAGICDSTOOL_MODE_DEFINECOPY,          definecopyMode);
    6769        MODECASE(MAGICDSTOOL_MODE_UPDATERUN,           updaterunMode);
    6870        MODECASE(MAGICDSTOOL_MODE_TODESTREAK,          todestreakMode);
    … …  
    127129
    128130    ippStage stageNum = ippStringToStage(stage);
    129    
     131
    130132    psString query = NULL;
    131133    switch (stageNum) {
    … …  
    249251        psString magicRunDataGroup = psMetadataLookupStr(NULL, row, "data_group");
    250252        psString magicRunWorkdir = psMetadataLookupStr(NULL, row, "workdir");
    251        
     253
    252254        // if workdir is not supplied use the magicRun's
    253255        if (!workdir) {
    … …  
    302304
    303305    if (!dry_run && !psDBCommit(config->dbh)) {
     306        psError(PS_ERR_UNKNOWN, false, "database error");
     307        return false;
     308    }
     309    psFree(output);
     310
     311    if (!magicDSRunPrintObjects(stdout, list, !simple)) {
     312        psError(PS_ERR_UNKNOWN, false, "failed to print object");
     313        psFree(list);
     314        return false;
     315    }
     316
     317    psFree(list);
     318
     319    return true;
     320}
     321
     322
     323// XXX This currently allows multiple destreak runs to be queued on the same exposure if there are multiple
     324// magicRuns selected!
     325static bool definecopyMode(pxConfig *config)
     326{
     327    // Required
     328    PXOPT_LOOKUP_STR(stage, config->args, "-stage", true, false);
     329    PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false);
     330
     331    // Optional
     332    PXOPT_LOOKUP_STR(recoveryroot, config->args, "-recoveryroot", false, false);
     333    PXOPT_LOOKUP_BOOL(noreplace, config->args, "-noreplace", false);
     334    PXOPT_LOOKUP_STR(set_label, config->args, "-set_label", false, false);
     335    PXOPT_LOOKUP_STR(set_data_group, config->args, "-set_data_group", false, false);
     336    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
     337    PXOPT_LOOKUP_BOOL(rerun, config->args, "-rerun", false);
     338    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
     339    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     340    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     341
     342    pretend = true;
     343
     344    // search args
     345    psMetadata *where = psMetadataAlloc();
     346    PXOPT_COPY_S64(config->args, where, "-exp_id",  "chipRun.exp_id", "==");
     347    PXOPT_COPY_S64(config->args, where, "-chip_id", "chipRun.chip_id", "==");
     348    PXOPT_COPY_S64(config->args, where, "-cam_id",  "camRun.cam_id", "==");
     349    PXOPT_COPY_S64(config->args, where, "-warp_id", "warpRun.warp_id", "==");
     350    PXOPT_COPY_S64(config->args, where, "-diff_id", "diffRun.diff_id", "==");
     351    PXOPT_COPY_S64(config->args, where, "-magic_id", "magicRun.magic_id", "==");
     352    PXOPT_COPY_S32(config->args, where, "-streaks_max", "magicMask.streaks", "<=");
     353
     354    pxAddLabelSearchArgs (config, where, "-magic_label", "magicRun.label", "=="); // define magic label
     355    psString labelName = NULL;                                                    // Name of label
     356    psStringAppend(&labelName, "%sRun.label", stage);
     357    pxAddLabelSearchArgs (config, where, "-stage_label", labelName, "=="); // define stageRun label
     358    psFree(labelName);
     359
     360    ippStage stageNum = ippStringToStage(stage);
     361
     362    psString query = NULL;
     363    switch (stageNum) {
     364      case IPP_STAGE_RAW:
     365        psError(PS_ERR_BAD_PARAMETER_VALUE, true, "Raw stage is not appropriate for a copied destreak");
     366        return false;
     367      case IPP_STAGE_CHIP:
     368        query = pxDataGet("magicdstool_definecopy_chip.sql");
     369        break;
     370      case IPP_STAGE_CAMERA:
     371      case IPP_STAGE_WARP:
     372      case IPP_STAGE_DIFF:
     373      case IPP_STAGE_FAKE:
     374        psError(PS_ERR_BAD_PARAMETER_VALUE, true, "%s has not been coded.", stage);
     375        return false;
     376      case IPP_STAGE_STACK:
     377        psError(PXTOOLS_ERR_DATA, true, "Stacks do not need to be destreaked");
     378        return false;
     379      case IPP_STAGE_NONE:
     380        psError(PXTOOLS_ERR_DATA, true, "%s is not a valid stage", stage);
     381        return false;
     382      default:
     383        psError(PXTOOLS_ERR_PROG, true, "ippStageToString returned %d for invalid stage %s",
     384                stageNum, stage);
     385        return false;
     386    }
     387
     388    if (!query) {
     389        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     390        return false;
     391    }
     392    const char *rerun_flag =  rerun ? "\n" : ""; // String to give query to activate (or not) rerun
     393
     394    if (stageNum != IPP_STAGE_DIFF) {
     395        if (psListLength(where->list)) {
     396            psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     397            psStringAppend(&query, "\nAND %s", whereClause);
     398            psFree(whereClause);
     399        }
     400        psFree(where);
     401
     402        // treat limit == 0 as "no limit"
     403        if (limit) {
     404            psString limitString = psDBGenerateLimitSQL(limit);
     405            psStringAppend(&query, " %s", limitString);
     406            psFree(limitString);
     407        }
     408        if (!p_psDBRunQueryF(config->dbh, query, rerun_flag)) {
     409            psError(PS_ERR_UNKNOWN, false, "database error");
     410            psFree(query);
     411            return false;
     412        }
     413    } else {
     414        // diff stage query has two types bothways and !bothways
     415        // so we need to send the rerun flag and the where data twice
     416        psString whereString = psStringCopy("");
     417        if (psListLength(where->list)) {
     418            psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     419            psStringAppend(&whereString, "\nAND %s", whereClause);
     420            psFree(whereClause);
     421        }
     422        psFree(where);
     423
     424        // treat limit == 0 as "no limit"
     425        if (limit) {
     426            psString limitString = psDBGenerateLimitSQL(limit);
     427            psStringAppend(&query, " %s", limitString);
     428            psFree(limitString);
     429        }
     430
     431        if (!p_psDBRunQueryF(config->dbh, query, rerun_flag, whereString, rerun_flag, whereString)) {
     432            psError(PS_ERR_UNKNOWN, false, "database error");
     433            psFree(whereString);
     434            psFree(query);
     435            return false;
     436        }
     437        psFree(whereString);
     438    }
     439    psFree(query);
     440
     441    psArray *output = p_psDBFetchResult(config->dbh);
     442    if (!output) {
     443        psErrorCode err = psErrorCodeLast();
     444        switch (err) {
     445          case PS_ERR_DB_CLIENT:
     446            psError(PXTOOLS_ERR_SYS, false, "database error");
     447          case PS_ERR_DB_SERVER:
     448            psError(PXTOOLS_ERR_PROG, false, "database error");
     449          default:
     450            psError(PXTOOLS_ERR_PROG, false, "unknown error");
     451        }
     452
     453        return false;
     454    }
     455    if (!psArrayLength(output)) {
     456        psTrace("magictool", PS_LOG_INFO, "no rows found");
     457        psFree(output);
     458        return true;
     459    }
     460
     461    // Parse the list of runs ready to be destreaked
     462
     463    if (!pretend && !psDBTransaction(config->dbh)) {
     464        psError(PS_ERR_UNKNOWN, false, "database error");
     465        return false;
     466    }
     467
     468    psArray *list = psArrayAllocEmpty(16); // List of runs, to print
     469    for (long i = 0; i < psArrayLength(output); i++) {
     470        psMetadata *row = output->data[i]; // Row of interest
     471        psS64 stage_id = psMetadataLookupS64(NULL, row, "stage_id");
     472        psS64 exp_id = psMetadataLookupS64(NULL, row, "exp_id");
     473        psS64 magic_id = psMetadataLookupS64(NULL, row, "magic_id");
     474        psS64 inv_magic_id = psMetadataLookupS64(NULL, row, "inv_magic_id");
     475        psS64 cam_id = psMetadataLookupS64(NULL, row, "cam_id");
     476        psString magicRunLabel = psMetadataLookupStr(NULL, row, "label");
     477        psString magicRunDataGroup = psMetadataLookupStr(NULL, row, "data_group");
     478
     479        psString outroot = NULL;
     480        // set outroot to workdir/exp_id/stage for example /somewhere/424242/chip
     481        psStringAppend(&outroot, "%s/%" PRId64 "/%s", workdir, exp_id, stage);
     482
     483        // create a new magicRun for this group
     484        magicDSRunRow *run = magicDSRunRowAlloc(
     485                0, // magic_ds_id
     486                magic_id,
     487                inv_magic_id,
     488                "new",
     489                stage,
     490                stage_id,
     491                cam_id,
     492                set_label ? set_label : magicRunLabel,
     493                set_data_group ? set_data_group : magicRunDataGroup,
     494                outroot,
     495                recoveryroot,
     496                noreplace ? 0 :1,   // re_place
     497                0,      // remove
     498                0,      // fault
     499                note);  // remove
     500
     501        psFree(outroot);
     502        if (!run) {
     503            psAbort("failed to alloc magicDSRun object");
     504        }
     505
     506        if (!pretend) {
     507            if (!magicDSRunInsertObject(config->dbh, run)) {
     508                psError(PS_ERR_UNKNOWN, false, "database error");
     509                psFree(run);
     510                psFree(output);
     511                psFree(list);
     512                if (!psDBRollback(config->dbh)) {
     513                    psError(PS_ERR_UNKNOWN, false, "database error");
     514                }
     515                return false;
     516            }
     517            psS64 magic_ds_id = psDBLastInsertID(config->dbh); // Assigned identifier
     518            run->magic_ds_id = magic_ds_id;
     519        }
     520
     521        psArrayAdd(list, list->n, run);
     522        psFree(run);
     523    }
     524
     525    if (!pretend && !psDBCommit(config->dbh)) {
    304526        psError(PS_ERR_UNKNOWN, false, "database error");
    305527        return false;
    … …  
    8291051    for (int i=0; i<psArrayLength(output); i++) {
    8301052        psMetadata *row = output->data[i];
    831         psS64 magic_ds_id = psMetadataLookupS64(NULL, row, "magic_ds_id"); 
    832         psString old_state = psMetadataLookupStr(NULL, row, "state"); 
     1053        psS64 magic_ds_id = psMetadataLookupS64(NULL, row, "magic_ds_id");
     1054        psString old_state = psMetadataLookupStr(NULL, row, "state");
    8331055        psString new_state;
    8341056        if (!strcmp(old_state, "goto_censored")) {

  • trunk/ippTools/src/magicdstool.h

    r25835 r26912  
    2626    MAGICDSTOOL_MODE_NONE           = 0x0,
    2727    MAGICDSTOOL_MODE_DEFINEBYQUERY,
     28    MAGICDSTOOL_MODE_DEFINECOPY,
    2829    MAGICDSTOOL_MODE_UPDATERUN,
    2930    MAGICDSTOOL_MODE_TODESTREAK,

  • trunk/ippTools/src/magicdstoolConfig.c

    r26567 r26912  
    6666    psMetadataAddS32(definebyqueryArgs, PS_LIST_TAIL, "-streaks_max", 0, "maximum number of streaks", 0);
    6767
    68     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-rerun",   0, "queue a new run even if one arleady exists", false);
     68    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-rerun",   0, "queue a new run even if one already exists", false);
    6969    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-dry_run", 0, "don't queue runs just display what would be queued", false);
    7070    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-simple",  0, "use the simple output format", false);
    7171    psMetadataAddU64(definebyqueryArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
     72
     73    // -definecopy
     74    psMetadata *definecopyArgs = psMetadataAlloc();
     75    psMetadataAddStr(definecopyArgs, PS_LIST_TAIL, "-stage",       0, "define stage (required)", NULL);
     76    psMetadataAddStr(definecopyArgs, PS_LIST_TAIL, "-workdir",     0, "define workdir (required)", NULL);
     77    psMetadataAddStr(definecopyArgs, PS_LIST_TAIL, "-recoveryroot", 0, "define recovery directory", NULL);
     78    psMetadataAddBool(definecopyArgs, PS_LIST_TAIL, "-noreplace", 0, "do not replace input files with the destreaked versions", false);
     79    psMetadataAddStr(definecopyArgs, PS_LIST_TAIL, "-set_label",    0, "define label", NULL);
     80    psMetadataAddStr(definecopyArgs, PS_LIST_TAIL, "-set_data_group", 0, "define data_group", NULL);
     81    psMetadataAddStr(definecopyArgs, PS_LIST_TAIL, "-set_note", 0, "define note", NULL);
     82    psMetadataAddStr(definecopyArgs, PS_LIST_TAIL, "-stage_label", PS_META_DUPLICATE_OK, "search by stageRun.label", NULL);
     83    psMetadataAddStr(definecopyArgs, PS_LIST_TAIL, "-magic_label", PS_META_DUPLICATE_OK, "search by magicRun.label", NULL);
     84    psMetadataAddS64(definecopyArgs, PS_LIST_TAIL, "-exp_id",   0, "search by exp_id", 0);
     85    psMetadataAddS64(definecopyArgs, PS_LIST_TAIL, "-chip_id",  0, "search by chip_id", 0);
     86    psMetadataAddS64(definecopyArgs, PS_LIST_TAIL, "-cam_id",  0, "search by cam_id", 0);
     87    psMetadataAddS64(definecopyArgs, PS_LIST_TAIL, "-warp_id",  0, "search by warp_id", 0);
     88    psMetadataAddS64(definecopyArgs, PS_LIST_TAIL, "-diff_id",  0, "search by diff_id", 0);
     89    psMetadataAddS64(definecopyArgs, PS_LIST_TAIL, "-magic_id", 0, "search by magic_id", 0);
     90    psMetadataAddS32(definecopyArgs, PS_LIST_TAIL, "-streaks_max", 0, "maximum number of streaks", 0);
     91    psMetadataAddBool(definecopyArgs, PS_LIST_TAIL, "-rerun",   0, "queue a new run even if one already exists", false);
     92    psMetadataAddBool(definecopyArgs, PS_LIST_TAIL, "-pretend", 0, "don't queue runs just display what would be queued", false);
     93    psMetadataAddBool(definecopyArgs, PS_LIST_TAIL, "-simple",  0, "use the simple output format", false);
     94    psMetadataAddU64(definecopyArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
    7295
    7396    // -updaterun
    … …  
    166189    PXOPT_ADD_MODE("-definebyquery",       "create magic de-streak runs from magic runs",
    167190                    MAGICDSTOOL_MODE_DEFINEBYQUERY,     definebyqueryArgs);
     191    PXOPT_ADD_MODE("-definecopy",          "create magic de-streak runs from magic runs for different path",
     192                    MAGICDSTOOL_MODE_DEFINECOPY,     definecopyArgs);
    168193    PXOPT_ADD_MODE("-updaterun",           "update state of magic de-streak run",
    169194                    MAGICDSTOOL_MODE_UPDATERUN,         updaterunArgs);
Note: See TracChangeset for help on using the changeset viewer.