IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Aug 7, 2009, 12:45:24 PM (17 years ago)
Author:
eugene
Message:

update from mainline

Location:
branches/eam_branches/20090715
Files:
22 edited

Legend:

Unmodified
Added
Removed

  • branches/eam_branches/20090715

  • branches/eam_branches/20090715/ippTools/src/dettool.c

    r24779 r25022  
    276276    PXOPT_LOOKUP_F64(posang_min, config->args, "-posang_min", false, false);
    277277    PXOPT_LOOKUP_F64(posang_max, config->args, "-posang_max", false, false);
    278     PXOPT_LOOKUP_F64(solang_min, config->args, "-solang_min", false, false);
    279     PXOPT_LOOKUP_F64(solang_max, config->args, "-solang_max", false, false);
     278    PXOPT_LOOKUP_F64(solang_min, config->args, "-sun_angle_min", false, false);
     279    PXOPT_LOOKUP_F64(solang_max, config->args, "-sun_angle_max", false, false);
    280280    PXOPT_LOOKUP_TIME(time_begin, config->args, "-time_begin", false, false);
    281281    PXOPT_LOOKUP_TIME(time_end, config->args, "-time_end", false, false);
    … …  
    521521    PXOPT_LOOKUP_F64(posang_min, config->args, "-posang_min", false, false);
    522522    PXOPT_LOOKUP_F64(posang_max, config->args, "-posang_max", false, false);
    523     PXOPT_LOOKUP_F64(solang_min, config->args, "-solang_min", false, false);
    524     PXOPT_LOOKUP_F64(solang_max, config->args, "-solang_max", false, false);
     523    PXOPT_LOOKUP_F64(solang_min, config->args, "-sun_angle_min", false, false);
     524    PXOPT_LOOKUP_F64(solang_max, config->args, "-sun_angle_max", false, false);
    525525
    526526    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
    … …  
    557557    PXOPT_COPY_F64(config->args, where, "-select_posang_min", "posang", ">=");
    558558    PXOPT_COPY_F64(config->args, where, "-select_posang_max", "posang", "<=");
    559     PXOPT_COPY_F64(config->args, where, "-select_solang_min", "solang", ">=");
    560     PXOPT_COPY_F64(config->args, where, "-select_solang_max", "solang", "<=");
     559    PXOPT_COPY_F64(config->args, where, "-select_sun_angle_min", "sun_angle", ">=");
     560    PXOPT_COPY_F64(config->args, where, "-select_sun_angle_max", "sun_angle", "<=");
     561    PXOPT_COPY_F64(config->args, where, "-select_sun_alt_min", "sun_alt", ">=");
     562    PXOPT_COPY_F64(config->args, where, "-select_sun_alt_max", "sun_alt", "<=");
    561563
    562564    PXOPT_COPY_F64(config->args, where, "-select_moon_angle_min", "moon_angle", ">=");
    … …  
    775777    PXOPT_LOOKUP_F64(posang_min, config->args, "-set_posang_min", false, false);
    776778    PXOPT_LOOKUP_F64(posang_max, config->args, "-set_posang_max", false, false);
    777     PXOPT_LOOKUP_F64(solang_min, config->args, "-set_solang_min", false, false);
    778     PXOPT_LOOKUP_F64(solang_max, config->args, "-set_solang_max", false, false);
     779    PXOPT_LOOKUP_F64(solang_min, config->args, "-set_sun_angle_min", false, false);
     780    PXOPT_LOOKUP_F64(solang_max, config->args, "-set_sun_angle_max", false, false);
    779781    PXOPT_LOOKUP_TIME(registered, config->args, "-set_registered", false, false);
    780782    PXOPT_LOOKUP_TIME(time_begin, config->args, "-set_time_begin", false, false);
    … …  
    16131615    PXOPT_LOOKUP_F64(posang_min, config->args, "-posang_min", false, false);
    16141616    PXOPT_LOOKUP_F64(posang_max, config->args, "-posang_max", false, false);
    1615     PXOPT_LOOKUP_F64(solang_min, config->args, "-solang_min", false, false);
    1616     PXOPT_LOOKUP_F64(solang_max, config->args, "-solang_max", false, false);
     1617    PXOPT_LOOKUP_F64(solang_min, config->args, "-sun_angle_min", false, false);
     1618    PXOPT_LOOKUP_F64(solang_max, config->args, "-sun_angle_max", false, false);
    16171619    PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
    16181620    PXOPT_LOOKUP_TIME(time_begin, config->args, "-time_begin", false, false);

  • branches/eam_branches/20090715/ippTools/src/dettoolConfig.c

    r24779 r25022  
    6868    psMetadataAddF64(definebytagArgs, PS_LIST_TAIL, "-posang_min",  0,            "define min rotator position angle", NAN);
    6969    psMetadataAddF64(definebytagArgs, PS_LIST_TAIL, "-posang_max",  0,            "define max rotator position angle", NAN);
    70     psMetadataAddF64(definebytagArgs, PS_LIST_TAIL, "-solang_min",  0,            "define min solar angle", NAN);
    71     psMetadataAddF64(definebytagArgs, PS_LIST_TAIL, "-solang_max",  0,            "define max solar angle", NAN);
     70    psMetadataAddF64(definebytagArgs, PS_LIST_TAIL, "-sun_angle_min",  0,            "define min solar angle", NAN);
     71    psMetadataAddF64(definebytagArgs, PS_LIST_TAIL, "-sun_angle_max",  0,            "define max solar angle", NAN);
    7272
    7373    psMetadataAddTime(definebytagArgs, PS_LIST_TAIL, "-registered",  0,            "time detrend run was registered", now);
    … …  
    100100    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-posang_min",  0,            "define min rotator position angle", NAN);
    101101    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-posang_max",  0,            "define max rotator position angle", NAN);
    102     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-solang_min",  0,            "define min solar angle", NAN);
    103     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-solang_max",  0,            "define max solar angle", NAN);
     102    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-sun_angle_min",  0,            "define min solar angle", NAN);
     103    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-sun_angle_max",  0,            "define max solar angle", NAN);
    104104    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-registered",  0,            "time detrend run was registered", now);
    105105    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-time_begin",  0,            "detrend applies to exposures taken during this period", NULL);
    … …  
    125125    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_posang_min",  0,            "define min rotator position angle", NAN);
    126126    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_posang_max",  0,            "define max rotator position angle", NAN);
    127     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_solang_min",  0,            "define min solar angle", NAN);
    128     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_solang_max",  0,            "define max solar angle", NAN);
     127    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_sun_angle_min",  0,            "define min solar angle", NAN);
     128    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_sun_angle_max",  0,            "define max solar angle", NAN);
     129    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_sun_alt_min",  0,            "define min solar altitude", NAN);
     130    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_sun_alt_max",  0,            "define max solar altitude", NAN);
    129131
    130132    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_moon_angle_min",  0,          "define min moon angle", NAN);
    … …  
    164166    psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_posang_min",  0,            "define rotator position angle", NAN);
    165167    psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_posang_max",  0,            "define rotator position angle", NAN);
    166     psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_solang_min",  0,            "define solar angle", NAN);
    167     psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_solang_max",  0,            "define solar angle", NAN);
     168    psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_sun_angle_min",  0,            "define solar angle", NAN);
     169    psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_sun_angle_max",  0,            "define solar angle", NAN);
    168170    psMetadataAddTime(definebydetrunArgs, PS_LIST_TAIL, "-set_registered",  0,            "time detrend run was registered", now);
    169171    psMetadataAddTime(definebydetrunArgs, PS_LIST_TAIL, "-set_time_begin",  0,            "start of period to apply detrend too", NULL);
    … …  
    840842    psMetadataAddF64(register_detrendArgs, PS_LIST_TAIL, "-posang_min",  0,            "define min rotator position angle", NAN);
    841843    psMetadataAddF64(register_detrendArgs, PS_LIST_TAIL, "-posang_max",  0,            "define max rotator position angle", NAN);
    842     psMetadataAddF64(register_detrendArgs, PS_LIST_TAIL, "-solang_min",  0,            "define min solar angle", NAN);
    843     psMetadataAddF64(register_detrendArgs, PS_LIST_TAIL, "-solang_max",  0,            "define max solar angle", NAN);
     844    psMetadataAddF64(register_detrendArgs, PS_LIST_TAIL, "-sun_angle_min",  0,            "define min solar angle", NAN);
     845    psMetadataAddF64(register_detrendArgs, PS_LIST_TAIL, "-sun_angle_max",  0,            "define max solar angle", NAN);
    844846    psMetadataAddTime(register_detrendArgs, PS_LIST_TAIL, "-registered",  0,            "time detrend run was registered", now);
    845847    psMetadataAddTime(register_detrendArgs, PS_LIST_TAIL, "-time_begin",  0,            "detrend applies to exposures taken during this period", NULL);

  • branches/eam_branches/20090715/ippTools/src/difftool.c

    r24676 r25022  
    582582    PXOPT_COPY_STR(config->args, where, "-skycell_id", "diffInputSkyfile.skycell_id", "==");
    583583    PXOPT_COPY_S64(config->args, where,  "-diff_skyfile_id", "diffInputSkyfile.diff_skyfile_id", "==");
    584     PXOPT_COPY_STR(config->args, where, "-tess_id", "diffSkyfile.tess_id", "==");
     584    PXOPT_COPY_STR(config->args, where, "-tess_id", "diffRun.tess_id", "==");
    585585    PXOPT_COPY_S16(config->args, where, "-fault", "diffSkyfile.fault", "==");
    586586    PXOPT_COPY_S64(config->args, where, "-exp_id", "rawExp.exp_id", "==");
    … …  
    661661    PXOPT_COPY_STR(config->args, where,  "-label", "diffRun.label", "==");
    662662    PXOPT_COPY_S16(config->args, where, "-fault",     "fault", "==");
     663
     664    if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
     665        psFree(where);
     666        psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     667        return false;
     668    }
    663669
    664670    if (!psDBTransaction(config->dbh)) {
    … …  
    12881294                   "ABS(TIME_TO_SEC(TIMEDIFF(inputRawExp.dateobs, templateRawExp.dateobs)))", "<=");
    12891295
     1296    // other where restrictions:
     1297    PXOPT_COPY_TIME(config->args,  selectWhere, "-dateobs_begin",      "inputRawExp.dateobs",        ">=");
     1298    PXOPT_COPY_TIME(config->args,  selectWhere, "-dateobs_end",        "inputRawExp.dateobs",        "<=");
     1299    PXOPT_COPY_RADEC(config->args, selectWhere, "-ra_min",             "inputRawExp.ra",             ">=");
     1300    PXOPT_COPY_RADEC(config->args, selectWhere, "-ra_max",             "inputRawExp.ra",             "<");
     1301    PXOPT_COPY_RADEC(config->args, selectWhere, "-decl_min",           "inputRawExp.decl",           ">=");
     1302    PXOPT_COPY_RADEC(config->args, selectWhere, "-decl_max",           "inputRawExp.decl",           "<");
     1303    PXOPT_COPY_F32(config->args,   selectWhere, "-sat_pixel_frac_min", "inputRawExp.sat_pixel_frac", ">=");
     1304    PXOPT_COPY_F32(config->args,   selectWhere, "-sat_pixel_frac_max", "inputRawExp.sat_pixel_frac", "<");
     1305    PXOPT_COPY_F64(config->args,   selectWhere, "-airmass_min",        "inputRawExp.airmass",        ">=");
     1306    PXOPT_COPY_F64(config->args,   selectWhere, "-airmass_max",        "inputRawExp.airmass",        "<");
     1307    PXOPT_COPY_F32(config->args,   selectWhere, "-exp_time_min",       "inputRawExp.exp_time",       ">=");
     1308    PXOPT_COPY_F32(config->args,   selectWhere, "-exp_time_max",       "inputRawExp.exp_time",       "<");
     1309    PXOPT_COPY_F64(config->args,   selectWhere, "-bg_min",             "inputRawExp.bg",             ">=");
     1310    PXOPT_COPY_F64(config->args,   selectWhere, "-bg_max",             "inputRawExp.bg",             "<");
     1311    PXOPT_COPY_F64(config->args,   selectWhere, "-bg_stdev_min",       "inputRawExp.bg_stdev",       ">=");
     1312    PXOPT_COPY_F64(config->args,   selectWhere, "-bg_stdev_max",       "inputRawExp.bg_stdev",       "<");
     1313    PXOPT_COPY_F64(config->args,   selectWhere, "-bg_mean_stdev_min",  "inputRawExp.bg_mean_stdev",  ">=");
     1314    PXOPT_COPY_F64(config->args,   selectWhere, "-bg_mean_stdev_max",  "inputRawExp.bg_mean_stdev",  "<");
     1315    PXOPT_COPY_F64(config->args,   selectWhere, "-alt_min",            "inputRawExp.alt",            ">=");
     1316    PXOPT_COPY_F64(config->args,   selectWhere, "-alt_max",            "inputRawExp.alt",            "<");
     1317    PXOPT_COPY_F64(config->args,   selectWhere, "-az_min",             "inputRawExp.az",             ">=");
     1318    PXOPT_COPY_F64(config->args,   selectWhere, "-az_max",             "inputRawExp.az",             "<");
     1319    PXOPT_COPY_F32(config->args,   selectWhere, "-ccd_temp_min",       "inputRawExp.ccd_temp",       ">=");
     1320    PXOPT_COPY_F32(config->args,   selectWhere, "-ccd_temp_max",       "inputRawExp.ccd_temp",       "<");
     1321    PXOPT_COPY_F64(config->args,   selectWhere, "-posang_min",         "inputRawExp.posang",         ">=");
     1322    PXOPT_COPY_F64(config->args,   selectWhere, "-posang_max",         "inputRawExp.posang",         "<");
     1323    PXOPT_COPY_F32(config->args,   selectWhere, "-sun_angle_min",      "inputRawExp.sun_angle",      ">=");
     1324    PXOPT_COPY_F32(config->args,   selectWhere, "-sun_angle_max",      "inputRawExp.sun_angle",      "<");
     1325    PXOPT_COPY_STR(config->args,   selectWhere, "-comment",            "inputRawExp.comment",        "LIKE");
     1326
    12901327    // Haversine formula for great circle distance
    12911328    PXOPT_COPY_F32(config->args, selectWhere, "-distance",

  • branches/eam_branches/20090715/ippTools/src/difftoolConfig.c

    r24174 r25022  
    133133    psMetadataAddStr(revertdiffskyfileArgs, PS_LIST_TAIL, "-label", 0, "search by label", NULL);
    134134    psMetadataAddS16(revertdiffskyfileArgs, PS_LIST_TAIL, "-fault",  0,            "search by fault code", 0);
     135    psMetadataAddBool(revertdiffskyfileArgs, PS_LIST_TAIL, "-all",  0, "allow no search terms", 0);
    135136
    136137    // -definepoprun
    … …  
    189190    psMetadataAddBool(definewarpwarpArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    190191    psMetadataAddBool(definewarpwarpArgs, PS_LIST_TAIL, "-pretend", 0, "list results but to not queue", false);
     192    psMetadataAddTime(definewarpwarpArgs, PS_LIST_TAIL, "-dateobs_begin",      0, "search for exposures by time (>=)", NULL);
     193    psMetadataAddTime(definewarpwarpArgs, PS_LIST_TAIL, "-dateobs_end",        0, "search for exposures by time (<)", NULL);
     194    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-ra_min",             0, "search by min RA (degrees) ", NAN);
     195    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-ra_max",             0, "search by max RA (degrees) ", NAN);
     196    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-decl_min",           0, "search by min DEC (degrees)", NAN);
     197    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-decl_max",           0, "search by max DEC (degrees)", NAN);
     198    psMetadataAddF32(definewarpwarpArgs,  PS_LIST_TAIL, "-airmass_min",        0, "search by min airmass", NAN);
     199    psMetadataAddF32(definewarpwarpArgs,  PS_LIST_TAIL, "-airmass_max",        0, "search by max airmass", NAN);
     200    psMetadataAddF32(definewarpwarpArgs,  PS_LIST_TAIL, "-exp_time_min",       0, "search by min exposure time", NAN);
     201    psMetadataAddF32(definewarpwarpArgs,  PS_LIST_TAIL, "-exp_time_max",       0, "search by max exposure time", NAN);
     202    psMetadataAddF32(definewarpwarpArgs,  PS_LIST_TAIL, "-sat_pixel_frac_min", 0, "search by min fraction of saturated pixels", NAN);
     203    psMetadataAddF32(definewarpwarpArgs,  PS_LIST_TAIL, "-sat_pixel_frac_max", 0, "search by max fraction of saturated pixels", NAN);
     204    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-bg_min",             0, "search by min background", NAN);
     205    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-bg_max",             0, "search by max background", NAN);
     206    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-bg_stdev_min",       0, "search by min background standard deviation", NAN);
     207    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-bg_stdev_max",       0, "search by max background standard deviation", NAN);
     208    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-bg_mean_stdev_min",  0, "search by min background mean standard deviation (across imfiles)", NAN);
     209    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-bg_mean_stdev_max",  0, "search by max background mean standard deviation (across imfiles)", NAN);
     210    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-alt_min",            0, "search by min altitude", NAN);
     211    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-alt_max",            0, "search by max altitude", NAN);
     212    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-az_min",             0, "search by min azimuth ", NAN);
     213    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-az_max",             0, "search by max azimuth ", NAN);
     214    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-ccd_temp_min",       0, "search by min ccd tempature", NAN);
     215    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-ccd_temp_max",       0, "search by max ccd tempature", NAN);
     216    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-posang_min",         0, "search by min rotator position angle", NAN);
     217    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-posang_max",         0, "search by max rotator position angle", NAN);
     218    psMetadataAddF32(definewarpwarpArgs,  PS_LIST_TAIL, "-sun_angle_min",         0, "search by min solar angle", NAN);
     219    psMetadataAddF32(definewarpwarpArgs,  PS_LIST_TAIL, "-sun_angle_max",         0, "search by max solar angle", NAN);
     220    psMetadataAddStr(definewarpwarpArgs,  PS_LIST_TAIL, "-comment",            0, "search by comment field (LIKE comparison)", NULL);
    191221
    192222    // -pendingcleanuprun

  • branches/eam_branches/20090715/ippTools/src/faketool.c

    r24733 r25022  
    157157    PXOPT_COPY_F64(config->args, where, "-posang_max", "posang", "<");
    158158    PXOPT_COPY_STR(config->args, where, "-object", "object", "==");
    159     PXOPT_COPY_F32(config->args, where, "-solang_min", "solang", ">=");
    160     PXOPT_COPY_F32(config->args, where, "-solang_max", "solang", "<");
     159    PXOPT_COPY_F32(config->args, where, "-sun_angle_min", "sun_angle", ">=");
     160    PXOPT_COPY_F32(config->args, where, "-sun_angle_max", "sun_angle", "<");
    161161    PXOPT_COPY_STR(config->args, where, "-comment", "comment", "LIKE");
    162162
    … …  
    325325    PXOPT_COPY_F64(config->args, where, "-posang_max", "posang", "<");
    326326    PXOPT_COPY_STR(config->args, where, "-object", "object", "==");
    327     PXOPT_COPY_F32(config->args, where, "-solang_min", "solang", ">=");
    328     PXOPT_COPY_F32(config->args, where, "-solang_max", "solang", "<");
     327    PXOPT_COPY_F32(config->args, where, "-sun_angle_min", "sun_angle", ">=");
     328    PXOPT_COPY_F32(config->args, where, "-sun_angle_max", "sun_angle", "<");
    329329    PXOPT_COPY_STR(config->args, where, "-label", "fakeRun.label", "==");
    330330
    … …  
    669669    PXOPT_COPY_F64(config->args, where, "-posang_max", "posang", "<");
    670670    PXOPT_COPY_STR(config->args, where, "-object", "object", "==");
    671     PXOPT_COPY_F32(config->args, where, "-solang_min", "solang", ">=");
    672     PXOPT_COPY_F32(config->args, where, "-solang_max", "solang", "<");
     671    PXOPT_COPY_F32(config->args, where, "-sun_angle_min", "sun_angle", ">=");
     672    PXOPT_COPY_F32(config->args, where, "-sun_angle_max", "sun_angle", "<");
    673673
    674674    if (!psListLength(where->list)

  • branches/eam_branches/20090715/ippTools/src/faketoolConfig.c

    r24733 r25022  
    8484    psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-posang_max",  0,            "define max rotator position angle", NAN);
    8585    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-object",  0,            "search by exposure object", NULL);
    86     psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-solang_min",  0,            "define min solar angle", NAN);
    87     psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-solang_max",  0,            "define max solar angle", NAN);
     86    psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-sun_angle_min",  0,            "define min solar angle", NAN);
     87    psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-sun_angle_max",  0,            "define max solar angle", NAN);
    8888    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_workdir",  0,            "define workdir", NULL);
    8989    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_label",  0,            "define label", NULL);
    … …  
    137137    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-posang_max",  0,            "define max rotator position angle", NAN);
    138138    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-object",  0,            "search by exposure object", NULL);
    139     psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-solang_min",  0,            "define min solar angle", NAN);
    140     psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-solang_max",  0,            "define max solar angle", NAN);
     139    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-sun_angle_min",  0,            "define min solar angle", NAN);
     140    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-sun_angle_max",  0,            "define max solar angle", NAN);
    141141    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label", 0, "search by label", NULL);
    142142
    … …  
    235235    psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-posang_max",  0,            "define max rotator position angle", NAN);
    236236    psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-object",  0,            "search by exposure object", NULL);
    237     psMetadataAddF32(revertprocessedimfileArgs, PS_LIST_TAIL, "-solang_min",  0,            "define min solar angle", NAN);
    238     psMetadataAddF32(revertprocessedimfileArgs, PS_LIST_TAIL, "-solang_max",  0,            "define max solar angle", NAN);
     237    psMetadataAddF32(revertprocessedimfileArgs, PS_LIST_TAIL, "-sun_angle_min",  0,            "define min solar angle", NAN);
     238    psMetadataAddF32(revertprocessedimfileArgs, PS_LIST_TAIL, "-sun_angle_max",  0,            "define max solar angle", NAN);
    239239
    240240    psMetadataAddBool(revertprocessedimfileArgs, PS_LIST_TAIL, "-all",  0,            "allow everything to be queued without search terms", false);

  • branches/eam_branches/20090715/ippTools/src/magicdstool.c

    r24709 r25022  
    22 * magicdstool.c
    33 *
    4  * Copyright (C) 2006-2007  IfA
     4 * Copyright (C) 2006-2009  IfA
    55 *
    66 * This program is free software; you can redistribute it and/or modify it
    … …  
    2727#include <math.h>
    2828#include <ippdb.h>
     29#include <ippStages.h>
    2930
    3031#include "pxtools.h"
    … …  
    9798static bool definebyqueryMode(pxConfig *config)
    9899{
    99     PS_ASSERT_PTR_NON_NULL(config, false);
    100     psError(PS_ERR_UNKNOWN, true, "definebyquery not implelmented yet");
    101 
    102     return false;
    103 #ifdef notyet
    104100
    105101    // Required
     102    PXOPT_LOOKUP_STR(stage, config->args, "-stage", true, false);
     103
     104    // Optional
    106105    PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", false, false);
    107 
    108     // Optional
    109     PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
    110     PXOPT_LOOKUP_STR(dvodb, config->args, "-dvodb", false, false);
    111     PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
     106    PXOPT_LOOKUP_STR(recoveryroot, config->args, "-recoveryroot", false, false);
     107    PXOPT_LOOKUP_BOOL(re_place, config->args, "-replace", false);
     108    PXOPT_LOOKUP_STR(set_label, config->args, "-set_label", false, false);
     109    PXOPT_LOOKUP_BOOL(rerun, config->args, "-rerun", false);
     110    PXOPT_LOOKUP_BOOL(dry_run, config->args, "-dry_run", false);
    112111    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    113 
    114     // Create temporary table of the best diffs
    115     {
    116         psString query = pxDataGet("magictool_definebyquery_temp_create.sql");
    117         if (!query) {
    118             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    119             return false;
    120         }
    121 
    122         if (!p_psDBRunQuery(config->dbh, query)) {
     112    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     113
     114    // search args
     115    psMetadata *where = psMetadataAlloc();
     116    PXOPT_COPY_S64(config->args, where, "-exp_id",  "exp_id", "==");
     117    PXOPT_COPY_S64(config->args, where, "-chip_id", "chip_id", "==");
     118    PXOPT_COPY_S64(config->args, where, "-cam_id",  "cam_id", "==");
     119    PXOPT_COPY_S64(config->args, where, "-warp_id", "warp_id", "==");
     120    PXOPT_COPY_S64(config->args, where, "-diff_id", "diff_id", "==");
     121    PXOPT_COPY_S64(config->args, where, "-magic_id","magic_id", "==");
     122    PXOPT_COPY_S32(config->args, where, "-streaks_max","streaks", "<=");
     123
     124    pxAddLabelSearchArgs (config, where, "-label", "magicRun.label", "==");
     125
     126    ippStage stageNum = ippStringToStage(stage);
     127   
     128    psString query = NULL;
     129    switch (stageNum) {
     130    case IPP_STAGE_RAW:
     131        query = pxDataGet("magicdstool_definebyquery_raw.sql");
     132        break;
     133    case IPP_STAGE_CHIP:
     134        query = pxDataGet("magicdstool_definebyquery_chip.sql");
     135        break;
     136    case IPP_STAGE_CAMERA:
     137        query = pxDataGet("magicdstool_definebyquery_camera.sql");
     138        break;
     139    case IPP_STAGE_WARP:
     140        query = pxDataGet("magicdstool_definebyquery_warp.sql");
     141        break;
     142    case IPP_STAGE_DIFF:
     143        query = pxDataGet("magicdstool_definebyquery_diff.sql");
     144        break;
     145    case IPP_STAGE_FAKE:
     146    case IPP_STAGE_STACK:
     147        psError(PXTOOLS_ERR_DATA, true, "%sRuns do not need to be destreaked", stage);
     148        return false;
     149    case IPP_STAGE_NONE:
     150        psError(PXTOOLS_ERR_DATA, true, "%s is not a valid stage", stage);
     151        return false;
     152    default:
     153        psError(PXTOOLS_ERR_PROG, true, "ippStageToString returned %d for invalid stage %s",
     154            stageNum, stage);
     155        return false;
     156    }
     157
     158    if (!query) {
     159        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     160        return false;
     161    }
     162    char *rerun_flag =  rerun ? "\n1 " : "\n0" ;
     163
     164    if (stageNum != IPP_STAGE_DIFF) {
     165        if (psListLength(where->list)) {
     166            psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     167            psStringAppend(&query, "\nAND %s", whereClause);
     168            psFree(whereClause);
     169        }
     170        psFree(where);
     171
     172        // treat limit == 0 as "no limit"
     173        if (limit) {
     174            psString limitString = psDBGenerateLimitSQL(limit);
     175            psStringAppend(&query, " %s", limitString);
     176            psFree(limitString);
     177        }
     178        if (!p_psDBRunQueryF(config->dbh, query, rerun_flag)) {
    123179            psError(PS_ERR_UNKNOWN, false, "database error");
    124             return false;
    125         }
    126         psFree(query);
    127     }
    128 
    129     // Insert list of best diffs into temporary table
    130     {
    131         psString query = pxDataGet("magictool_definebyquery_temp_insert.sql");
    132         if (!query) {
    133             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    134             return false;
    135         }
    136 
    137         psMetadata *where = psMetadataAlloc();
    138         PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
    139         PXOPT_COPY_STR(config->args, where, "-diff_label", "diffRun.label", "==");
    140         PXOPT_COPY_F32(config->args, where, "-good_frac", "warpSkyfile.good_frac", ">=");
    141 
    142         psString whereClause = NULL;    // WHERE conditions
    143         if (psListLength(where->list)) {
    144             whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    145             psStringPrepend(&whereClause, "\n AND ");
    146         }
    147         psFree(where);
    148 
    149         if (!p_psDBRunQueryF(config->dbh, query, whereClause)) {
    150             psError(PS_ERR_UNKNOWN, false, "database error");
    151             psFree(whereClause);
    152180            psFree(query);
    153181            return false;
    154182        }
    155         psFree(whereClause);
    156         psFree(query);
    157     }
    158 
    159     // Get list of exposures ready to magic
    160     {
    161         psString query = pxDataGet("magictool_definebyquery_select.sql");
    162         if (!query) {
    163             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    164             return false;
    165         }
    166 
    167         psString magicSkyCellNumsWhere = NULL;    // WHERE conditions for magicSkyCellNums
    168         {
    169             psMetadata *where = psMetadataAlloc();
    170             PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
    171             PXOPT_COPY_STR(config->args, where, "-diff_label", "diffRun.label", "==");
    172             PXOPT_COPY_F32(config->args, where, "-good_frac", "warpSkyfile.good_frac", ">=");
    173 
    174             if (psListLength(where->list)) {
    175                 magicSkyCellNumsWhere = psDBGenerateWhereConditionSQL(where, NULL);
    176                 psStringPrepend(&magicSkyCellNumsWhere, "\n AND ");
    177             }
    178             psFree(where);
    179         }
    180 
    181         // "available" means only concern ourselves with exposures that have all diffs completed, unless we're
    182         // told to only take what's available.
    183         // "new" means we want a new run even if there's already a magic run defined
    184         PXOPT_LOOKUP_BOOL(available, config->args, "-available", false);
    185         PXOPT_LOOKUP_BOOL(new, config->args, "-new", false);
    186 
    187         psString queryWhere = NULL;     // WHERE conditions for entire query
    188         if (available) {
    189             psStringAppend(&queryWhere, " WHERE num_done = num_todo");
    190         }
    191         if (new) {
    192             const char *newWhere = " magic_id IS NULL"; // String to add
    193             if (queryWhere) {
    194                 psStringAppend(&queryWhere, " AND %s", newWhere);
    195             } else {
    196                 psStringAppend(&queryWhere, " WHERE %s", newWhere);
    197             }
    198         }
    199         if (queryWhere) {
    200             psStringAppend(&query, " %s", queryWhere);
    201             psFree(queryWhere);
    202         }
    203 
    204 
    205         if (!p_psDBRunQueryF(config->dbh, query, magicSkyCellNumsWhere ? magicSkyCellNumsWhere : "")) {
     183    } else {
     184        // diff stage query has two types bothways and !bothways
     185        // so we need to send the rerun flag and the where data twice
     186        psString whereString = psStringCopy("");
     187        if (psListLength(where->list)) {
     188            psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     189            psStringAppend(&whereString, "\nAND %s", whereClause);
     190            psFree(whereClause);
     191        }
     192        psFree(where);
     193
     194        // treat limit == 0 as "no limit"
     195        if (limit) {
     196            psString limitString = psDBGenerateLimitSQL(limit);
     197            psStringAppend(&query, " %s", limitString);
     198            psFree(limitString);
     199        }
     200
     201        if (!p_psDBRunQueryF(config->dbh, query, rerun_flag, whereString, rerun_flag, whereString)) {
    206202            psError(PS_ERR_UNKNOWN, false, "database error");
    207             psFree(magicSkyCellNumsWhere);
     203            psFree(whereString);
    208204            psFree(query);
    209205            return false;
    210206        }
    211         psFree(magicSkyCellNumsWhere);
    212         psFree(query);
    213     }
     207        psFree(whereString);
     208    }
     209    psFree(query);
    214210
    215211    psArray *output = p_psDBFetchResult(config->dbh);
    … …  
    233229    }
    234230
    235     // Parse the list of exposures ready to magic
    236 
    237     if (!psDBTransaction(config->dbh)) {
    238         psError(PS_ERR_UNKNOWN, false, "database error");
    239         return false;
    240     }
    241 
    242     psString insert = pxDataGet("magictool_definebyquery_insert.sql"); // Insert query
     231    // Parse the list of runs ready to be destreaked
     232
     233    if (!dry_run && !psDBTransaction(config->dbh)) {
     234        psError(PS_ERR_UNKNOWN, false, "database error");
     235        return false;
     236    }
    243237
    244238    psArray *list = psArrayAllocEmpty(16); // List of runs, to print
    245239    for (long i = 0; i < psArrayLength(output); i++) {
    246240        psMetadata *row = output->data[i]; // Row of interest
    247         psS64 exp_id = psMetadataLookupS64(NULL, row, "exp_id"); // Exposure identifier
     241        psS64 stage_id = psMetadataLookupS64(NULL, row, "stage_id");
     242        psS64 exp_id = psMetadataLookupS64(NULL, row, "exp_id");
     243        psS64 magic_id = psMetadataLookupS64(NULL, row, "magic_id");
     244        psS64 inv_magic_id = psMetadataLookupS64(NULL, row, "inv_magic_id");
     245        psS64 cam_id = psMetadataLookupS64(NULL, row, "cam_id");
     246        psString magicRunLabel = psMetadataLookupStr(NULL, row, "label");
     247        psString magicRunWorkdir = psMetadataLookupStr(NULL, row, "workdir");
     248       
     249        // if workdir is not supplied use the magicRun's
     250        if (!workdir) {
     251            workdir = magicRunWorkdir;
     252        }
     253
     254        psString outroot = NULL;
     255        // set outroot to workdir/exp_id/stage for example /somewhere/424242/chip
     256        psStringAppend(&outroot, "%s/%" PRId64 "/%s", workdir, exp_id, stage);
    248257
    249258        // create a new magicRun for this group
    250         magicRunRow *run = magicRunRowAlloc(0, exp_id, "new", workdir, "dirty", label, dvodb, registered, 0);
     259        magicDSRunRow *run = magicDSRunRowAlloc(
     260                0, // magic_ds_id
     261                magic_id,
     262                inv_magic_id,
     263                "new",
     264                stage,
     265                stage_id,
     266                cam_id,
     267                set_label ? set_label : magicRunLabel,
     268                outroot,
     269                recoveryroot,
     270                re_place,
     271                0); // remove
     272
     273        psFree(outroot);
    251274        if (!run) {
    252             psAbort("failed to alloc magicRun object");
    253         }
    254 
    255         if (!magicRunInsertObject(config->dbh, run)) {
    256             psError(PS_ERR_UNKNOWN, false, "database error");
    257             psFree(run);
    258             psFree(insert);
    259             psFree(output);
    260             psFree(list);
    261             if (!psDBRollback(config->dbh)) {
     275            psAbort("failed to alloc magicDSRun object");
     276        }
     277
     278        if (!dry_run) {
     279            if (!magicDSRunInsertObject(config->dbh, run)) {
    262280                psError(PS_ERR_UNKNOWN, false, "database error");
     281                psFree(run);
     282                psFree(output);
     283                psFree(list);
     284                if (!psDBRollback(config->dbh)) {
     285                    psError(PS_ERR_UNKNOWN, false, "database error");
     286                }
     287                return false;
    263288            }
    264             return false;
    265         }
    266 
    267         psS64 magic_id = psDBLastInsertID(config->dbh); // Assigned identifier
    268         run->magic_id = magic_id;
     289            psS64 magic_ds_id = psDBLastInsertID(config->dbh); // Assigned identifier
     290            run->magic_ds_id = magic_ds_id;
     291        }
    269292
    270293        psArrayAdd(list, list->n, run);
    271294        psFree(run);
    272 
    273         // Create a suitable insertion query for this run
    274         psString thisInsert = psStringCopy(insert);
    275         {
    276             psString idString = NULL;
    277             psStringAppend(&idString, "%" PRId64, magic_id);
    278             psStringSubstitute(&thisInsert, idString, "@MAGIC_ID@");
    279             psFree(idString);
    280         }
    281         {
    282             psString idString = NULL;
    283             psStringAppend(&idString, "%" PRId64, exp_id);
    284             psStringSubstitute(&thisInsert, idString, "@EXP_ID@");
    285             psFree(idString);
    286         }
    287 
    288         if (!p_psDBRunQueryF(config->dbh, thisInsert, magic_id, exp_id)) {
    289             psError(PS_ERR_UNKNOWN, false, "database error");
    290             psFree(thisInsert);
    291             psFree(insert);
    292             psFree(output);
    293             psFree(list);
    294             if (!psDBRollback(config->dbh)) {
    295                 psError(PS_ERR_UNKNOWN, false, "database error");
    296             }
    297             return false;
    298         }
    299         psFree(thisInsert);
    300     }
    301 
    302     if (!psDBCommit(config->dbh)) {
     295    }
     296
     297    if (!dry_run && !psDBCommit(config->dbh)) {
    303298        psError(PS_ERR_UNKNOWN, false, "database error");
    304299        return false;
    … …  
    306301    psFree(output);
    307302
    308     if (!magicRunPrintObjects(stdout, list, !simple)) {
     303    if (!magicDSRunPrintObjects(stdout, list, !simple)) {
    309304        psError(PS_ERR_UNKNOWN, false, "failed to print object");
    310305        psFree(list);
    … …  
    315310
    316311    return true;
    317 #endif // notyet
    318312}
    319313
    … …  
    344338            0,          // ID
    345339            magic_id,
     340            0,          // inv_magic_id
    346341            "new",      // state
    347342            stage,
    … …  
    405400    PXOPT_COPY_S64(config->args, where, "-magic_id", "magic_id", "==");
    406401    pxAddLabelSearchArgs (config, where, "-label", "label", "==");
     402    PXOPT_COPY_STR(config->args, where, "-stage", "stage", "==");
    407403
    408404    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    … …  
    501497    psMetadata *row = output->data[0];
    502498
    503     psString stage = psMetadataLookupStr(NULL, row, "stage");
     499    psString stage= psMetadataLookupStr(NULL, row, "stage");
    504500    psS64 stage_id = psMetadataLookupS64(NULL, row, "stage_id");
    505501
    506     if (!strcmp(stage, "camera")) {
    507         // no there is no magicked column in camProcessedExp
     502    ippStage stageNum = ippStringToStage(stage);
     503
     504    // chose the appropriate query based on the stage
     505    switch (stageNum) {
     506    case IPP_STAGE_RAW:
     507        query = "UPDATE rawImfile SET magicked = %" PRId64 " where exp_id = %" PRId64 " AND class_id = '%s'";
     508        break;
     509    case IPP_STAGE_CHIP:
     510        query = "UPDATE chipProcessedImfile SET magicked = %" PRId64 " where chip_id = %" PRId64 " AND class_id = '%s'";
     511        break;
     512    case IPP_STAGE_CAMERA:
     513        // no there is no magicked column in camProcessedExp so we have nothing to do
    508514        psFree(output);
    509515        return true;
    510     }
    511 
    512     // chose the appropriate query based on the stage
    513     if (!strcmp(stage, "raw")) {
    514         query = "UPDATE rawImfile SET magicked = %" PRId64 " where exp_id = %" PRId64 " AND class_id = '%s'";
    515     } else if (!strcmp(stage, "chip")) {
    516         query = "UPDATE chipProcessedImfile SET magicked = %" PRId64 " where chip_id = %" PRId64 " AND class_id = '%s'";
    517     } else if (!strcmp(stage, "warp")) {
     516    case IPP_STAGE_WARP:
    518517        query = "UPDATE warpSkyfile SET magicked = %" PRId64 " where warp_id = %" PRId64 " AND skycell_id = '%s'";
    519     } else if (!strcmp(stage, "diff")) {
     518        break;
     519    case IPP_STAGE_DIFF:
    520520        query = "UPDATE diffSkyfile SET magicked = %" PRId64 " where diff_id = %" PRId64 " AND skycell_id = '%s'";
    521     } else {
     521        break;
     522    default:
    522523        psError(PS_ERR_UNKNOWN, true, "unexpected value for stage: %s found", stage);
    523524        psFree(output);
    524525        return false;
    525526    }
     527
    526528    if (!p_psDBRunQueryF(config->dbh, query, magic_ds_id, stage_id, component)) {
    527529        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    571573    psS64 stage_id = psMetadataLookupS64(NULL, row, "stage_id");
    572574
     575    ippStage stageNum = ippStringToStage(stage);
    573576
    574577    // chose the appropriate query based on the stage
    575     if (!strcmp(stage, "raw")) {
     578    switch (stageNum) {
     579    case IPP_STAGE_RAW:
    576580        query = "UPDATE rawExp SET magicked = %" PRId64 " where exp_id = %" PRId64;
    577     } else if (!strcmp(stage, "chip")) {
     581        break;
     582    case IPP_STAGE_CHIP:
    578583        query = "UPDATE chipRun SET magicked = %" PRId64 " where chip_id = %" PRId64;
    579     } else if (!strcmp(stage, "camera")) {
     584        break;
     585    case IPP_STAGE_CAMERA:
    580586        query = "UPDATE camRun SET magicked = %" PRId64 " where cam_id = %" PRId64;
    581     } else if (!strcmp(stage, "warp")) {
     587        break;
     588    case IPP_STAGE_WARP:
    582589        query = "UPDATE warpRun SET magicked = %" PRId64 " where warp_id = %" PRId64;
    583     } else if (!strcmp(stage, "diff")) {
     590        break;
     591    case IPP_STAGE_DIFF:
    584592        query = "UPDATE diffRun SET magicked = %" PRId64 " where diff_id = %" PRId64;
    585     } else {
     593        break;
     594    default:
    586595        psError(PS_ERR_UNKNOWN, true, "unexpected value for stage: %s found", stage);
    587596        psFree(output);
    … …  
    671680    PS_ASSERT_PTR_NON_NULL(cam_id, false);
    672681
    673     if (!strcmp(stage, "diff")) {
    674         // don't need these ids for diff stage because diff_id is in the magicRun
    675         *stage_id = 0;
    676         *cam_id = 0;
    677         return true;
    678     }
    679 
    680     int stageNum;
    681     if (!strcmp(stage, "raw")) {
    682         stageNum = 0;
    683     } else if (!strcmp(stage, "chip")) {
    684         stageNum = 1;
    685     } else if (!strcmp(stage, "camera")) {
    686         stageNum = 2;
    687     } else if (!strcmp(stage, "warp")) {
    688         stageNum = 3;
    689     } else {
    690         psError(PXTOOLS_ERR_DATA, true, "%s is not a valid value for stage", stage);
    691         return false;
    692     }
    693 
     682    int stageNum = ippStringToStage(stage);;
     683    if (stageNum == IPP_STAGE_NONE) {
     684        psError(PXTOOLS_ERR_DATA, false, "%s is not a valid value for stage", stage);
     685        return false;
     686    }
    694687
    695688    psString query = pxDataGet("magicdstool_getrunids.sql");
    … …  
    724717
    725718    *cam_id = psMetadataLookupS64(NULL, row, "cam_id");
    726     if (stageNum == 0) {
     719    switch (stageNum) {
     720    case IPP_STAGE_RAW:
    727721        *stage_id = psMetadataLookupS64(NULL, row, "exp_id");
    728     } else if (stageNum == 1) {
     722        break;
     723    case IPP_STAGE_CHIP:
    729724        *stage_id = psMetadataLookupS64(NULL, row, "chip_id");
    730     } else if (stageNum == 2) {
     725        break;
     726    case IPP_STAGE_CAMERA:
    731727        *stage_id = *cam_id;
    732     } else if (stageNum == 3) {
     728        return true;
     729    case IPP_STAGE_WARP:
    733730        *stage_id = psMetadataLookupS64(NULL, row, "warp_id");
     731        break;
     732    case IPP_STAGE_DIFF:
     733        *stage_id = psMetadataLookupS64(NULL, row, "diff_id");
     734        break;
    734735    }
    735736

  • branches/eam_branches/20090715/ippTools/src/magicdstoolConfig.c

    r24693 r25022  
    4949    // -definebyquery
    5050    psMetadata *definebyqueryArgs = psMetadataAlloc();
    51 #ifdef notyet
    52     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-workdir",     0, "define workdir (required)", NULL);
    53     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-label",       0, "define label", NULL);
    54     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-dvodb",       0, "define dvodb", NULL);
    55     psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-registered", 0, "time detrend run was registered", now);
    56     psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-exp_id", 0, "search exp_id", 0);
    57     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-diff_label", 0, "select diff label", NULL);
    58     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-good_frac", 0, "limit good_frac", NAN);
    59     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-available", 0, "process what's immediately available?", false);
    60     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-new", 0, "generate new run even if existing?", false);
    61     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    62 #endif
     51    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-stage",       0, "define stage (required)", NULL);
     52    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-workdir",     0, "define workdir", NULL);
     53    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-recoveryroot", 0, "define recovery directory", NULL);
     54    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-replace", 0, "replace input files with the destreaked versions", false);
     55    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_label",    0, "define label", NULL);
     56
     57    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by magicRun.label", NULL);
     58    psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-exp_id",   0, "search by exp_id", 0);
     59    psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-chip_id",  0, "search by chip_id", 0);
     60    psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-cam_id",  0, "search by cam_id", 0);
     61    psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-warp_id",  0, "search by warp_id", 0);
     62    psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-diff_id",  0, "search by diff_id", 0);
     63    psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-magic_id", 0, "search by magic_id", 0);
     64    psMetadataAddS32(definebyqueryArgs, PS_LIST_TAIL, "-streaks_max", 0, "maximum number of streaks", 0);
     65
     66    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-rerun",   0, "queue a new run even if one arleady exists", false);
     67    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-dry_run", 0, "don't queue runs just display what would be queued", false);
     68    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-simple",  0, "use the simple output format", false);
     69    psMetadataAddU64(definebyqueryArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
    6370
    6471    // -definerun
    6572    psMetadata *definerunArgs = psMetadataAlloc();
    6673    psMetadataAddS64(definerunArgs, PS_LIST_TAIL, "-magic_id", 0, "define magic_id (required)", 0);
    67     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-stage", 0, "define output directory (required)", NULL);
     74    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-stage", 0, "define stage for run (required)", NULL);
    6875    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-outroot", 0, "define output directory (required)", NULL);
    6976    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-recoveryroot", 0, "define recovery directory", NULL);
    … …  
    8996    psMetadataAddS64(todestreakArgs, PS_LIST_TAIL, "-magic_id", 0, "search by magic ID", 0);
    9097    psMetadataAddStr(todestreakArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "define label", NULL);
     98    psMetadataAddStr(todestreakArgs, PS_LIST_TAIL, "-stage", 0, "limit query to stage", NULL);
    9199    psMetadataAddU64(todestreakArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
    92100    psMetadataAddBool(todestreakArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);

  • branches/eam_branches/20090715/ippTools/src/magictool.c

    r24551 r25022  
    4747static bool revertmaskMode(pxConfig *config);
    4848static bool maskMode(pxConfig *config);
     49static bool censorrunMode(pxConfig *config);
    4950
    5051static bool setmagicRunState(pxConfig *config, psS64 magic_id, const char *state);
    … …  
    8586        MODECASE(MAGICTOOL_MODE_REVERTMASK,          revertmaskMode);
    8687        MODECASE(MAGICTOOL_MODE_MASK,                maskMode);
     88        MODECASE(MAGICTOOL_MODE_CENSORRUN,           censorrunMode);
    8789        default:
    8890            psAbort("invalid option (this should not happen)");
    … …  
    580582    PXOPT_COPY_S64(config->args, where, "-magic_id", "magic_id", "==");
    581583    PXOPT_COPY_S16(config->args, where, "-fault", "fault", "==");
     584    PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
    582585
    583586    psString query = psStringCopy("UPDATE magicRun SET fault = 0, state = 'new' WHERE fault != 0");
    … …  
    801804    // treat limit == 0 as "no limit"
    802805    if (limit) {
    803         psString limitString = psDBGenerateLimitSQL(limit);
     806        // cut limit in half
     807        // hack to prevent pending leaf nodes from blocking branch nodes
     808        psString limitString = psDBGenerateLimitSQL((limit + 1) / 2);
    804809        psStringAppend(&query, " %s", limitString);
    805810        psFree(limitString);
    … …  
    847852
    848853    // look for tree nodes that need to be processed
    849     // XXX: This gets all nodes from all magicRuns that are in 'new'state
    850     // That doens't seem particularly efficient
    851     query = pxDataGet("magictool_toprocess_tree.sql");
     854    query = pxDataGet("magictool_toprocess_runs.sql");
    852855    if (!query) {
    853856        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    … …  
    855858    }
    856859
     860    {
     861        psString limitString = psDBGenerateLimitSQL( 100 );
     862        psStringAppend(&query, " %s", limitString);
     863        psFree(limitString);
     864    }
    857865
    858866    if (!p_psDBRunQueryF(config->dbh, query, whereString ? whereString :  "")) {
    … …  
    865873    psFree(query);
    866874
    867     psArray *magicTree = p_psDBFetchResult(config->dbh);
    868     if (!magicTree) {
     875    psArray *magicRuns = p_psDBFetchResult(config->dbh);
     876    if (!magicRuns) {
    869877        psErrorCode err = psErrorCodeLast();
    870878        switch (err) {
    … …  
    879887        return false;
    880888    }
    881     if (!psArrayLength(magicTree)) {
     889    if (!psArrayLength(magicRuns)) {
    882890        psTrace("magictool", PS_LOG_INFO, "no rows found");
    883         psFree(magicTree);
     891        psFree(magicRuns);
    884892        return true;
    885893    }
    886894
    887     // entries are ordered by magic_id
    888     long index = 0;
    889     while (index <  psArrayLength(magicTree)) {
    890         bool status;
     895    query = pxDataGet("magictool_toprocess_tree.sql");
     896    if (!query) {
     897        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     898        return false;
     899    }
     900
     901    for (psS64 index = 0; index < psArrayLength(magicRuns); index++) {
    891902        if (limit && (psArrayLength(output) >= limit)) {
    892903            break;
    893904        }
    894         psS64 current_magic_id = psMetadataLookupS64(&status, magicTree->data[index], "magic_id");
     905        bool status;
     906        psS64 magic_id = psMetadataLookupS64(&status, magicRuns->data[index], "magic_id");
    895907        if (!status) {
    896908            psAbort("failed to lookup value for magic_id column");
    897909        }
    898 
    899         // find the end of this block
    900         long first = index;
    901         long last = index;
    902         for (long i = index + 1; i < psArrayLength(magicTree); i++) {
    903             psS64 magic_id = psMetadataLookupS64(&status, magicTree->data[i], "magic_id");
    904             if (!status) {
    905                 psAbort("failed to lookup value for magic_id column");
     910       
     911        whereString = NULL;
     912        psStringAppend(&whereString, "\nAND (magic_id = %" PRId64 ")", magic_id);
     913        if (!p_psDBRunQueryF(config->dbh, query, whereString )) {
     914            psError(PS_ERR_UNKNOWN, false, "database error");
     915            psFree(whereString);
     916            psFree(query);
     917            return false;
     918        }
     919        psFree(whereString);
     920        psArray *magicTree = p_psDBFetchResult(config->dbh);
     921        if (!magicTree) {
     922            psErrorCode err = psErrorCodeLast();
     923            switch (err) {
     924                case PS_ERR_DB_CLIENT:
     925                    psError(PXTOOLS_ERR_SYS, false, "database error");
     926                case PS_ERR_DB_SERVER:
     927                    psError(PXTOOLS_ERR_PROG, false, "database error");
     928                default:
     929                    psError(PXTOOLS_ERR_PROG, false, "unknown error");
    906930            }
    907             if (magic_id != current_magic_id) {
    908                 break;
    909             }
    910             last = i;
    911         }
    912 
    913         index = last + 1;
    914 
    915         psHash *forest = psHashAlloc(last - first + 1);
     931
     932            return false;
     933        }
     934        psS64 length = psArrayLength(magicTree);
     935        if (!length) {
     936            psTrace("magictool", PS_LOG_INFO, "no rows found for magic_id %" PRId64, magic_id);
     937            psFree(magicTree);
     938            continue;
     939        }
     940
     941        psHash *forest = psHashAlloc(length);
    916942
    917943        // convert the array of metadata into a pxTree structure
    918         for (long i = first; i <= last; i++) {
     944        for (long i = 0; i < length; i++) {
    919945            bool status;
    920946            psString node = psMetadataLookupStr(&status, magicTree->data[i], "node");
    … …  
    941967        pxTreeCrawl(root, findReadyNodes, output);
    942968        psFree(root);
    943 
    944     }
    945     psFree(magicTree);
     969        psFree(magicTree);
     970    }
    946971
    947972    if (psArrayLength(output)) {
    … …  
    13671392    return true;
    13681393}
     1394
     1395static bool censorStage(pxConfig *config, psString stage, psString whereClause)
     1396{
     1397    psString queryFile = NULL;
     1398    psStringAppend(&queryFile, "magictool_censor_%s.sql", stage);
     1399    psString query = pxDataGet(queryFile);
     1400    if (!query) {
     1401        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement from %s", queryFile);
     1402        psFree(queryFile);
     1403        if (!psDBRollback(config->dbh)) {
     1404            psError(PS_ERR_UNKNOWN, false, "database error");
     1405        }
     1406        return false;
     1407    }
     1408    psFree(queryFile);
     1409
     1410    psStringAppend(&query, " WHERE %s",  whereClause);
     1411
     1412    if (!p_psDBRunQuery(config->dbh, query)) {
     1413        psError(PS_ERR_UNKNOWN, false, "database error");
     1414        psFree(query);
     1415        if (!psDBRollback(config->dbh)) {
     1416            psError(PS_ERR_UNKNOWN, false, "database error");
     1417        }
     1418        return false;
     1419    }
     1420    psFree(query);
     1421
     1422    return true;
     1423}
     1424
     1425static bool censorrunMode(pxConfig *config)
     1426{
     1427    PS_ASSERT_PTR_NON_NULL(config, false);
     1428
     1429    psError(PS_ERR_PROGRAMMING, true, "-censorrun mode not ready yet");
     1430    return false;
     1431
     1432    psMetadata *where = psMetadataAlloc();
     1433
     1434    // at least one of these required
     1435    PXOPT_COPY_S64(config->args, where, "-magic_id", "magic_id", "==");
     1436    PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
     1437
     1438    if (!psListLength(where->list)) {
     1439        psError(PS_ERR_UNKNOWN, true, "either -exp_id or -magic_id is required");
     1440        psFree(where);
     1441        return false;
     1442    }
     1443
     1444    psString query = psStringCopy("UPDATE magicRun SET state = 'censored'");
     1445
     1446    psString whereClause = psDBGenerateWhereConditionSQL(where, "magicRun");
     1447    psFree(where);
     1448    psStringAppend(&query, " WHERE %s", whereClause);
     1449
     1450    if (!psDBTransaction(config->dbh)) {
     1451        psError(PS_ERR_UNKNOWN, false, "database error");
     1452        return false;
     1453    }
     1454
     1455    if (!p_psDBRunQuery(config->dbh, query)) {
     1456        psError(PS_ERR_UNKNOWN, false, "database error");
     1457        psFree(whereClause);
     1458        psFree(query);
     1459        return false;
     1460    }
     1461    psFree(query);
     1462
     1463    psS32 numUpdated = psDBAffectedRows(config->dbh);
     1464    if (numUpdated == 0) {
     1465        psError(PS_ERR_UNKNOWN, false, "failed to censor magicRun");
     1466        psFree(whereClause);
     1467        return false;
     1468    }
     1469
     1470    // Now queue any destreaked files to be re-verted
     1471
     1472    // note: on failure censorStage issues the rollback
     1473    if (!censorStage(config, "raw", whereClause)) {
     1474        psFree(whereClause);
     1475        return false;
     1476    }
     1477    if (!censorStage(config, "chip", whereClause)) {
     1478        psFree(whereClause);
     1479        return false;
     1480    }
     1481    if (!censorStage(config, "camera", whereClause)) {
     1482        psFree(whereClause);
     1483        return false;
     1484    }
     1485    if (!censorStage(config, "warp", whereClause)) {
     1486        psFree(whereClause);
     1487        return false;
     1488    }
     1489    if (!censorStage(config, "diff", whereClause)) {
     1490        psFree(whereClause);
     1491        return false;
     1492    }
     1493
     1494    psFree(whereClause);
     1495
     1496    if (!psDBCommit(config->dbh)) {
     1497        psError(PS_ERR_UNKNOWN, false, "database error");
     1498        return false;
     1499    }
     1500
     1501    return true;
     1502}

  • branches/eam_branches/20090715/ippTools/src/magictool.h

    r20700 r25022  
    4141    MAGICTOOL_MODE_REVERTMASK,
    4242    MAGICTOOL_MODE_MASK,
    43     MAGICTOOL_MODE_DIFFSKYFILE,
    44     MAGICTOOL_MODE_WARPSKYFILE,
    45     MAGICTOOL_MODE_CHIPPROCESSEDIMFILE,
    46     MAGICTOOL_MODE_RAWIMFILE,
     43    MAGICTOOL_MODE_CENSORRUN,
    4744} MAGICtoolMode;
    4845

  • branches/eam_branches/20090715/ippTools/src/magictoolConfig.c

    r24551 r25022  
    108108    psMetadataAddS64(reverttreeArgs, PS_LIST_TAIL, "-magic_id", 0, "search by magictool ID", 0);
    109109    psMetadataAddS16(reverttreeArgs, PS_LIST_TAIL, "-fault", 0, "search by fault code", 0);
     110    psMetadataAddStr(reverttreeArgs, PS_LIST_TAIL, "-label", 0, "search by label", NULL);
    110111
    111112    // -inputs
    … …  
    160161    psMetadataAddBool(maskArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    161162
    162 #ifdef notdef
    163     // -diffskyfile
    164     psMetadata *diffskyfileArgs = psMetadataAlloc();
    165     psMetadataAddS64(diffskyfileArgs, PS_LIST_TAIL, "-magic_id", 0, "define magictool ID (required)", 0);
    166     psMetadataAddStr(diffskyfileArgs, PS_LIST_TAIL, "-class_id", 0, "define class identifier", NULL);
    167     psMetadataAddStr(diffskyfileArgs, PS_LIST_TAIL, "-skycell_id", 0, "define skycell identifier", NULL);
    168     psMetadataAddBool(diffskyfileArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    169 
    170     // -warpskyfile
    171     psMetadata *warpskyfileArgs = psMetadataAlloc();
    172     psMetadataAddS64(warpskyfileArgs, PS_LIST_TAIL, "-magic_id", 0, "define magictool ID (required)", 0);
    173     psMetadataAddBool(warpskyfileArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    174     psMetadataAddStr(warpskyfileArgs, PS_LIST_TAIL, "-skycell_id", 0, "define skycell identifier", NULL);
    175 
    176     // -chipprocessedimfile
    177     psMetadata *chipprocessedimfileArgs = psMetadataAlloc();
    178     psMetadataAddS64(chipprocessedimfileArgs, PS_LIST_TAIL, "-magic_id", 0, "define magictool ID (required)", 0);
    179     psMetadataAddStr(chipprocessedimfileArgs, PS_LIST_TAIL, "-class_id", 0, "define class identifier", NULL);
    180     psMetadataAddBool(chipprocessedimfileArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    181 
    182     // -rawimfile
    183     psMetadata *rawimfileArgs = psMetadataAlloc();
    184     psMetadataAddS64(rawimfileArgs, PS_LIST_TAIL, "-magic_id", 0, "define magictool ID (required)", 0);
    185     psMetadataAddStr(rawimfileArgs, PS_LIST_TAIL, "-class_id", 0, "define class identifier", NULL);
    186     psMetadataAddBool(rawimfileArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    187 #endif // notdef
     163    // -censorun
     164    psMetadata *censorrunArgs = psMetadataAlloc();
     165    psMetadataAddS64(censorrunArgs, PS_LIST_TAIL, "-magic_id", 0, "define magictool ID", 0);
     166    psMetadataAddS64(censorrunArgs, PS_LIST_TAIL, "-exp_id", 0, "define exposure ID", 0);
    188167
    189168    psFree(now);
    … …  
    208187    PXOPT_ADD_MODE("-revertmask",          "", MAGICTOOL_MODE_REVERTMASK,          revertmaskArgs);
    209188    PXOPT_ADD_MODE("-mask",                "", MAGICTOOL_MODE_MASK,                maskArgs);
    210 #ifdef notdef
    211     PXOPT_ADD_MODE("-diffskyfile",         "", MAGICTOOL_MODE_DIFFSKYFILE,         diffskyfileArgs);
    212     PXOPT_ADD_MODE("-warpskyfile",         "", MAGICTOOL_MODE_WARPSKYFILE,         warpskyfileArgs);
    213     PXOPT_ADD_MODE("-chipprocessedimfile", "", MAGICTOOL_MODE_CHIPPROCESSEDIMFILE, chipprocessedimfileArgs);
    214     PXOPT_ADD_MODE("-rawimfile",           "", MAGICTOOL_MODE_RAWIMFILE,           rawimfileArgs);
    215 #endif
     189    PXOPT_ADD_MODE("-censorrun",           "", MAGICTOOL_MODE_CENSORRUN,           censorrunArgs);
    216190
    217191    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {

  • branches/eam_branches/20090715/ippTools/src/pstamptool.c

    r21412 r25022  
    3434static bool datastoreMode(pxConfig *config);
    3535static bool moddatastoreMode(pxConfig *config);
    36 static bool addReqMode(pxConfig *config);
    37 static bool completedReqMode(pxConfig *config);
    38 static bool listReqMode(pxConfig *config);
    39 static bool pendingReqMode(pxConfig *config);
    40 static bool updateReqMode(pxConfig *config);
    41 static bool revertReqMode(pxConfig *config);
    42 static bool addJobMode(pxConfig *config);
    43 static bool listJobMode(pxConfig *config);
    44 static bool pendingJobMode(pxConfig *config);
    45 static bool updateJobMode(pxConfig *config);
    46 static bool addProjectMode(pxConfig *config);
     36static bool addreqMode(pxConfig *config);
     37static bool completedreqMode(pxConfig *config);
     38static bool listreqMode(pxConfig *config);
     39static bool pendingreqMode(pxConfig *config);
     40static bool updatereqMode(pxConfig *config);
     41static bool revertreqMode(pxConfig *config);
     42static bool addjobMode(pxConfig *config);
     43static bool listjobMode(pxConfig *config);
     44static bool pendingjobMode(pxConfig *config);
     45static bool updatejobMode(pxConfig *config);
     46static bool addprojectMode(pxConfig *config);
    4747static bool projectMode(pxConfig *config);
    48 static bool modProjectMode(pxConfig *config);
     48static bool modprojectMode(pxConfig *config);
    4949
    5050# define MODECASE(caseName, func) \
    … …  
    7070        MODECASE(PSTAMPTOOL_MODE_DATASTORE, datastoreMode);
    7171        MODECASE(PSTAMPTOOL_MODE_MODDATASTORE, moddatastoreMode);
    72         MODECASE(PSTAMPTOOL_MODE_ADDREQ, addReqMode);
    73         MODECASE(PSTAMPTOOL_MODE_COMPLETEDREQ, completedReqMode);
    74         MODECASE(PSTAMPTOOL_MODE_LISTREQ, listReqMode);
    75         MODECASE(PSTAMPTOOL_MODE_PENDINGREQ, pendingReqMode);
    76         MODECASE(PSTAMPTOOL_MODE_UPDATEREQ, updateReqMode);
    77         MODECASE(PSTAMPTOOL_MODE_REVERTREQ, revertReqMode);
    78         MODECASE(PSTAMPTOOL_MODE_ADDJOB, addJobMode);
    79         MODECASE(PSTAMPTOOL_MODE_LISTJOB, listJobMode);
    80         MODECASE(PSTAMPTOOL_MODE_PENDINGJOB, pendingJobMode);
    81         MODECASE(PSTAMPTOOL_MODE_UPDATEJOB, updateJobMode);
    82         MODECASE(PSTAMPTOOL_MODE_ADDPROJECT, addProjectMode);
    83         MODECASE(PSTAMPTOOL_MODE_MODPROJECT, modProjectMode);
     72        MODECASE(PSTAMPTOOL_MODE_ADDREQ, addreqMode);
     73        MODECASE(PSTAMPTOOL_MODE_COMPLETEDREQ, completedreqMode);
     74        MODECASE(PSTAMPTOOL_MODE_LISTREQ, listreqMode);
     75        MODECASE(PSTAMPTOOL_MODE_PENDINGREQ, pendingreqMode);
     76        MODECASE(PSTAMPTOOL_MODE_UPDATEREQ, updatereqMode);
     77        MODECASE(PSTAMPTOOL_MODE_REVERTREQ, revertreqMode);
     78        MODECASE(PSTAMPTOOL_MODE_ADDJOB, addjobMode);
     79        MODECASE(PSTAMPTOOL_MODE_LISTJOB, listjobMode);
     80        MODECASE(PSTAMPTOOL_MODE_PENDINGJOB, pendingjobMode);
     81        MODECASE(PSTAMPTOOL_MODE_UPDATEJOB, updatejobMode);
     82        MODECASE(PSTAMPTOOL_MODE_ADDPROJECT, addprojectMode);
     83        MODECASE(PSTAMPTOOL_MODE_MODPROJECT, modprojectMode);
    8484        MODECASE(PSTAMPTOOL_MODE_PROJECT, projectMode);
    8585        default:
    … …  
    220220}
    221221
    222 static bool addReqMode(pxConfig *config)
     222static bool addreqMode(pxConfig *config)
    223223{
    224224    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    251251}
    252252
    253 static bool pendingReqMode(pxConfig *config)
     253static bool pendingreqMode(pxConfig *config)
    254254{
    255255    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    311311}
    312312
    313 static bool listReqMode(pxConfig *config)
     313static bool listreqMode(pxConfig *config)
    314314{
    315315    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    359359}
    360360
    361 static bool completedReqMode(pxConfig *config)
     361static bool completedreqMode(pxConfig *config)
    362362{
    363363    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    408408}
    409409
    410 static bool updateReqMode(pxConfig *config)
     410static bool updatereqMode(pxConfig *config)
    411411{
    412412    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    472472}
    473473
    474 static bool revertReqMode(pxConfig *config)
     474static bool revertreqMode(pxConfig *config)
    475475{
    476476    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    493493}
    494494
    495 static bool addJobMode(pxConfig *config)
     495static bool addjobMode(pxConfig *config)
    496496{
    497497    bool    stampJob = false;
    … …  
    500500    PS_ASSERT_PTR_NON_NULL(config, false);
    501501
    502     PXOPT_LOOKUP_S64(uri,         config->args, "-uri",        true, false);
    503502    PXOPT_LOOKUP_S64(req_id,      config->args, "-req_id",     true, false);
    504503    PXOPT_LOOKUP_STR(rownum,      config->args, "-rownum",     true, false);
    505504    PXOPT_LOOKUP_STR(job_type,    config->args, "-job_type",   false, false);
    506505    PXOPT_LOOKUP_STR(outputBase,  config->args, "-outputBase", true,  false);
    507     PXOPT_LOOKUP_STR(argString,   config->args, "-args",       false, false);
    508506    PXOPT_LOOKUP_STR(stateString, config->args, "-state",      false, false);
    509507    PXOPT_LOOKUP_STR(fault,       config->args, "-fault",      false, false);
    … …  
    519517        return false;
    520518    }
    521 
    522     if (stampJob && !argString) {
    523         psError(PS_ERR_UNKNOWN, true, "-args is required for stamp job");
    524         return false;
    525     }
    526 
    527519    if (stampJob) {
    528520        query = pxDataGet("pstamptool_addjob_stampjob.sql");
    … …  
    535527    }
    536528
    537     if (!p_psDBRunQueryF(config->dbh, query, req_id, rownum, stateString, job_type, uri, exp_id, outputBase, fault, argString)) {
     529    if (!p_psDBRunQueryF(config->dbh, query, req_id, rownum, stateString, job_type, exp_id, outputBase, fault)) {
    538530        psError(PS_ERR_UNKNOWN, false, "database error");
    539531        return false;
    … …  
    554546}
    555547
    556 static bool listJobMode(pxConfig *config)
     548static bool listjobMode(pxConfig *config)
    557549{
    558550    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    626618}
    627619
    628 static bool pendingJobMode(pxConfig *config)
     620static bool pendingjobMode(pxConfig *config)
    629621{
    630622    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    688680}
    689681
    690 static bool updateJobMode(pxConfig *config)
     682static bool updatejobMode(pxConfig *config)
    691683{
    692684    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    723715    return true;
    724716}
    725 static bool addProjectMode(pxConfig *config)
     717static bool addprojectMode(pxConfig *config)
    726718{
    727719    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    801793    return true;
    802794}
    803 static bool modProjectMode(pxConfig *config)
     795static bool modprojectMode(pxConfig *config)
    804796{
    805797    PS_ASSERT_PTR_NON_NULL(config, false);

  • branches/eam_branches/20090715/ippTools/src/pstamptoolConfig.c

    r20151 r25022  
    100100    // -addjob
    101101    psMetadata *addjobArgs = psMetadataAlloc();
    102     psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-uri", 0,            "define job file uri", NULL);
    103102    psMetadataAddS64(addjobArgs, PS_LIST_TAIL, "-req_id", 0,            "define job req_id", 0);
    104103    psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-rownum", 0,            "define job rownum", NULL);
    105104    psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-job_type", 0,            "define job job_type", "stamp");
    106105    psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-outputBase", 0,            "define job outputBase", NULL);
    107     psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-args", 0,            "define job args", NULL);
    108106    psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-state", 0,            "new state", "run");
    109107    psMetadataAddS64(addjobArgs, PS_LIST_TAIL, "-exp_id", 0,           "exposure id", 0);
    … …  
    128126    psMetadataAddS64(updatejobArgs, PS_LIST_TAIL, "-job_id", 0,            "req_id for which to change state", 0);
    129127    psMetadataAddStr(updatejobArgs, PS_LIST_TAIL, "-state", 0,            "new state", NULL);
    130     // psMetadataAddStr(updatejobArgs, PS_LIST_TAIL, "-result", 0,            "new result", NULL);
    131128    psMetadataAddStr(updatejobArgs, PS_LIST_TAIL, "-fault", 0,            "new result", NULL);
    132129

  • branches/eam_branches/20090715/ippTools/src/pxcam.c

    r24733 r25022  
    6868    psMetadataAddF64(md,  PS_LIST_TAIL, "-posang_max",         0, "define max rotator position angle", NAN);
    6969    psMetadataAddStr(md,  PS_LIST_TAIL, "-object",             0, "search by exposure object", NULL);
    70     psMetadataAddF32(md,  PS_LIST_TAIL, "-solang_min",         0, "define min solar angle", NAN);
    71     psMetadataAddF32(md,  PS_LIST_TAIL, "-solang_max",         0, "define max solar angle", NAN);
     70    psMetadataAddF32(md,  PS_LIST_TAIL, "-sun_angle_min",         0, "define min solar angle", NAN);
     71    psMetadataAddF32(md,  PS_LIST_TAIL, "-sun_angle_max",         0, "define max solar angle", NAN);
    7272
    7373    return true;
    … …  
    113113    PXOPT_COPY_F64(config->args,   where, "-posang_max",         "rawExp.posang",         "<");
    114114    PXOPT_COPY_STR(config->args,   where, "-object",             "rawExp.object",         "==");
    115     PXOPT_COPY_F32(config->args,   where, "-solang_min",         "rawExp.solang",         ">=");
    116     PXOPT_COPY_F32(config->args,   where, "-solang_max",         "rawExp.solang",         "<");
     115    PXOPT_COPY_F32(config->args,   where, "-sun_angle_min",         "rawExp.sun_angle",         ">=");
     116    PXOPT_COPY_F32(config->args,   where, "-sun_angle_max",         "rawExp.sun_angle",         "<");
    117117
    118118    return true;

  • branches/eam_branches/20090715/ippTools/src/pxchip.c

    r24733 r25022  
    6969    psMetadataAddF64(md,  PS_LIST_TAIL, "-posang_min",         0, "search by min rotator position angle", NAN);
    7070    psMetadataAddF64(md,  PS_LIST_TAIL, "-posang_max",         0, "search by max rotator position angle", NAN);
    71     psMetadataAddF32(md,  PS_LIST_TAIL, "-solang_min",         0, "search by min solar angle", NAN);
    72     psMetadataAddF32(md,  PS_LIST_TAIL, "-solang_max",         0, "search by max solar angle", NAN);
     71    psMetadataAddF32(md,  PS_LIST_TAIL, "-sun_angle_min",         0, "search by min solar angle", NAN);
     72    psMetadataAddF32(md,  PS_LIST_TAIL, "-sun_angle_max",         0, "search by max solar angle", NAN);
    7373    psMetadataAddStr(md,  PS_LIST_TAIL, "-object",             0, "search by exposure object", NULL);
    7474    psMetadataAddStr(md,  PS_LIST_TAIL, "-comment",            0, "search by comment field (LIKE comparison)", NULL);
    … …  
    122122    PXOPT_COPY_F64(config->args, where, "-posang_max", "rawExp.posang", "<");
    123123    PXOPT_COPY_STR(config->args, where, "-object", "rawExp.object", "==");
    124     PXOPT_COPY_F32(config->args, where, "-solang_min", "rawExp.solang", ">=");
    125     PXOPT_COPY_F32(config->args, where, "-solang_max", "rawExp.solang", "<");
     124    PXOPT_COPY_F32(config->args, where, "-sun_angle_min", "rawExp.sun_angle", ">=");
     125    PXOPT_COPY_F32(config->args, where, "-sun_angle_max", "rawExp.sun_angle", "<");
    126126    PXOPT_COPY_STR(config->args, where, "-comment", "rawExp.comment", "LIKE");
    127127    PXOPT_COPY_STR(config->args, where, "-obs_mode", "rawExp.obs_mode", "==");

  • branches/eam_branches/20090715/ippTools/src/regtool.c

    r24733 r25022  
    923923    PXOPT_COPY_F64(config->args,   where,  "-posang_max", "posang", "<");
    924924    PXOPT_COPY_STR(config->args,   where,  "-object", "object", "==");
    925     PXOPT_COPY_F32(config->args,   where,  "-solang_min", "solang", ">=");
    926     PXOPT_COPY_F32(config->args,   where,  "-solang_max", "solang", "<");
     925    PXOPT_COPY_F32(config->args,   where,  "-sun_angle_min", "sun_angle", ">=");
     926    PXOPT_COPY_F32(config->args,   where,  "-sun_angle_max", "sun_angle", "<");
    927927
    928928    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);

  • branches/eam_branches/20090715/ippTools/src/regtoolConfig.c

    r24733 r25022  
    138138    ADD_OPT(Bool, processedimfileArgs, "-faulted",   "only return imfiles with a fault status set", false);
    139139    ADD_OPT(Bool, processedimfileArgs, "-simple",    "use the simple output format",          false);
     140    ADD_OPT(Bool, processedimfileArgs, "-ordered_by_date", "force output to be in DATE order", false);
    140141
    141142    // -revertprocessedimfile
    … …  
    273274    psMetadataAddF64(processedexpArgs,  PS_LIST_TAIL, "-posang_max",    0,            "search by max rotator position angle", NAN);
    274275    psMetadataAddStr(processedexpArgs,  PS_LIST_TAIL, "-object",        0,            "search by exposure object", NULL);
    275     psMetadataAddF32(processedexpArgs,  PS_LIST_TAIL, "-solang_min",    0,            "define min solar angle", NAN);
    276     psMetadataAddF32(processedexpArgs,  PS_LIST_TAIL, "-solang_max",    0,            "define max solar angle", NAN);
     276    psMetadataAddF32(processedexpArgs,  PS_LIST_TAIL, "-sun_angle_min",    0,         "define min solar angle", NAN);
     277    psMetadataAddF32(processedexpArgs,  PS_LIST_TAIL, "-sun_angle_max",    0,         "define max solar angle", NAN);
    277278
    278279    psMetadataAddU64(processedexpArgs,  PS_LIST_TAIL, "-limit",         0,            "limit result set to N items", 0);

  • branches/eam_branches/20090715/ippTools/src/stacktool.c

    r24736 r25022  
    133133    PXOPT_COPY_F32(config->args,  where, "-select_posang_min",         "rawExp.posang", ">=");
    134134    PXOPT_COPY_F32(config->args,  where, "-select_posang_max",         "rawExp.posang", "<=");
    135     PXOPT_COPY_F32(config->args,  where, "-select_solang_min",         "rawExp.solang", ">=");
    136     PXOPT_COPY_F32(config->args,  where, "-select_solang_max",         "rawExp.solang", "<=");
     135    PXOPT_COPY_F32(config->args,  where, "-select_sun_angle_min",      "rawExp.sun_angle", ">=");
     136    PXOPT_COPY_F32(config->args,  where, "-select_sun_angle_max",      "rawExp.sun_angle", "<=");
    137137    PXOPT_COPY_F32(config->args,  where, "-select_fwhm_major_min",     "camProcessedExp.fwhm_major", ">=");
    138138    PXOPT_COPY_F32(config->args,  where, "-select_fwhm_major_max",     "camProcessedExp.fwhm_major", "<=");
    … …  
    857857    PXOPT_COPY_S64(config->args, where, "-exp_id", "rawExp.exp_id", "==");
    858858    PXOPT_COPY_STR(config->args, where, "-exp_name", "rawExp.exp_name", "==");
     859    PXOPT_COPY_STR(config->args, where, "-tess_id", "stackRun.tess_id", "==");
     860    PXOPT_COPY_STR(config->args, where, "-skycell_id", "stackRun.skycell_id", "==");
    859861
    860862    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    … …  
    931933    PXOPT_COPY_S16(config->args, where, "-fault", "stackSumSkyfile.fault", "==");
    932934
    933     if (!psDBTransaction(config->dbh)) {
    934         psError(PS_ERR_UNKNOWN, false, "database error");
     935    if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
    935936        psFree(where);
    936         return false;
    937     }
    938 
    939     int numStacks;                      // Number of stacks affected
    940 
    941     // Update state to 'new'
    942     {
    943         psString update = pxDataGet("stacktool_revertsumskyfile_update.sql");
    944         if (!update) {
    945             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    946             if (!psDBRollback(config->dbh)) {
    947                 psError(PS_ERR_UNKNOWN, false, "database error");
    948             }
    949             return false;
    950         }
    951 
    952         if (psListLength(where->list)) {
    953             psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    954             psStringAppend(&update, " AND %s", whereClause);
    955             psFree(whereClause);
    956         }
    957 
    958         if (!p_psDBRunQuery(config->dbh, update)) {
    959             psError(PS_ERR_UNKNOWN, false, "database error");
    960             psFree(update);
    961             psFree(where);
    962             if (!psDBRollback(config->dbh)) {
    963                 psError(PS_ERR_UNKNOWN, false, "database error");
    964             }
    965             return false;
    966         }
    967         psFree(update);
    968 
    969         numStacks = psDBAffectedRows(config->dbh);
    970 
    971         if (numStacks < 1) {
    972             psError(PS_ERR_UNKNOWN, false, "should have affected atleast 1 row");
    973             if (!psDBRollback(config->dbh)) {
    974                 psError(PS_ERR_UNKNOWN, false, "database error");
    975             }
    976             return false;
    977         }
     937        psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     938        return false;
    978939    }
    979940
    980941    // Delete product
    981     {
    982         psString delete = pxDataGet("stacktool_revertsumskyfile_delete.sql");
    983         if (!delete) {
    984             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    985             if (!psDBRollback(config->dbh)) {
    986                 psError(PS_ERR_UNKNOWN, false, "database error");
    987             }
    988             return false;
    989         }
    990 
    991         if (psListLength(where->list)) {
    992             psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    993             psStringAppend(&delete, " AND %s", whereClause);
    994             psFree(whereClause);
    995         }
    996 
    997         if (!p_psDBRunQuery(config->dbh, delete)) {
    998             psError(PS_ERR_UNKNOWN, false, "database error");
    999             psFree(delete);
    1000             psFree(where);
    1001             if (!psDBRollback(config->dbh)) {
    1002                 psError(PS_ERR_UNKNOWN, false, "database error");
    1003             }
    1004             return false;
    1005         }
     942    psString delete = pxDataGet("stacktool_revertsumskyfile_delete.sql");
     943    if (!delete) {
     944        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     945        return false;
     946    }
     947
     948    if (psListLength(where->list)) {
     949        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     950        psStringAppend(&delete, " AND %s", whereClause);
     951        psFree(whereClause);
     952    }
     953
     954    if (!p_psDBRunQuery(config->dbh, delete)) {
     955        psError(PS_ERR_UNKNOWN, false, "database error");
    1006956        psFree(delete);
    1007 
    1008         if (psDBAffectedRows(config->dbh) != numStacks) {
    1009             psError(PS_ERR_UNKNOWN, true, "Updated and deleted different number of entries!");
    1010             psFree(where);
    1011             if (!psDBRollback(config->dbh)) {
    1012                 psError(PS_ERR_UNKNOWN, false, "database error");
    1013             }
    1014             return false;
    1015         }
    1016 
    1017     }
    1018 
    1019     if (!psDBCommit(config->dbh)) {
    1020         psError(PS_ERR_UNKNOWN, false, "database error");
    1021         return false;
    1022     }
     957        psFree(where);
     958        return false;
     959    }
     960    psFree(delete);
     961
     962    int numRows = psDBAffectedRows(config->dbh); // Number of row affected
     963    psLogMsg("stacktool", PS_LOG_INFO, "Deleted %d rows", numRows);
    1023964
    1024965    psFree(where);

  • branches/eam_branches/20090715/ippTools/src/stacktoolConfig.c

    r24664 r25022  
    7171    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_posang_min", 0, "define min rotator position angle", NAN);
    7272    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_posang_max", 0, "define max rotator position angle", NAN);
    73     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_solang_min", 0, "define min solar angle", NAN);
    74     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_solang_max", 0, "define max solar angle", NAN);
     73    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_sun_angle_min", 0, "define min solar angle", NAN);
     74    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_sun_angle_max", 0, "define max solar angle", NAN);
    7575    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_fwhm_major_min", 0, "define min fwhm (major axis)", NAN);
    7676    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_fwhm_major_max", 0, "define max fwhm (major axis)", NAN);
    … …  
    159159    psMetadataAddS64(sumskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,            "search by stack ID", 0);
    160160    psMetadataAddS64(sumskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,            "search by warp ID", 0);
     161    psMetadataAddStr(sumskyfileArgs, PS_LIST_TAIL, "-tess_id", 0,            "search by tess ID", 0);
     162    psMetadataAddStr(sumskyfileArgs, PS_LIST_TAIL, "-skycell_id", 0,         "search by skycell ID", 0);
    161163    psMetadataAddS64(sumskyfileArgs, PS_LIST_TAIL, "-exp_id", 0,            "search by exposure ID", 0);
    162164    psMetadataAddStr(sumskyfileArgs, PS_LIST_TAIL, "-exp_name", 0,          "search by exposure name", NULL);
    … …  
    169171    psMetadataAddStr(revertsumskyfileArgs, PS_LIST_TAIL, "-label", 0, "search by label", 0);
    170172    psMetadataAddS16(revertsumskyfileArgs, PS_LIST_TAIL, "-fault",  0,            "search by fault code", 0);
     173    psMetadataAddBool(revertsumskyfileArgs, PS_LIST_TAIL, "-all",  0, "allow no search terms", 0);
    171174
    172175    // -pendingcleanuprun

  • branches/eam_branches/20090715/ippTools/src/warptool.c

    r24733 r25022  
    234234    PXOPT_COPY_F64(config->args,   where, "-posang_max",         "rawExp.posang",         "<");
    235235    PXOPT_COPY_STR(config->args,   where, "-object",             "rawExp.object",         "==");
    236     PXOPT_COPY_F32(config->args,   where, "-solang_min",         "rawExp.solang",         ">=");
    237     PXOPT_COPY_F32(config->args,   where, "-solang_max",         "rawExp.solang",         "<");
     236    PXOPT_COPY_F32(config->args,   where, "-sun_angle_min",      "rawExp.sun_angle",      ">=");
     237    PXOPT_COPY_F32(config->args,   where, "-sun_angle_max",      "rawExp.sun_angle",      "<");
    238238    PXOPT_COPY_STR(config->args,   where, "-reduction",          "fakeRun.reduction",     "==");
    239239    pxAddLabelSearchArgs (config,  where, "-label",             "fakeRun.label",         "==");
    … …  
    11901190    PXOPT_COPY_S64(config->args, where, "-warp_id",    "warpSkyfile.warp_id", "==");
    11911191    PXOPT_COPY_STR(config->args, where, "-skycell_id", "warpSkyfile.skycell_id", "==");
     1192    PXOPT_COPY_S64(config->args, where, "-warp_skyfile_id", "warpImfile.warp_skyfile_id", "==");
     1193    PXOPT_COPY_STR(config->args, where, "-skycell_id", "warpSkyfile.skycell_id", "==");
    11921194    PXOPT_COPY_STR(config->args, where, "-tess_id",    "warpSkyfile.tess_id", "==");
    11931195    PXOPT_COPY_S64(config->args, where, "-exp_id",     "rawExp.exp_id", "==");

  • branches/eam_branches/20090715/ippTools/src/warptoolConfig.c

    r24733 r25022  
    8989    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-posang_max",         0, "search by max rotator position angle", NAN);
    9090    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-object",             0, "search by exposure object", NULL);
    91     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-solang_min",         0, "search by min solar angle", NAN);
    92     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-solang_max",         0, "search by max solar angle", NAN);
     91    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-sun_angle_min",         0, "search by min solar angle", NAN);
     92    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-sun_angle_max",         0, "search by max solar angle", NAN);
    9393    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-reduction",          0, "search by fakeRun reduction class", NULL);
    9494    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search on fakeRun label", NULL);
    … …  
    208208    // -warped
    209209    psMetadata *warpedArgs = psMetadataAlloc();
    210     psMetadataAddS64(warpedArgs, PS_LIST_TAIL, "-warp_id", 0,            "search by warptool ID", 0);
    211     psMetadataAddStr(warpedArgs, PS_LIST_TAIL, "-skycell_id",  0,            "define skycell ID", NULL);
    212     psMetadataAddStr(warpedArgs, PS_LIST_TAIL, "-tess_id",  0,            "define tessellation ID", NULL);
    213     psMetadataAddS64(warpedArgs, PS_LIST_TAIL, "-exp_id", 0,            "define exposure tag", 0);
    214     psMetadataAddStr(warpedArgs, PS_LIST_TAIL, "-exp_name", 0,          "define exposure tag", 0);
    215     psMetadataAddS64(warpedArgs, PS_LIST_TAIL, "-fake_id", 0,            "define phase 3 version of exposure tag", 0);
     210    psMetadataAddS64(warpedArgs, PS_LIST_TAIL, "-warp_id", 0,           "search by warptool ID", 0);
     211    psMetadataAddStr(warpedArgs, PS_LIST_TAIL, "-skycell_id",  0,       "search by skycell ID", NULL);
     212    psMetadataAddS64(warpedArgs, PS_LIST_TAIL, "-warp_skyfile_id", 0,   "search by skyfile ID", 0);
     213    psMetadataAddStr(warpedArgs, PS_LIST_TAIL, "-tess_id",  0,          "search by tessellation ID", NULL);
     214    psMetadataAddS64(warpedArgs, PS_LIST_TAIL, "-exp_id", 0,            "search by exposure tag", 0);
     215    psMetadataAddStr(warpedArgs, PS_LIST_TAIL, "-exp_name", 0,          "search by exposure tag", 0);
     216    psMetadataAddS64(warpedArgs, PS_LIST_TAIL, "-fake_id", 0,           "search by phase 3 version of exposure tag", 0);
    216217    psMetadataAddU64(warpedArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    217     psMetadataAddBool(warpedArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     218    psMetadataAddBool(warpedArgs, PS_LIST_TAIL, "-simple",  0,          "use the simple output format", false);
    218219
    219220    // -revertwarped
Note: See TracChangeset for help on using the changeset viewer.