IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 18153


Ignore:
Timestamp:
Jun 16, 2008, 1:49:43 PM (18 years ago)
Author:
jhoblitt
Message:

MERGE from HEAD

Location:
branches/cleanup/ippTools
Files:
24 edited

Legend:

Unmodified
Added
Removed

  • branches/cleanup/ippTools/share/dettool_tonormalizedstat.sql

    r15769 r18153  
    1616    iteration,
    1717    camera,
    18     workdir
     18    workdir,
     19    class_id
    1920FROM
    2021    (SELECT DISTINCT

  • branches/cleanup/ippTools/share/dettool_toresidimfile.sql

    r15856 r18153  
    7777    AND detResidImfile.exp_id IS NULL
    7878    AND detResidImfile.class_id IS NULL
     79ORDER BY exp_id

  • branches/cleanup/ippTools/share/faketool_pendingimfile.sql

    r18076 r18153  
    2424        camProcessedExp.path_base as cam_path_base,
    2525        rawExp.exp_name,
     26        rawExp.exp_tag,
    2627        rawExp.camera,
    2728        rawExp.telescope,

  • branches/cleanup/ippTools/share/warptool_imfile.sql

    r18076 r18153  
    22    rawImfile.*,
    33    warpRun.fake_id,
     4    camRun.cam_id as cam_id,
    45    chipProcessedImfile.uri as chip_uri,
    56    chipProcessedImfile.path_base as chip_path_base,

  • branches/cleanup/ippTools/src/camtool.c

    r18076 r18153  
    3030#include "camtool.h"
    3131
    32 static bool queueMode(pxConfig *config);
     32static bool definebyqueryMode(pxConfig *config);
    3333static bool updaterunMode(pxConfig *config);
    3434static bool pendingexpMode(pxConfig *config);
    … …  
    6060
    6161    switch (config->mode) {
    62         MODECASE(CAMTOOL_MODE_QUEUE,                queueMode);
     62        MODECASE(CAMTOOL_MODE_DEFINEBYQUERY,        definebyqueryMode);
    6363        MODECASE(CAMTOOL_MODE_UPDATERUN,            updaterunMode);
    6464        MODECASE(CAMTOOL_MODE_PENDINGEXP,           pendingexpMode);
    … …  
    9393
    9494
    95 static bool queueMode(pxConfig *config)
     95static bool definebyqueryMode(pxConfig *config)
    9696{
    9797    PS_ASSERT_PTR_NON_NULL(config, NULL);

  • branches/cleanup/ippTools/src/camtool.h

    r17171 r18153  
    2525typedef enum {
    2626    CAMTOOL_MODE_NONE      = 0x0,
    27     CAMTOOL_MODE_QUEUE,
     27    CAMTOOL_MODE_DEFINEBYQUERY,
    2828    CAMTOOL_MODE_UPDATERUN,
    2929    CAMTOOL_MODE_PENDINGEXP,

  • branches/cleanup/ippTools/src/camtoolConfig.c

    r17216 r18153  
    4646    }
    4747
    48     // -queue
    49     psMetadata *queueArgs = psMetadataAlloc();
     48    // -definebyquery
     49    psMetadata *definebydefinebyqueryArgs = psMetadataAlloc();
    5050    // XXX need to allow multiple chip_ids
    51     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-chip_id",  0,
     51    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-chip_id",  0,
    5252            "search by chip_id", NULL);
    5353    // XXX need to allow multiple exp_ids
    54     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-exp_id",  0,
     54    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-exp_id",  0,
    5555            "search by exp_id", NULL);
    56     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-exp_name",  0,
     56    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-exp_name",  0,
    5757            "search by exp_name", NULL);
    58     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-inst",  0,
     58    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-inst",  0,
    5959            "search for camera", NULL);
    60     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-telescope",  0,
     60    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-telescope",  0,
    6161            "search for telescope", NULL);
    62     psMetadataAddTime(queueArgs, PS_LIST_TAIL, "-dateobs_begin", 0,
     62    psMetadataAddTime(definebydefinebyqueryArgs, PS_LIST_TAIL, "-dateobs_begin", 0,
    6363            "search for exposures by time (>=)", NULL);
    64     psMetadataAddTime(queueArgs, PS_LIST_TAIL, "-dateobs_end", 0,
     64    psMetadataAddTime(definebydefinebyqueryArgs, PS_LIST_TAIL, "-dateobs_end", 0,
    6565            "search for exposures by time (<)", NULL);
    66     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-exp_tag",  0,
     66    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-exp_tag",  0,
    6767            "search by exp_tag", NULL);
    68     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-exp_type",  0,
     68    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-exp_type",  0,
    6969            "search by exp_type", NULL);
    70     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-filelevel",  0,
     70    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-filelevel",  0,
    7171            "search by filelevel", NULL);
    72     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-reduction",  0,
     72    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-reduction",  0,
    7373            "search by reduction class", NULL);
    74     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-filter",  0,
     74    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-filter",  0,
    7575            "search for filter", NULL);
    76     psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-airmass_min",  0,
     76    psMetadataAddF32(definebydefinebyqueryArgs, PS_LIST_TAIL, "-airmass_min",  0,
    7777            "define min airmass", NAN);
    78     psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-airmass_max",  0,
     78    psMetadataAddF32(definebydefinebyqueryArgs, PS_LIST_TAIL, "-airmass_max",  0,
    7979            "define max airmass", NAN);
    80     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-ra_min",  0,
    81             "define min", NAN);
    82     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-ra_max",  0,
    83             "define max", NAN);
    84     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-decl_min",  0,
    85             "define min", NAN);
    86     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-decl_max",  0,
    87             "define max", NAN);
    88     psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-exp_time_min",  0,
    89             "define min", NAN);
    90     psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-exp_time_max",  0,
    91             "define max", NAN);
    92     psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-sat_pixel_frac_min",  0,
     80    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-ra_min",  0,
     81            "define min", NAN);
     82    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-ra_max",  0,
     83            "define max", NAN);
     84    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-decl_min",  0,
     85            "define min", NAN);
     86    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-decl_max",  0,
     87            "define max", NAN);
     88    psMetadataAddF32(definebydefinebyqueryArgs, PS_LIST_TAIL, "-exp_time_min",  0,
     89            "define min", NAN);
     90    psMetadataAddF32(definebydefinebyqueryArgs, PS_LIST_TAIL, "-exp_time_max",  0,
     91            "define max", NAN);
     92    psMetadataAddF32(definebydefinebyqueryArgs, PS_LIST_TAIL, "-sat_pixel_frac_min",  0,
    9393            "define max fraction of saturated pixels", NAN);
    94     psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-sat_pixel_frac_max",  0,
     94    psMetadataAddF32(definebydefinebyqueryArgs, PS_LIST_TAIL, "-sat_pixel_frac_max",  0,
    9595            "define min fraction of saturated pixels", NAN);
    96     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-bg_min",  0,
    97             "define max", NAN);
    98     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-bg_max",  0,
    99             "define max", NAN);
    100     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-bg_stdev_min",  0,
    101             "define max", NAN);
    102     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-bg_stdev_max",  0,
    103             "define max", NAN);
    104     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-bg_mean_stdev_min",  0,
    105             "define max", NAN);
    106     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-bg_mean_stdev_max",  0,
    107             "define max", NAN);
    108     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-alt_min",  0,
    109             "define min", NAN);
    110     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-alt_max",  0,
    111             "define max", NAN);
    112     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-az_min",  0,
    113             "define min", NAN);
    114     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-az_max",  0,
    115             "define max", NAN);
    116     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-ccd_temp_min",  0,
     96    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-bg_min",  0,
     97            "define max", NAN);
     98    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-bg_max",  0,
     99            "define max", NAN);
     100    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-bg_stdev_min",  0,
     101            "define max", NAN);
     102    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-bg_stdev_max",  0,
     103            "define max", NAN);
     104    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-bg_mean_stdev_min",  0,
     105            "define max", NAN);
     106    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-bg_mean_stdev_max",  0,
     107            "define max", NAN);
     108    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-alt_min",  0,
     109            "define min", NAN);
     110    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-alt_max",  0,
     111            "define max", NAN);
     112    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-az_min",  0,
     113            "define min", NAN);
     114    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-az_max",  0,
     115            "define max", NAN);
     116    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-ccd_temp_min",  0,
    117117            "define min ccd tempature", NAN);
    118     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-ccd_temp_max",  0,
     118    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-ccd_temp_max",  0,
    119119            "define max ccd tempature", NAN);
    120     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-posang_min",  0,
     120    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-posang_min",  0,
    121121            "define min rotator position angle", NAN);
    122     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-posang_max",  0,
     122    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-posang_max",  0,
    123123            "define max rotator position angle", NAN);
    124     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-object",  0,
     124    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-object",  0,
    125125            "search by exposure object", NULL);
    126     psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-solang_min",  0,
     126    psMetadataAddF32(definebydefinebyqueryArgs, PS_LIST_TAIL, "-solang_min",  0,
    127127            "define min solar angle", NAN);
    128     psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-solang_max",  0,
     128    psMetadataAddF32(definebydefinebyqueryArgs, PS_LIST_TAIL, "-solang_max",  0,
    129129            "define max solar angle", NAN);
    130     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_workdir",  0,
     130    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-set_workdir",  0,
    131131            "define workdir", NULL);
    132     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_label",  0,
     132    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-set_label",  0,
    133133            "define label", NULL);
    134     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_reduction",  0,
     134    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-set_reduction",  0,
    135135            "define reduction class", NULL);
    136     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_expgroup",  0,
     136    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-set_expgroup",  0,
    137137            "define exposure group", NULL);
    138     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_dvodb",  0,
     138    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-set_dvodb",  0,
    139139            "define DVO db", NULL);
    140     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_tess_id",  0,
     140    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-set_tess_id",  0,
    141141            "define tess ID", NULL);
    142     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_end_stage",  0,
     142    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-set_end_stage",  0,
    143143            "define end stage", NULL);
    144     psMetadataAddBool(queueArgs, PS_LIST_TAIL, "-all",  0,
     144    psMetadataAddBool(definebydefinebyqueryArgs, PS_LIST_TAIL, "-all",  0,
    145145            "allow everything to be queued without search terms", false);
    146146
    … …  
    462462    psMetadata *modes = psMetadataAlloc();
    463463
    464     PXOPT_ADD_MODE("-queue",               "", CAMTOOL_MODE_QUEUE,         queueArgs);
     464    PXOPT_ADD_MODE("-definebyquery",       "", CAMTOOL_MODE_DEFINEBYQUERY, definebydefinebyqueryArgs);
    465465    PXOPT_ADD_MODE("-updaterun",           "", CAMTOOL_MODE_UPDATERUN,      updaterunArgs);
    466466    PXOPT_ADD_MODE("-pendingexp",          "", CAMTOOL_MODE_PENDINGEXP,    pendingexpArgs);

  • branches/cleanup/ippTools/src/chiptool.c

    r17863 r18153  
    3434#include "camtool.h"
    3535
    36 static bool queueMode(pxConfig *config);
     36static bool definebyqueryMode(pxConfig *config);
    3737static bool updaterunMode(pxConfig *config);
    3838static bool pendingimfileMode(pxConfig *config);
    … …  
    6868
    6969    switch (config->mode) {
    70         MODECASE(CHIPTOOL_MODE_QUEUE,                   queueMode);
     70        MODECASE(CHIPTOOL_MODE_DEFINEBYQUERY,                   definebyqueryMode);
    7171        MODECASE(CHIPTOOL_MODE_UPDATERUN,               updaterunMode);
    7272        MODECASE(CHIPTOOL_MODE_PENDINGIMFILE,           pendingimfileMode);
    … …  
    104104
    105105
    106 static bool queueMode(pxConfig *config)
     106static bool definebyqueryMode(pxConfig *config)
    107107{
    108108    PS_ASSERT_PTR_NON_NULL(config, NULL);

  • branches/cleanup/ippTools/src/chiptool.h

    r17863 r18153  
    2525typedef enum {
    2626    CHIPTOOL_MODE_NONE      = 0x0,
    27     CHIPTOOL_MODE_QUEUE,
     27    CHIPTOOL_MODE_DEFINEBYQUERY,
    2828    CHIPTOOL_MODE_UPDATERUN,
    2929    CHIPTOOL_MODE_PENDINGIMFILE,

  • branches/cleanup/ippTools/src/chiptoolConfig.c

    r17863 r18153  
    4444    }
    4545
    46     // -queue
     46    // -definebyquery
    4747    psMetadata *queueArgs = psMetadataAlloc();
    4848    // XXX need to allow multiple exp_ids
    … …  
    293293    psMetadata *modes = psMetadataAlloc();
    294294
    295     PXOPT_ADD_MODE("-queue",                "create runs from raw exposures",
    296         CHIPTOOL_MODE_QUEUE,                queueArgs);
     295    PXOPT_ADD_MODE("-definebyquery",                "create runs from raw exposures",
     296        CHIPTOOL_MODE_DEFINEBYQUERY,                queueArgs);
    297297    PXOPT_ADD_MODE("-updaterun",            "change chip run properties",
    298298        CHIPTOOL_MODE_UPDATERUN,            updaterunArgs);

  • branches/cleanup/ippTools/src/dettool.c

    r16868 r18153  
    535535    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    536536
     537    PXOPT_LOOKUP_BOOL(randomSubset, config->args, "-random_subset", false);
     538    PXOPT_LOOKUP_S32(randomLimit, config->args, "-random_limit", false, false);
     539
    537540    PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
    538541    PXOPT_LOOKUP_TIME(time_begin, config->args, "-time_begin", false, false);
    … …  
    549552    PXOPT_COPY_STR(config->args, where, "-select_uri", "uri", "==");
    550553    PXOPT_COPY_TIME(config->args, where, "-select_dateobs_begin", "dateobs", ">=");
    551     PXOPT_COPY_TIME(config->args, where, "-select_dateobs_end", "dateobs", "<");
     554    PXOPT_COPY_TIME(config->args, where, "-select_dateobs_end", "dateobs", "<=");
    552555    PXOPT_COPY_F32(config->args, where, "-select_airmass_min", "airmass", ">=");
    553556    PXOPT_COPY_F32(config->args, where, "-select_airmass_max", "airmass", "<=");
    … …  
    557560    PXOPT_COPY_F32(config->args, where, "-select_ccd_temp_min", "ccd_temp", ">=");
    558561    PXOPT_COPY_F32(config->args, where, "-select_ccd_temp_max", "ccd_temp", "<=");
     562    PXOPT_COPY_F32(config->args, where, "-select_pon_time_min", "pon_time", ">=");
     563    PXOPT_COPY_F32(config->args, where, "-select_pon_time_max", "pon_time", "<=");
    559564    PXOPT_COPY_F32(config->args, where, "-select_posang_min", "posang", ">=");
    560565    PXOPT_COPY_F32(config->args, where, "-select_posang_max", "posang", "<=");
    … …  
    584589        psFree(detrendExps);
    585590        return true;
     591    }
     592
     593    if (randomSubset && (randomLimit < detrendExps->n)) {
     594      // generate a random-valued vector, return an index sorted by the random values
     595      psVector *randomVector = psVectorAlloc(detrendExps->n, PS_TYPE_F32); // random values
     596      psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
     597      for (int i = 0; i < randomVector->n; i++) {
     598        randomVector->data.F32[i] = psRandomUniform(rng);
     599      }
     600      psVector *indexVector = psVectorSortIndex(NULL, randomVector);
     601
     602      // accept for first n of the sequence
     603      psArray *subset = psArrayAlloc (randomLimit);
     604      for (int i = 0; i < randomLimit; i++ ){
     605        int j = indexVector->data.S32[i];
     606        subset->data[i] = psMemIncrRefCounter (detrendExps->data[j]);
     607      }
     608      psFree (detrendExps);
     609      detrendExps = subset;
    586610    }
    587611

  • branches/cleanup/ippTools/src/dettoolConfig.c

    r17089 r18153  
    194194    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_ccd_temp_max",  0,
    195195            "define max ccd tempature", NAN);
     196    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_pon_time_min",  0,
     197            "define min power-on time", NAN);
     198    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_pon_time_max",  0,
     199            "define max power-on time", NAN);
    196200    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_posang_min",  0,
    197201            "define min rotator position angle", NAN);
    … …  
    210214    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-simple",  0,
    211215            "use the simple output format", false);
     216
     217    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-random_subset",  0,
     218            "use a random subset of elements", false);
     219    psMetadataAddS32(definebyqueryArgs, PS_LIST_TAIL, "-random_limit",  0,
     220            "use this number of random elements", 20);
    212221
    213222    // -definebydetrun

  • branches/cleanup/ippTools/src/difftool.c

    r17785 r18153  
    4040static bool revertdiffskyfileMode(pxConfig *config);
    4141static bool definepoprunMode(pxConfig *config);
    42 static bool queueMode(pxConfig *config);
     42static bool definebyqueryMode(pxConfig *config);
    4343
    4444static bool setdiffRunState(pxConfig *config, const char *diff_id, const char *state);
    … …  
    7171        MODECASE(DIFFTOOL_MODE_REVERTDIFFSKYFILE, revertdiffskyfileMode);
    7272        MODECASE(DIFFTOOL_MODE_DEFINEPOPRUN,      definepoprunMode);
    73         MODECASE(DIFFTOOL_MODE_QUEUE,             queueMode);
     73        MODECASE(DIFFTOOL_MODE_DEFINEBYQUERY,             definebyqueryMode);
    7474        default:
    7575            psAbort("invalid option (this should not happen)");
    … …  
    802802
    803803
    804 static bool queueMode(pxConfig *config)
     804static bool definebyqueryMode(pxConfig *config)
    805805{
    806806    PS_ASSERT_PTR_NON_NULL(config, false);

  • branches/cleanup/ippTools/src/difftool.h

    r17712 r18153  
    3434    DIFFTOOL_MODE_REVERTDIFFSKYFILE,
    3535    DIFFTOOL_MODE_DEFINEPOPRUN,
    36     DIFFTOOL_MODE_QUEUE,
     36    DIFFTOOL_MODE_DEFINEBYQUERY,
    3737} difftoolMode;
    3838

  • branches/cleanup/ippTools/src/difftoolConfig.c

    r17785 r18153  
    180180            "define stack ID for input", NULL);
    181181
    182     // -queue
     182    // -definebyquery
    183183    psMetadata *queueArgs = psMetadataAlloc();
    184184    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-workdir", 0,
    … …  
    203203    PXOPT_ADD_MODE("-revertdiffskyfile","", DIFFTOOL_MODE_REVERTDIFFSKYFILE, revertdiffskyfileArgs);
    204204    PXOPT_ADD_MODE("-definepoprun",     "", DIFFTOOL_MODE_DEFINEPOPRUN,      definepoprunArgs);
    205     PXOPT_ADD_MODE("-queue",            "", DIFFTOOL_MODE_QUEUE,             queueArgs);
     205    PXOPT_ADD_MODE("-definebyquery",            "", DIFFTOOL_MODE_DEFINEBYQUERY,             queueArgs);
    206206
    207207    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {

  • branches/cleanup/ippTools/src/faketool.c

    r18076 r18153  
    3333#include "faketool.h"
    3434
    35 static bool queueMode(pxConfig *config);
     35static bool definebyqueryMode(pxConfig *config);
    3636static bool updaterunMode(pxConfig *config);
    3737static bool pendingexpMode(pxConfig *config);
    … …  
    6565
    6666    switch (config->mode) {
    67         MODECASE(FAKETOOL_MODE_QUEUE,                   queueMode);
     67        MODECASE(FAKETOOL_MODE_DEFINEBYQUERY,                   definebyqueryMode);
    6868        MODECASE(FAKETOOL_MODE_UPDATERUN,               updaterunMode);
    6969        MODECASE(FAKETOOL_MODE_PENDINGEXP,              pendingexpMode);
    … …  
    9999
    100100
    101 static bool queueMode(pxConfig *config)
     101static bool definebyqueryMode(pxConfig *config)
    102102{
    103103    PS_ASSERT_PTR_NON_NULL(config, NULL);

  • branches/cleanup/ippTools/src/faketool.h

    r18076 r18153  
    2525typedef enum {
    2626    FAKETOOL_MODE_NONE      = 0x0,
    27     FAKETOOL_MODE_QUEUE,
     27    FAKETOOL_MODE_DEFINEBYQUERY,
    2828    FAKETOOL_MODE_UPDATERUN,
    2929    FAKETOOL_MODE_PENDINGIMFILE,

  • branches/cleanup/ippTools/src/faketoolConfig.c

    r18076 r18153  
    4444    }
    4545
    46     // -queue
     46    // -definebyquery
    4747    psMetadata *queueArgs = psMetadataAlloc();
    4848    // XXX need to allow multiple exp_ids
    … …  
    426426    psMetadata *modes = psMetadataAlloc();
    427427
    428     PXOPT_ADD_MODE("-queue",                 "create runs from raw exposures",
    429         FAKETOOL_MODE_QUEUE,                    queueArgs);
     428    PXOPT_ADD_MODE("-definebyquery",                 "create runs from raw exposures",
     429        FAKETOOL_MODE_DEFINEBYQUERY,                    queueArgs);
    430430    PXOPT_ADD_MODE("-updaterun",             "change fake run properties",
    431431        FAKETOOL_MODE_UPDATERUN,                updaterunArgs);

  • branches/cleanup/ippTools/src/magictool.c

    r16170 r18153  
    3131#include "magictool.h"
    3232
    33 static bool queueMode(pxConfig *config);
     33static bool definebyqueryMode(pxConfig *config);
    3434static psS64 definerunMode(pxConfig *config);
    3535static bool updaterunMode(pxConfig *config);
    … …  
    6565
    6666    switch (config->mode) {
    67         MODECASE(MAGICTOOL_MODE_QUEUE,          queueMode);
     67        MODECASE(MAGICTOOL_MODE_DEFINEBYQUERY,          definebyqueryMode);
    6868        MODECASE(MAGICTOOL_MODE_DEFINERUN,      definerunMode);
    6969        MODECASE(MAGICTOOL_MODE_UPDATERUN,      updaterunMode);
    … …  
    9898}
    9999
    100 static bool queueMode(pxConfig *config)
     100static bool definebyqueryMode(pxConfig *config)
    101101{
    102102    PS_ASSERT_PTR_NON_NULL(config, false);

  • branches/cleanup/ippTools/src/magictool.h

    r15501 r18153  
    2525typedef enum {
    2626    MAGICTOOL_MODE_NONE           = 0x0,
    27     MAGICTOOL_MODE_QUEUE,
     27    MAGICTOOL_MODE_DEFINEBYQUERY,
    2828    MAGICTOOL_MODE_DEFINERUN,
    2929    MAGICTOOL_MODE_UPDATERUN,

  • branches/cleanup/ippTools/src/magictoolConfig.c

    r16170 r18153  
    4747    psTime *now = psTimeGetNow(PS_TIME_TAI);
    4848
    49     // -queue
     49    // -definebyquery
    5050    psMetadata *queueArgs = psMetadataAlloc();
    5151
    … …  
    160160    psMetadata *modes   = psMetadataAlloc();
    161161
    162     PXOPT_ADD_MODE("-queue",           "", MAGICTOOL_MODE_QUEUE,           queueArgs);
     162    PXOPT_ADD_MODE("-definebyquery",           "", MAGICTOOL_MODE_DEFINEBYQUERY,           queueArgs);
    163163    PXOPT_ADD_MODE("-definerun",       "", MAGICTOOL_MODE_DEFINERUN,       definerunArgs);
    164164    PXOPT_ADD_MODE("-updaterun",       "", MAGICTOOL_MODE_UPDATERUN,       updaterunArgs);

  • branches/cleanup/ippTools/src/stacktool.c

    r16940 r18153  
    3131#include "stacktool.h"
    3232
    33 static bool queueMode(pxConfig *config);
     33static bool definebyqueryMode(pxConfig *config);
    3434static bool definerunMode(pxConfig *config);
    3535static bool updaterunMode(pxConfig *config);
    … …  
    6161
    6262    switch (config->mode) {
    63         MODECASE(STACKTOOL_MODE_QUEUE,              queueMode);
     63        MODECASE(STACKTOOL_MODE_DEFINEBYQUERY,              definebyqueryMode);
    6464        MODECASE(STACKTOOL_MODE_DEFINERUN,          definerunMode);
    6565        MODECASE(STACKTOOL_MODE_UPDATERUN,          updaterunMode);
    … …  
    9292
    9393
    94 static bool queueMode(pxConfig *config)
     94static bool definebyqueryMode(pxConfig *config)
    9595{
    9696    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    107107    PXOPT_COPY_STR(config->args, whereRE, "-select_uri", "uri", "==");
    108108    PXOPT_COPY_TIME(config->args, whereRE, "-select_dateobs_begin", "dateobs", ">=");
    109     PXOPT_COPY_TIME(config->args, whereRE, "-select_dateobs_end", "dateobs", "<");
     109    PXOPT_COPY_TIME(config->args, whereRE, "-select_dateobs_end", "dateobs", "<=");
    110110    PXOPT_COPY_F32(config->args, whereRE, "-select_airmass_min", "airmass", ">=");
    111111    PXOPT_COPY_F32(config->args, whereRE, "-select_airmass_max", "airmass", "<=");
    … …  
    120120    PXOPT_COPY_F32(config->args, whereRE, "-select_solang_max", "solang", "<=");
    121121    PXOPT_COPY_STR(config->args, whereWSF, "-select_skycell_id", "skycell_id", "==");
     122    PXOPT_LOOKUP_BOOL(randomSubset, config->args, "-random_subset", false);
     123    PXOPT_LOOKUP_S32(randomLimit, config->args, "-random_limit", false, false);
    122124
    123125    if (!psListLength(whereRE->list) && !psListLength(whereWSF->list) &&
    … …  
    182184    }
    183185
     186    // valid_warpids should be NULL unless randomSubset is specified
     187    psVector *valid_warpids = NULL;
     188    if (randomSubset && (randomLimit < psArrayLength(output))) {
     189        // loop over the array of metadata and figure out which warp_id are in
     190        // the result set
     191        psArray *warps = psArrayAlloc(0);
     192        for (long i = 0; i < psArrayLength(output); i++) {
     193//            psMetadata *md = output->data[i];
     194
     195            // pull out the warp_id
     196            bool status = false;
     197//            psS64 warp_id = psMetadataLookupS64(&status, md, "warp_id");
     198            if (!status) {
     199                psError(PS_ERR_UNKNOWN, false, "failed to lookup warp_id");
     200                psFree(output);
     201                psFree(warps);
     202                return NULL;
     203            }
     204
     205//            psArrayAdd(warps, 0, warp_id);
     206        }
     207
     208        // generate a random-valued vector, return an index sorted by the
     209        // random values
     210        psVector *randomVector = psVectorAlloc(psArrayLength(output), PS_TYPE_F32);
     211        psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
     212        for (int i = 0; i < randomVector->n; i++) {
     213            randomVector->data.F32[i] = psRandomUniform(rng);
     214        }
     215        psVector *indexVector = psVectorSortIndex(NULL, randomVector);
     216        psFree(randomVector);
     217
     218        // accept for first n of the sequence
     219        valid_warpids = psVectorAlloc(randomLimit, PS_TYPE_S64);
     220        for (int i = 0; i < randomLimit; i++ ){
     221//            int j = indexVector->data.S32[i];
     222//            valid_warpids->data[i] = psMemIncrRefCounter (warps->data[j]);
     223        }
     224        psFree(indexVector);
     225        psFree(warps);
     226    }
     227
     228
    184229    psHash *stacks = psHashAlloc(psArrayLength(output));
    185230
    186     // loop over the array of metadata
     231    // loop over the array of metadata and build a hash keyed by tess_id &
     232    // skycell_id
    187233    for (long i = 0; i < psArrayLength(output); i++) {
    188234        psMetadata *md = output->data[i];
    189235
    190         // pull out the warp_id, skycell_id, & tess_id
    191236        bool status;
     237        if (valid_warpids) {
     238//            psS64 warp_id = psMetadataLookupS64(&status, md, "warp_id");
     239            if (!status) {
     240                psError(PS_ERR_UNKNOWN, false, "failed to lookup warp_id");
     241                psFree(valid_warpids);
     242                psFree(output);
     243                return NULL;
     244            }
     245
     246            // is this a warp_id that should be left out of the stack set(s)?
     247//            for (long i = 0; i < psArrayLength(valid_warpids); i++) {
     248//                if (valid_warpids->data[i] == warp_id) {
     249//                    continue;
     250//                }
     251//            }
     252        }
     253
     254        // pull out the skycell_id, & tess_id
    192255        psString skycell_id = psMetadataLookupStr(&status, md, "skycell_id");
    193256        if (!status) {
    194257            psError(PS_ERR_UNKNOWN, false, "failed to lookup skycell_id");
     258            psFree(valid_warpids);
    195259            psFree(output);
    196260            return NULL;
    … …  
    200264        if (!status) {
    201265            psError(PS_ERR_UNKNOWN, false, "failed to lookup tess_id");
     266            psFree(valid_warpids);
    202267            psFree(output);
    203268            return NULL;
    … …  
    220285
    221286    }
     287    psFree(valid_warpids);
    222288    psFree(output);
    223289

  • branches/cleanup/ippTools/src/stacktool.h

    r16724 r18153  
    2525typedef enum {
    2626    STACKTOOL_MODE_NONE           = 0x0,
    27     STACKTOOL_MODE_QUEUE,
     27    STACKTOOL_MODE_DEFINEBYQUERY,
    2828    STACKTOOL_MODE_DEFINERUN,
    2929    STACKTOOL_MODE_UPDATERUN,

  • branches/cleanup/ippTools/src/stacktoolConfig.c

    r16940 r18153  
    4545    psTime *now = psTimeGetNow(PS_TIME_TAI);
    4646
    47     // -queue
    48     psMetadata *queueArgs = psMetadataAlloc();
    49     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-workdir", 0,
     47    // -definebyquery
     48    psMetadata *definebyqueryArgs = psMetadataAlloc();
     49    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-workdir", 0,
    5050            "define workdir (required)", NULL);
    51     psMetadataAddTime(queueArgs, PS_LIST_TAIL, "-registered",  0,
     51    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-registered",  0,
    5252            "time detrend run was registered", now);
    53     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-select_skycell_id",  0,
     53    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_skycell_id",  0,
    5454            "search for skycell_id", NULL);
    55     psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-select_good_frac_min",  0,
     55    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_good_frac_min",  0,
    5656            "define min good_frac", 0.0);
    57     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-select_exp_type",  0,
     57    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_exp_type",  0,
    5858            "search for exp_type", "object");
    59     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-select_inst",  0,
     59    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_inst",  0,
    6060            "search for camera", NULL);
    61     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-select_telescope",  0,
     61    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_telescope",  0,
    6262            "search for telescope", NULL);
    63     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-select_filter",  0,
     63    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_filter",  0,
    6464            "search for filter", NULL);
    65     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-select_uri",  0,
     65    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_uri",  0,
    6666            "search for uri", NULL);
    67     psMetadataAddTime(queueArgs, PS_LIST_TAIL, "-select_dateobs_begin", 0,
     67    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-select_dateobs_begin", 0,
    6868            "search for exposures by time (>=)", NULL);
    69     psMetadataAddTime(queueArgs, PS_LIST_TAIL, "-select_dateobs_end", 0,
     69    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-select_dateobs_end", 0,
    7070            "search for exposures by time (<)", NULL);
    71     psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-select_airmass_min",  0,
     71    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_airmass_min",  0,
    7272            "define min airmass", NAN);
    73     psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-select_airmass_max",  0,
     73    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_airmass_max",  0,
    7474            "define max airmass", NAN);
    75     psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-select_sat_pixel_frac_max",  0,
     75    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_sat_pixel_frac_max",  0,
    7676            "define max fraction of saturated pixels", NAN);
    77     psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-select_exp_time_min",  0,
     77    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_exp_time_min",  0,
    7878            "define min exposure time", NAN);
    79     psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-select_exp_time_max",  0,
     79    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_exp_time_max",  0,
    8080            "define max exposure time", NAN);
    81     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-select_ccd_temp_min",  0,
     81    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_ccd_temp_min",  0,
    8282            "define min ccd tempature", NAN);
    83     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-select_ccd_temp_max",  0,
     83    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_ccd_temp_max",  0,
    8484            "define max ccd tempature", NAN);
    85     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-select_posang_min",  0,
     85    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_posang_min",  0,
    8686            "define min rotator position angle", NAN);
    87     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-select_posang_max",  0,
     87    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_posang_max",  0,
    8888            "define max rotator position angle", NAN);
    89     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-select_solang_min",  0,
     89    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_solang_min",  0,
    9090            "define min solar angle", NAN);
    91     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-select_solang_max",  0,
     91    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_solang_max",  0,
    9292            "define max solar angle", NAN);
    93 
    94     psMetadataAddBool(queueArgs, PS_LIST_TAIL, "-all",  0,
     93    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-random_subset",  0,
     94            "use a random subset of elements", false);
     95    psMetadataAddS32(definebyqueryArgs, PS_LIST_TAIL, "-random_limit",  0,
     96            "use this number of random elements", 20);
     97
     98    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-all",  0,
    9599            "allow everything to be queued without search terms", false);
    96     psMetadataAddBool(queueArgs, PS_LIST_TAIL, "-simple",  0,
     100    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-simple",  0,
    97101            "use the simple output format", false);
    98102
    … …  
    200204    psMetadata *modes   = psMetadataAlloc();
    201205
    202     PXOPT_ADD_MODE("-queue", "Define a new stackRun by searching for warp IDs",
    203         STACKTOOL_MODE_QUEUE,  queueArgs);
     206    PXOPT_ADD_MODE("-definebyquery", "Define a new stackRun by searching for warp IDs",
     207        STACKTOOL_MODE_DEFINEBYQUERY,  definebyqueryArgs);
    204208    PXOPT_ADD_MODE("-definerun",       "", STACKTOOL_MODE_DEFINERUN,      definerunArgs);
    205209    PXOPT_ADD_MODE("-updaterun",       "", STACKTOOL_MODE_UPDATERUN,      updaterunArgs);
Note: See TracChangeset for help on using the changeset viewer.