IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 16170 for trunk/ippTools/src


Ignore:
Timestamp:
Jan 20, 2008, 3:48:37 PM (18 years ago)
Author:
eugene
Message:

merging changes from JHs end_stage branch (new end_stage field and related features; substantial cleanup via macros)

Location:
trunk/ippTools/src
Files:
34 edited

Legend:

Unmodified
Added
Removed

  • trunk/ippTools/src/caltool.c

    r15570 r16170  
    8585    PS_ASSERT_PTR_NON_NULL(config, false);
    8686
    87     // required options
    88     bool status = false;
    89     psString dvodb = psMetadataLookupStr(&status, config->args, "-dvodb");
    90     if (!status) {
    91         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -dvodb");
    92         return false;
    93     }
    94     if (!dvodb) {
    95         psError(PS_ERR_UNKNOWN, true, "-dvodb is required");
    96         return false;
    97     }
     87    // required
     88    PXOPT_LOOKUP_STR(dvodb, config->args, "-set_dvodb", true, false);
    9889
    9990    if (!calDBInsert(config->dbh,
    … …  
    115106    PS_ASSERT_PTR_NON_NULL(config, false);
    116107
    117     bool status = false;
    118     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    119     if (!status) {
    120         psError(PXTOOLS_ERR_PROG, false, "failed to lookup value for -limit");
    121         return false;
    122     }
     108    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     109    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    123110
    124111    psString query = psStringCopy("SELECT * FROM calDB");
    … …  
    164151    }
    165152
    166     bool simple = false;
    167     {
    168         bool status = false;
    169         simple = psMetadataLookupBool(&status, config->args, "-simple");
    170         if (!status) {
    171             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    172             return false;
    173         }
    174     }
    175 
    176153    if (psArrayLength(output)) {
    177154        if (!convertIdToStr(output)) {
    … …  
    199176    PS_ASSERT_PTR_NON_NULL(config, false);
    200177
    201     // required options
    202     bool status = false;
    203     psString cal_id = psMetadataLookupStr(&status, config->args, "-cal_id");
    204     if (!status) {
    205         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -cal_id");
    206         return false;
    207     }
    208     if (!cal_id) {
    209         psError(PS_ERR_UNKNOWN, true, "-cal_id is required");
    210         return false;
    211     }
    212 
    213     psString region = psMetadataLookupStr(&status, config->args, "-region");
    214     if (!status) {
    215         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -region");
    216         return false;
    217     }
    218     if (!region) {
    219         psError(PS_ERR_UNKNOWN, true, "-region is required");
    220         return false;
    221     }
    222 
    223     psString last_step = psMetadataLookupStr(&status, config->args, "-last_step");
    224     if (!status) {
    225         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -last_step");
    226         return false;
    227     }
    228     if (!last_step) {
    229         psError(PS_ERR_UNKNOWN, true, "-last_step is required");
    230         return false;
    231     }
    232 
    233     psString state = psMetadataLookupStr(&status, config->args, "-state");
    234     if (!status) {
    235         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -state");
    236         return false;
    237     }
    238     if (!state) {
    239         psError(PS_ERR_UNKNOWN, true, "-state is required");
    240         return false;
    241     }
     178    // required
     179    PXOPT_LOOKUP_STR(cal_id, config->args, "-cal_id", true, false);
     180    PXOPT_LOOKUP_STR(region, config->args, "-region", true, false);
     181    PXOPT_LOOKUP_STR(last_step, config->args, "-last_step", true, false);
     182    PXOPT_LOOKUP_STR(state, config->args, "-state", true, false);
    242183
    243184    if (!calRunInsert(config->dbh,
    … …  
    260201    PS_ASSERT_PTR_NON_NULL(config, false);
    261202
    262     bool status = false;
    263     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    264     if (!status) {
    265         psError(PXTOOLS_ERR_PROG, false, "failed to lookup value for -limit");
    266         return false;
    267     }
     203    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     204    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    268205
    269206    psString query = psStringCopy("SELECT * FROM calRun");
    … …  
    309246    }
    310247
    311     bool simple = false;
    312     {
    313         bool status = false;
    314         simple = psMetadataLookupBool(&status, config->args, "-simple");
    315         if (!status) {
    316             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    317             return false;
    318         }
    319     }
    320 
    321248    if (psArrayLength(output)) {
    322249        if (!convertIdToStr(output)) {

  • trunk/ippTools/src/caltoolConfig.c

    r15570 r16170  
    8686    psMetadata *modes = psMetadataAlloc();
    8787
    88     PXTOOL_ADD_MODE("-adddb",   "add a DVO calibration DB",
     88    PXOPT_ADD_MODE("-adddb",   "add a DVO calibration DB",
    8989        CALTOOL_MODE_ADDDB,     adddbArgs);
    90     PXTOOL_ADD_MODE("-dbs",     "list DVO calibration DBs",
     90    PXOPT_ADD_MODE("-dbs",     "list DVO calibration DBs",
    9191        CALTOOL_MODE_DBS,       dbsArgs);
    92     PXTOOL_ADD_MODE("-addrun",  "add the results of a calibration run",
     92    PXOPT_ADD_MODE("-addrun",  "add the results of a calibration run",
    9393        CALTOOL_MODE_ADDRUN,    addrunArgs);
    94     PXTOOL_ADD_MODE("-runs",    "list the results of calibration runs",
     94    PXOPT_ADD_MODE("-runs",    "list the results of calibration runs",
    9595        CALTOOL_MODE_RUNS,      runsArgs);
    9696

  • trunk/ippTools/src/camtool.c

    r15957 r16170  
    8989}
    9090
    91 #define ADDRENAMEPARAMSTR(from, to, oldname, newname, comment) \
    92 { \
    93     bool status = false; \
    94     psString str = psMetadataLookupStr(&status, from, "-" oldname); \
    95     if (!status) { \
    96         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -" oldname); \
    97         return false; \
    98     } \
    99     if (str) { \
    100         if (!psMetadataAddStr(to, PS_LIST_TAIL, newname, PS_META_DUPLICATE_OK, comment, str)) { \
    101             psError(PS_ERR_UNKNOWN, false, "failed to add item " newname); \
    102             psFree(to); \
    103             return false; \
    104         } \
    105     } \
    106 }
    107 
    108 #define ADDPARAMSTR(from, to, name) \
    109   ADDRENAMEPARAMSTR(from, to, name, name, "==")
    110 
    111 #define ADDRENAMEPARAMF(from, to, type, oldname, newname, comment) \
    112 { \
    113     bool status = false; \
    114     ps##type var = psMetadataLookup##type(&status, from, "-" oldname); \
    115     if (!status) { \
    116         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -" oldname); \
    117         return false; \
    118     } \
    119     if (!isnan(var)) { \
    120         if (!psMetadataAdd##type(to, PS_LIST_TAIL, newname, PS_META_DUPLICATE_OK, comment, var)) { \
    121             psError(PS_ERR_UNKNOWN, false, "failed to add item " newname); \
    122             psFree(to); \
    123             return false; \
    124         } \
    125     } \
    126 }
    127 
    128 #define ADDPARAMF(from, to, type, name) \
    129   ADDRENAMEPARAMF(from, to, type, name, name, "==")
    13091
    13192static bool queueMode(pxConfig *config)
    13293{
    13394    PS_ASSERT_PTR_NON_NULL(config, NULL);
     95
     96    PXOPT_LOOKUP_STR(chip_id, config->args, "-chip_id", false, false);
     97    PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", false, false);
    13498
    13599    psMetadata *where = psMetadataAlloc();
    136100    // convert chip_id into a psS64
    137 {
    138     bool status = false;
    139     psString var = psMetadataLookupStr(&status, config->args, "-chip_id");
    140     if (!status) {
    141         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -chip_id");
    142         return false;
    143     }
    144     if (var) {
    145         if (!psMetadataAddS64(where, PS_LIST_TAIL, "chip_id", 0, "==", (psS64)atoll(var))) {
     101    if (chip_id) {
     102        if (!psMetadataAddS64(where, PS_LIST_TAIL, "chip_id", 0, "==", (psS64)atoll(chip_id))) {
    146103            psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id");
    147104            psFree(where);
    … …  
    149106        }
    150107    }
    151 }
     108 
    152109    // convert exp_id into a psS64
    153 {
    154     bool status = false;
    155     psString var = psMetadataLookupStr(&status, config->args, "-exp_id");
    156     if (!status) {
    157         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_id");
    158         return false;
    159     }
    160     if (var) {
    161         if (!psMetadataAddS64(where, PS_LIST_TAIL, "exp_id", 0, "==", (psS64)atoll(var))) {
     110    if (exp_id) {
     111        if (!psMetadataAddS64(where, PS_LIST_TAIL, "exp_id", 0, "==", (psS64)atoll(exp_id))) {
    162112            psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    163113            psFree(where);
    … …  
    165115        }
    166116    }
    167 }
    168     ADDPARAMSTR(config->args, where, "exp_name");
    169     ADDRENAMEPARAMSTR(config->args, where, "inst", "camera", "==");
    170     ADDPARAMSTR(config->args, where, "telescope");
    171     ADDPARAMSTR(config->args, where, "dateobs_begin");
    172     ADDPARAMSTR(config->args, where, "dateobs_end");
    173     ADDPARAMSTR(config->args, where, "exp_tag");
    174     ADDPARAMSTR(config->args, where, "exp_type");
    175     ADDPARAMSTR(config->args, where, "filelevel");
    176     ADDPARAMSTR(config->args, where, "reduction");
    177     ADDPARAMSTR(config->args, where, "filter");
    178     ADDRENAMEPARAMF(config->args, where, F64, "airmass_min", "airmass", ">=");
    179     ADDRENAMEPARAMF(config->args, where, F64, "airmass_max", "airmass", "<");
    180     ADDRENAMEPARAMF(config->args, where, F64, "ra_min", "ra", ">=");
    181     ADDRENAMEPARAMF(config->args, where, F64, "ra_max", "ra", "<");
    182     ADDRENAMEPARAMF(config->args, where, F64, "decl_min", "decl", ">=");
    183     ADDRENAMEPARAMF(config->args, where, F64, "decl_max", "decl", "<");
    184     ADDRENAMEPARAMF(config->args, where, F32, "exp_time_min", "exp_time", ">=");
    185     ADDRENAMEPARAMF(config->args, where, F32, "exp_time_max", "exp_time", "<");
    186     ADDRENAMEPARAMF(config->args, where, F32, "sat_pixel_frac_min", "sat_pixel_frac", ">=");
    187     ADDRENAMEPARAMF(config->args, where, F32, "sat_pixel_frac_max", "sat_pixel_frac", "<");
    188     ADDRENAMEPARAMF(config->args, where, F64, "bg_min", "bt", ">=");
    189     ADDRENAMEPARAMF(config->args, where, F64, "bg_max", "bt", "<");
    190     ADDRENAMEPARAMF(config->args, where, F64, "bg_stdev_min", "bg_stdev", ">=");
    191     ADDRENAMEPARAMF(config->args, where, F64, "bg_stdev_max", "bg_stdev", "<");
    192     ADDRENAMEPARAMF(config->args, where, F64, "bg_mean_stdev_min", "bg_mean_stdev", ">=");
    193     ADDRENAMEPARAMF(config->args, where, F64, "bg_mean_stdev_max", "bg_mean_stdev", "<");
    194     ADDRENAMEPARAMF(config->args, where, F64, "alt_min", "alt", ">=");
    195     ADDRENAMEPARAMF(config->args, where, F64, "alt_max", "alt", "<");
    196     ADDRENAMEPARAMF(config->args, where, F64, "az_min", "az", ">=");
    197     ADDRENAMEPARAMF(config->args, where, F64, "az_max", "az", "<");
    198     ADDRENAMEPARAMF(config->args, where, F32, "ccd_temp_min", "ccd_temp", ">=");
    199     ADDRENAMEPARAMF(config->args, where, F32, "ccd_temp_max", "ccd_temp", "<");
    200     ADDRENAMEPARAMF(config->args, where, F64, "posang_min", "posang", ">=");
    201     ADDRENAMEPARAMF(config->args, where, F64, "posang_max", "posang", "<");
    202     ADDPARAMSTR(config->args, where, "object");
    203     ADDRENAMEPARAMF(config->args, where, F32, "solang_min", "solang", ">=");
    204     ADDRENAMEPARAMF(config->args, where, F32, "solang_max", "solang", "<");
     117
     118    PXOPT_COPY_STR(config->args, where, "-exp_name", "exp_name", "==");
     119    PXOPT_COPY_STR(config->args, where, "-inst", "camera", "==");
     120    PXOPT_COPY_STR(config->args, where, "-telescope", "telescope", "==");
     121    PXOPT_COPY_TIME(config->args, where, "-dateobs_begin", "dateobs", ">=");
     122    PXOPT_COPY_TIME(config->args, where, "-dateobs_end", "dateobs", "<=");
     123    PXOPT_COPY_STR(config->args, where, "-exp_tag", "exp_tag", "==");
     124    PXOPT_COPY_STR(config->args, where, "-exp_type", "exp_type", "==");
     125    PXOPT_COPY_STR(config->args, where, "-filelevel", "filelevel", "==");
     126    PXOPT_COPY_STR(config->args, where, "-reduction", "reduction", "==");
     127    PXOPT_COPY_STR(config->args, where, "-filter", "filter", "==");
     128
     129    PXOPT_COPY_F64(config->args, where, "-airmass_min", "airmass", ">=");
     130    PXOPT_COPY_F64(config->args, where, "-airmass_max", "airmass", "<");
     131    PXOPT_COPY_F64(config->args, where, "-ra_min", "ra", ">=");
     132    PXOPT_COPY_F64(config->args, where, "-ra_max", "ra", "<");
     133    PXOPT_COPY_F64(config->args, where, "-decl_min", "decl", ">=");
     134    PXOPT_COPY_F64(config->args, where, "-decl_max", "decl", "<");
     135    PXOPT_COPY_F32(config->args, where, "-exp_time_min", "exp_time", ">=");
     136    PXOPT_COPY_F32(config->args, where, "-exp_time_max", "exp_time", "<");
     137    PXOPT_COPY_F32(config->args, where, "-sat_pixel_frac_min", "sat_pixel_frac", ">=");
     138    PXOPT_COPY_F32(config->args, where, "-sat_pixel_frac_max", "sat_pixel_frac", "<");
     139    PXOPT_COPY_F64(config->args, where, "-bg_min", "bt", ">=");
     140    PXOPT_COPY_F64(config->args, where, "-bg_max", "bt", "<");
     141    PXOPT_COPY_F64(config->args, where, "-bg_stdev_min", "bg_stdev", ">=");
     142    PXOPT_COPY_F64(config->args, where, "-bg_stdev_max", "bg_stdev", "<");
     143    PXOPT_COPY_F64(config->args, where, "-bg_mean_stdev_min", "bg_mean_stdev", ">=");
     144    PXOPT_COPY_F64(config->args, where, "-bg_mean_stdev_max", "bg_mean_stdev", "<");
     145    PXOPT_COPY_F64(config->args, where, "-alt_min", "alt", ">=");
     146    PXOPT_COPY_F64(config->args, where, "-alt_max", "alt", "<");
     147    PXOPT_COPY_F64(config->args, where, "-az_min", "az", ">=");
     148    PXOPT_COPY_F64(config->args, where, "-az_max", "az", "<");
     149    PXOPT_COPY_F32(config->args, where, "-ccd_temp_min", "ccd_temp", ">=");
     150    PXOPT_COPY_F32(config->args, where, "-ccd_temp_max", "ccd_temp", "<");
     151    PXOPT_COPY_F64(config->args, where, "-posang_min", "posang", ">=");
     152    PXOPT_COPY_F64(config->args, where, "-posang_max", "posang", "<");
     153    PXOPT_COPY_STR(config->args, where, "-object", "object", "==");
     154    PXOPT_COPY_F32(config->args, where, "-solang_min", "solang", ">=");
     155    PXOPT_COPY_F32(config->args, where, "-solang_max", "solang", "<");
    205156
    206157    if (where->list->n < 1) {
    … …  
    209160    }
    210161
    211     bool status = false;
    212     psString workdir = psMetadataLookupStr(&status, config->args, "-set_workdir");
    213     if (!status) {
    214         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_workdir");
    215         return false;
    216     }
    217 
    218     psString label = psMetadataLookupStr(&status, config->args, "-set_label");
    219     if (!status) {
    220         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_label");
    221         return false;
    222     }
    223 
    224     psString reduction = psMetadataLookupStr(&status, config->args, "-set_reduction");
    225     if (!status) {
    226         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_reduction");
    227         return false;
    228     }
    229 
    230     psString expgroup = psMetadataLookupStr(&status, config->args, "-set_expgroup");
    231     if (!status) {
    232         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_expgroup");
    233         return false;
    234     }
    235 
    236     psString dvodb = psMetadataLookupStr(&status, config->args, "-set_dvodb");
    237     if (!status) {
    238         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_dvodb");
    239         return false;
    240     }
     162    PXOPT_LOOKUP_STR(workdir, config->args, "-set_workdir", true, false);
     163    PXOPT_LOOKUP_STR(label, config->args, "-set_label", true, false);
     164    PXOPT_LOOKUP_STR(reduction, config->args, "-set_reduction", true, false);
     165    PXOPT_LOOKUP_STR(expgroup, config->args, "-set_expgroup", true, false);
     166    PXOPT_LOOKUP_STR(dvodb, config->args, "-set_dvodb", true, false);
     167    PXOPT_LOOKUP_STR(tess_id, config->args, "-set_tess_id", true, false);
     168    PXOPT_LOOKUP_STR(end_stage, config->args, "-set_end_stage", true, false);
    241169
    242170    // find the exp_id of all the exposures that we want to queue up.
    … …  
    303231                    reduction      ? reduction    : row->reduction,
    304232                    expgroup    ? expgroup  : row->expgroup,
    305                     dvodb       ? dvodb     : row->dvodb
     233                    dvodb       ? dvodb     : row->dvodb,
     234                    tess_id     ? tess_id   : row->tess_id,
     235                    end_stage   ? end_stage : row->end_stage
    306236        )) {
    307237            if (!psDBRollback(config->dbh)) {
    … …  
    330260    PS_ASSERT_PTR_NON_NULL(config, false);
    331261
    332     bool status = false;
    333     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    334     if (!status) {
    335         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
    336         return false;
    337     }
     262    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     263    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    338264
    339265    psString query = pxDataGet("camtool_find_pendingexp.sql");
    … …  
    374300    }
    375301
    376     bool simple = false;
    377     {
    378         bool status = false;
    379         simple = psMetadataLookupBool(&status, config->args, "-simple");
    380         if (!status) {
    381             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    382             return false;
    383         }
    384     }
    385 
    386302    if (!convertIdToStr(output)) {
    387303        psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    … …  
    405321{
    406322    PS_ASSERT_PTR_NON_NULL(config, false);
     323
     324    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    407325
    408326    psString query = pxDataGet("camtool_find_pendingimfile.sql");
    … …  
    436354    }
    437355
    438     bool simple = false;
    439     {
    440         bool status = false;
    441         simple = psMetadataLookupBool(&status, config->args, "-simple");
    442         if (!status) {
    443             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    444             return false;
    445         }
    446     }
    447 
    448356    if (!convertIdToStr(output)) {
    449357        psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    … …  
    468376    PS_ASSERT_PTR_NON_NULL(config, false);
    469377
    470     bool status = false;
    471     psString cam_id = psMetadataLookupStr(&status, config->args, "-cam_id");
    472     if (!status) {
    473         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -cam_id");
    474         return false;
    475     }
    476     if (!cam_id) {
    477         psError(PS_ERR_UNKNOWN, true, "-cam_id is required");
    478         return false;
    479     }
    480 
    481     psString uri = psMetadataLookupStr(&status, config->args, "-uri");
    482     if (!status) {
    483         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -uri");
    484         return false;
    485     }
    486     if (!uri) {
    487         psError(PS_ERR_UNKNOWN, true, "-uri is required");
    488         return false;
    489     }
    490 
    491     psF64 bg = psMetadataLookupF64(&status, config->args, "-bg");
    492     if (!status) {
    493         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg");
    494         return false;
    495     }
    496 
    497     psF64 bg_stdev = psMetadataLookupF64(&status, config->args, "-bg_stdev");
    498     if (!status) {
    499         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg_stdev");
    500         return false;
    501     }
    502 
    503     psF64 bg_mean_stdev = psMetadataLookupF64(&status, config->args, "-bg_mean_stdev");
    504     if (!status) {
    505         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg_mean_stdev");
    506         return false;
    507     }
    508 
    509     psF32 sigma_ra = psMetadataLookupF32(&status, config->args, "-sigma_ra");
    510     if (!status) {
    511         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -sigma_ra");
    512         return false;
    513     }
    514     //if (isnan(sigma_ra)) {
    515     //  psError(PS_ERR_UNKNOWN, true, "-sigma_ra is required");
    516     //  return false;
    517     //}
    518 
    519     psF32 sigma_dec = psMetadataLookupF32(&status, config->args, "-sigma_dec");
    520     if (!status) {
    521         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -sigma_dec");
    522         return false;
    523     }
    524     //if (isnan(sigma_dec)) {
    525     //  psError(PS_ERR_UNKNOWN, true, "-sigma_dec is required");
    526     //  return false;
    527     //}
    528 
    529     psF32 zp_mean = psMetadataLookupF32(&status, config->args, "-zp_mean");
    530     if (!status) {
    531         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -zp_mean");
    532         return false;
    533     }
    534     //if (isnan(zp_mean)) {
    535     //  psError(PS_ERR_UNKNOWN, true, "-zp_mean is required");
    536     //  return false;
    537     //}
    538 
    539     psF32 zp_stdev = psMetadataLookupF32(&status, config->args, "-zp_stdev");
    540     if (!status) {
    541         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -zp_stdev");
    542         return false;
    543     }
    544     //if (isnan(zp_stdev)) {
    545     //  psError(PS_ERR_UNKNOWN, true, "-zp_stdev is required");
    546     //  return false;
    547     //}
    548 
    549     psF32 fwhm = psMetadataLookupF32(&status, config->args, "-fwhm");
    550     if (!status) {
    551         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -fwhm");
    552         return false;
    553     }
    554     //if (isnan(fwhm)) {
    555     //  psError(PS_ERR_UNKNOWN, true, "-fwhm is required");
    556     //  return false;
    557     //}
    558 
    559     psF32 fwhm_range = psMetadataLookupF32(&status, config->args, "-fwhm_range");
    560     if (!status) {
    561         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -fwhm_range");
    562         return false;
    563     }
    564     //if (isnan(fwhm_range)) {
    565     //  psError(PS_ERR_UNKNOWN, true, "-fwhm_range is required");
    566     //  return false;
    567     //}
    568 
    569     psS32 n_stars = psMetadataLookupS32(&status, config->args, "-n_stars");
    570     if (!status) {
    571         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -n_stars");
    572         return false;
    573     }
    574     if (n_stars < 0) {
    575         psError(PS_ERR_UNKNOWN, true, "-n_stars is required");
    576         return false;
    577     }
    578 
    579     psS32 n_extended = psMetadataLookupS32(&status, config->args, "-n_extended");
    580     if (!status) {
    581         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -n_extended");
    582         return false;
    583     }
     378    // required
     379    PXOPT_LOOKUP_STR(cam_id, config->args, "-cam_id", true, false);
     380    PXOPT_LOOKUP_STR(uri, config->args, "-uri", true, false);
     381
     382    // optional
     383    PXOPT_LOOKUP_F32(bg, config->args, "-bg", false, false);
     384    PXOPT_LOOKUP_F32(bg_stdev, config->args, "-bg_stdev", false, false);
     385    PXOPT_LOOKUP_F32(bg_mean_stdev, config->args, "-bg_mean_stdev", false, false);
     386    PXOPT_LOOKUP_F32(sigma_ra, config->args, "-sigma_ra", false, false);
     387    PXOPT_LOOKUP_F32(sigma_dec, config->args, "-sigma_dec", false, false);
     388    PXOPT_LOOKUP_F32(zp_mean, config->args, "-zp_mean", false, false);
     389    PXOPT_LOOKUP_F32(zp_stdev, config->args, "-zp_stdev", false, false);
     390    PXOPT_LOOKUP_F32(fwhm, config->args, "-fwhm", false, false);
     391    PXOPT_LOOKUP_F32(fwhm_range, config->args, "-fwhm_range", false, false);
     392    PXOPT_LOOKUP_F32(n_stars, config->args, "-n_stars", false, false);
     393    PXOPT_LOOKUP_F32(n_extended, config->args, "-n_extended", false, false);
    584394    if (n_extended < 0) {
    585395        psError(PS_ERR_UNKNOWN, true, "-n_extended is required");
    586396        return false;
    587397    }
    588 
    589     psS32 n_cr = psMetadataLookupS32(&status, config->args, "-n_cr");
    590     if (!status) {
    591         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -n_cr");
    592         return false;
    593     }
     398    PXOPT_LOOKUP_F32(n_cr, config->args, "-n_cr", false, false);
    594399    if (n_cr < 0) {
    595400        psError(PS_ERR_UNKNOWN, true, "-n_cr is required");
    596401        return false;
    597402    }
    598 
    599     psS32 n_astrom = psMetadataLookupS32(&status, config->args, "-n_astrom");
    600     if (!status) {
    601         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -n_astrom");
    602         return false;
    603     }
     403    PXOPT_LOOKUP_F32(n_astrom, config->args, "-n_astrom", false, false);
    604404    if (n_astrom < 0) {
    605405        psError(PS_ERR_UNKNOWN, true, "-n_astrom is required");
    … …  
    607407    }
    608408
    609     // optional
    610     psString path_base = psMetadataLookupStr(&status, config->args, "-path_base");
    611     if (!status) {
    612         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -path_base");
    613         return false;
    614     }
     409    PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", false, false);
    615410
    616411    // default
    617     psS16 code = psMetadataLookupS16(&status, config->args, "-code");
    618     if (!status) {
    619         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -code");
    620         return false;
    621     }
     412    PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
    622413
    623414    psString query = pxDataGet("camtool_find_pendingexp.sql");
    … …  
    674465    camRunRow *pendingRow = camRunObjectFromMetadata(output->data[0]);
    675466    psFree(output);
    676     // create a new camProcessedImfile object
    677467    camProcessedExpRow *row = camProcessedExpRowAlloc(
    678468        pendingRow->cam_id,
    … …  
    697487    psFree(pendingRow);
    698488
    699     // insert the new row into the camProcessedImfile table
    700489    if (!camProcessedExpInsertObject(config->dbh, row)) {
    701490        // rollback
    … …  
    730519    PS_ASSERT_PTR_NON_NULL(config, false);
    731520
    732     bool status = false;
    733     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    734     if (!status) {
    735         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
    736         return false;
    737     }
    738 
    739     bool faulted = psMetadataLookupU64(&status, config->args, "-faulted");
    740     if (!status) {
    741         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -faulted");
    742         return false;
    743     }
     521    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     522    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     523    PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    744524
    745525    psString query = pxDataGet("camtool_find_processedexp.sql");
    … …  
    788568    }
    789569
    790     bool simple = false;
    791     {
    792         bool status = false;
    793         simple = psMetadataLookupBool(&status, config->args, "-simple");
    794         if (!status) {
    795             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    796             return false;
    797         }
    798     }
    799 
    800570    if (!convertIdToStr(output)) {
    801571        psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    … …  
    853623    PS_ASSERT_PTR_NON_NULL(config, false);
    854624
    855     bool status = false;
    856     psS16 code = psMetadataLookupS16(&status, config->args, "-code");
    857     if (!status) {
    858         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -code");
    859         return false;
    860     }
    861     if (code == INT16_MAX) {
    862         psError(PS_ERR_UNKNOWN, true, "-code is required");
    863         return false;
    864     }
     625    PXOPT_LOOKUP_S16(code, config->args, "-code", true, false);
    865626
    866627    if (!pxSetFaultCode(config->dbh, "camProcessedExp", config->where, code)) {
    … …  
    877638    PS_ASSERT_PTR_NON_NULL(config, false);
    878639
    879     bool status = false;
    880     psString label = psMetadataLookupStr(&status, config->args, "-label");
    881     if (!status) {
    882         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -label");
    883         return false;
    884     }
    885     if (!label) {
    886         psError(PS_ERR_UNKNOWN, true, "-label is required");
    887         return false;
    888     }
     640    PXOPT_LOOKUP_STR(label, config->args, "-label", true, false);
    889641
    890642    if (!camMaskInsert(config->dbh, label)) {
    … …  
    900652{
    901653    PS_ASSERT_PTR_NON_NULL(config, false);
     654
     655    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    902656
    903657    psString query = psStringCopy("SELECT * FROM camMask");
    … …  
    919673        psFree(output);
    920674        return true;
    921     }
    922 
    923     bool simple = false;
    924     {
    925         bool status = false;
    926         simple = psMetadataLookupBool(&status, config->args, "-simple");
    927         if (!status) {
    928             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    929             return false;
    930         }
    931675    }
    932676
    … …  
    954698    PS_ASSERT_PTR_NON_NULL(config, false);
    955699
    956     bool status = false;
    957     psString label = psMetadataLookupStr(&status, config->args, "-label");
    958     if (!status) {
    959         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -label");
    960         return false;
    961     }
    962     if (!label) {
    963         psError(PS_ERR_UNKNOWN, true, "-label is required");
    964         return false;
    965     }
     700    PXOPT_LOOKUP_STR(label, config->args, "-label", true, false);
    966701
    967702    char *query = "DELETE FROM camMask WHERE label = '%s'";
    … …  
    969704    if (!p_psDBRunQuery(config->dbh, query, label)) {
    970705        psError(PS_ERR_UNKNOWN, false, "database error");
    971         psFree(query);
    972         return false;
    973     }
    974 
    975     return true;
    976 }
     706        return false;
     707    }
     708
     709    return true;
     710}

  • trunk/ippTools/src/camtoolConfig.c

    r14227 r16170  
    6060    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-telescope",  0,
    6161            "search for telescope", NULL);
    62     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-dateobs_begin", 0,
     62    psMetadataAddTime(queueArgs, PS_LIST_TAIL, "-dateobs_begin", 0,
    6363            "search for exposures by time (>=)", NULL);
    64     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-dateobs_end", 0,
     64    psMetadataAddTime(queueArgs, PS_LIST_TAIL, "-dateobs_end", 0,
    6565            "search for exposures by time (<)", NULL);
    6666    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-exp_tag",  0,
    … …  
    138138    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_dvodb",  0,
    139139            "define DVO db", NULL);
     140    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_tess_id",  0,
     141            "define tess ID", NULL);
     142    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_end_stage",  0,
     143            "define end stage", NULL);
    140144
    141145    // -pendingexp
    … …  
    257261    psMetadata *modes = psMetadataAlloc();
    258262
    259     PXTOOL_ADD_MODE("-queue",               "", CAMTOOL_MODE_QUEUE,         queueArgs);
    260     PXTOOL_ADD_MODE("-pendingexp",          "", CAMTOOL_MODE_PENDINGEXP,    pendingexpArgs);
    261     PXTOOL_ADD_MODE("-pendingimfile",       "", CAMTOOL_MODE_PENDINGIMFILE, pendingimfileArgs);
    262     PXTOOL_ADD_MODE("-addprocessedexp",     "", CAMTOOL_MODE_ADDPROCESSEDEXP, addprocessedexpArgs);
    263     PXTOOL_ADD_MODE("-processedexp",        "", CAMTOOL_MODE_PROCESSEDEXP,  processedexpArgs);
    264     PXTOOL_ADD_MODE("-revertprocessedexp",  "", CAMTOOL_MODE_REVERTPROCESSEDEXP,  revertprocessedexpArgs);
    265     PXTOOL_ADD_MODE("-updateprocessedexp",  "", CAMTOOL_MODE_UPDATEPROCESSEDEXP,updateprocessedexpArgs);
    266     PXTOOL_ADD_MODE("-block",               "", CAMTOOL_MODE_BLOCK,         blockArgs);
    267     PXTOOL_ADD_MODE("-masked",              "", CAMTOOL_MODE_MASKED,        maskedArgs);
    268     PXTOOL_ADD_MODE("-unblock",             "", CAMTOOL_MODE_UNBLOCK,       unblockArgs);
     263    PXOPT_ADD_MODE("-queue",               "", CAMTOOL_MODE_QUEUE,         queueArgs);
     264    PXOPT_ADD_MODE("-pendingexp",          "", CAMTOOL_MODE_PENDINGEXP,    pendingexpArgs);
     265    PXOPT_ADD_MODE("-pendingimfile",       "", CAMTOOL_MODE_PENDINGIMFILE, pendingimfileArgs);
     266    PXOPT_ADD_MODE("-addprocessedexp",     "", CAMTOOL_MODE_ADDPROCESSEDEXP, addprocessedexpArgs);
     267    PXOPT_ADD_MODE("-processedexp",        "", CAMTOOL_MODE_PROCESSEDEXP,  processedexpArgs);
     268    PXOPT_ADD_MODE("-revertprocessedexp",  "", CAMTOOL_MODE_REVERTPROCESSEDEXP,  revertprocessedexpArgs);
     269    PXOPT_ADD_MODE("-updateprocessedexp",  "", CAMTOOL_MODE_UPDATEPROCESSEDEXP,updateprocessedexpArgs);
     270    PXOPT_ADD_MODE("-block",               "", CAMTOOL_MODE_BLOCK,         blockArgs);
     271    PXOPT_ADD_MODE("-masked",              "", CAMTOOL_MODE_MASKED,        maskedArgs);
     272    PXOPT_ADD_MODE("-unblock",             "", CAMTOOL_MODE_UNBLOCK,       unblockArgs);
    269273
    270274    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {

  • trunk/ippTools/src/chiptool.c

    r14214 r16170  
    9393}
    9494
    95 #define ADDRENAMEPARAMSTR(from, to, oldname, newname, comment) \
    96 { \
    97     bool status = false; \
    98     psString str = psMetadataLookupStr(&status, from, "-" oldname); \
    99     if (!status) { \
    100         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -" oldname); \
    101         return false; \
    102     } \
    103     if (str) { \
    104         if (!psMetadataAddStr(to, PS_LIST_TAIL, newname, PS_META_DUPLICATE_OK, comment, str)) { \
    105             psError(PS_ERR_UNKNOWN, false, "failed to add item " newname); \
    106             psFree(to); \
    107             return false; \
    108         } \
    109     } \
    110 }
    111 
    112 #define ADDPARAMSTR(from, to, name) \
    113   ADDRENAMEPARAMSTR(from, to, name, name, "==")
    114 
    115 #define ADDRENAMEPARAMF(from, to, type, oldname, newname, comment) \
    116 { \
    117     bool status = false; \
    118     ps##type var = psMetadataLookup##type(&status, from, "-" oldname); \
    119     if (!status) { \
    120         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -" oldname); \
    121         return false; \
    122     } \
    123     if (!isnan(var)) { \
    124         if (!psMetadataAdd##type(to, PS_LIST_TAIL, newname, PS_META_DUPLICATE_OK, comment, var)) { \
    125             psError(PS_ERR_UNKNOWN, false, "failed to add item " newname); \
    126             psFree(to); \
    127             return false; \
    128         } \
    129     } \
    130 }
    131 
    132 #define ADDPARAMF(from, to, type, name) \
    133   ADDRENAMEPARAMF(from, to, type, name, name, "==")
    13495
    13596static bool queueMode(pxConfig *config)
    13697{
    13798    PS_ASSERT_PTR_NON_NULL(config, NULL);
     99
     100    PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", false, false);
    138101
    139102    psMetadata *where = psMetadataAlloc();
    140103    // convert exp_id into a psS64
    141 {
    142     bool status = false;
    143     psString var = psMetadataLookupStr(&status, config->args, "-exp_id");
    144     if (!status) {
    145         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_id");
    146         return false;
    147     }
    148     if (var) {
    149         if (!psMetadataAddS64(where, PS_LIST_TAIL, "exp_id", 0, "==", (psS64)atoll(var))) {
     104    if (exp_id) {
     105        if (!psMetadataAddS64(where, PS_LIST_TAIL, "exp_id", 0, "==", (psS64)atoll(exp_id))) {
    150106            psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    151107            psFree(where);
    … …  
    153109        }
    154110    }
    155 }
    156     ADDPARAMSTR(config->args, where, "exp_name");
    157     ADDRENAMEPARAMSTR(config->args, where, "inst", "camera", "==");
    158     ADDPARAMSTR(config->args, where, "telescope");
    159     ADDPARAMSTR(config->args, where, "dateobs_begin");
    160     ADDPARAMSTR(config->args, where, "dateobs_end");
    161     ADDPARAMSTR(config->args, where, "exp_tag");
    162     ADDPARAMSTR(config->args, where, "exp_type");
    163     ADDPARAMSTR(config->args, where, "filelevel");
    164     ADDPARAMSTR(config->args, where, "reduction");
    165     ADDPARAMSTR(config->args, where, "filter");
    166     ADDRENAMEPARAMF(config->args, where, F64, "airmass_min", "airmass", ">=");
    167     ADDRENAMEPARAMF(config->args, where, F64, "airmass_max", "airmass", "<");
    168     ADDRENAMEPARAMF(config->args, where, F64, "ra_min", "ra", ">=");
    169     ADDRENAMEPARAMF(config->args, where, F64, "ra_max", "ra", "<");
    170     ADDRENAMEPARAMF(config->args, where, F64, "decl_min", "decl", ">=");
    171     ADDRENAMEPARAMF(config->args, where, F64, "decl_max", "decl", "<");
    172     ADDRENAMEPARAMF(config->args, where, F32, "exp_time_min", "exp_time", ">=");
    173     ADDRENAMEPARAMF(config->args, where, F32, "exp_time_max", "exp_time", "<");
    174     ADDRENAMEPARAMF(config->args, where, F32, "sat_pixel_frac_min", "sat_pixel_frac", ">=");
    175     ADDRENAMEPARAMF(config->args, where, F32, "sat_pixel_frac_max", "sat_pixel_frac", "<");
    176     ADDRENAMEPARAMF(config->args, where, F64, "bg_min", "bt", ">=");
    177     ADDRENAMEPARAMF(config->args, where, F64, "bg_max", "bt", "<");
    178     ADDRENAMEPARAMF(config->args, where, F64, "bg_stdev_min", "bg_stdev", ">=");
    179     ADDRENAMEPARAMF(config->args, where, F64, "bg_stdev_max", "bg_stdev", "<");
    180     ADDRENAMEPARAMF(config->args, where, F64, "bg_mean_stdev_min", "bg_mean_stdev", ">=");
    181     ADDRENAMEPARAMF(config->args, where, F64, "bg_mean_stdev_max", "bg_mean_stdev", "<");
    182     ADDRENAMEPARAMF(config->args, where, F64, "alt_min", "alt", ">=");
    183     ADDRENAMEPARAMF(config->args, where, F64, "alt_max", "alt", "<");
    184     ADDRENAMEPARAMF(config->args, where, F64, "az_min", "az", ">=");
    185     ADDRENAMEPARAMF(config->args, where, F64, "az_max", "az", "<");
    186     ADDRENAMEPARAMF(config->args, where, F32, "ccd_temp_min", "ccd_temp", ">=");
    187     ADDRENAMEPARAMF(config->args, where, F32, "ccd_temp_max", "ccd_temp", "<");
    188     ADDRENAMEPARAMF(config->args, where, F64, "posang_min", "posang", ">=");
    189     ADDRENAMEPARAMF(config->args, where, F64, "posang_max", "posang", "<");
    190     ADDPARAMSTR(config->args, where, "object");
    191     ADDRENAMEPARAMF(config->args, where, F32, "solang_min", "solang", ">=");
    192     ADDRENAMEPARAMF(config->args, where, F32, "solang_max", "solang", "<");
     111
     112    PXOPT_COPY_STR(config->args, where, "-exp_name", "exp_name", "==");
     113    PXOPT_COPY_STR(config->args, where, "-inst", "camera", "==");
     114    PXOPT_COPY_STR(config->args, where, "-telescope", "telescope", "==");
     115    PXOPT_COPY_STR(config->args, where, "-dateobs_begin", "dateobs", ">=");
     116    PXOPT_COPY_STR(config->args, where, "-dateobs_end", "dateobs", "<=");
     117    PXOPT_COPY_STR(config->args, where, "-exp_tag", "exp_tag", "==");
     118    PXOPT_COPY_STR(config->args, where, "-exp_type", "exp_type", "==");
     119    PXOPT_COPY_STR(config->args, where, "-filelevel", "filelevel", "==");
     120    PXOPT_COPY_STR(config->args, where, "-reduction", "reduction", "==");
     121    PXOPT_COPY_STR(config->args, where, "-filter", "filter", "==");
     122    PXOPT_COPY_F64(config->args, where, "-airmass_min", "airmass", ">=");
     123    PXOPT_COPY_F64(config->args, where, "-airmass_max", "airmass", "<");
     124    PXOPT_COPY_F64(config->args, where, "-ra_min", "ra", ">=");
     125    PXOPT_COPY_F64(config->args, where, "-ra_max", "ra", "<");
     126    PXOPT_COPY_F64(config->args, where, "-decl_min", "decl", ">=");
     127    PXOPT_COPY_F64(config->args, where, "-decl_max", "decl", "<");
     128    PXOPT_COPY_F32(config->args, where, "-exp_time_min", "exp_time", ">=");
     129    PXOPT_COPY_F32(config->args, where, "-exp_time_max", "exp_time", "<");
     130    PXOPT_COPY_F32(config->args, where, "-sat_pixel_frac_min", "sat_pixel_frac", ">=");
     131    PXOPT_COPY_F32(config->args, where, "-sat_pixel_frac_max", "sat_pixel_frac", "<");
     132    PXOPT_COPY_F64(config->args, where, "-bg_min", "bt", ">=");
     133    PXOPT_COPY_F64(config->args, where, "-bg_max", "bt", "<");
     134    PXOPT_COPY_F64(config->args, where, "-bg_stdev_min", "bg_stdev", ">=");
     135    PXOPT_COPY_F64(config->args, where, "-bg_stdev_max", "bg_stdev", "<");
     136    PXOPT_COPY_F64(config->args, where, "-bg_mean_stdev_min", "bg_mean_stdev", ">=");
     137    PXOPT_COPY_F64(config->args, where, "-bg_mean_stdev_max", "bg_mean_stdev", "<");
     138    PXOPT_COPY_F64(config->args, where, "-alt_min", "alt", ">=");
     139    PXOPT_COPY_F64(config->args, where, "-alt_max", "alt", "<");
     140    PXOPT_COPY_F64(config->args, where, "-az_min", "az", ">=");
     141    PXOPT_COPY_F64(config->args, where, "-az_max", "az", "<");
     142    PXOPT_COPY_F32(config->args, where, "-ccd_temp_min", "ccd_temp", ">=");
     143    PXOPT_COPY_F32(config->args, where, "-ccd_temp_max", "ccd_temp", "<");
     144    PXOPT_COPY_F64(config->args, where, "-posang_min", "posang", ">=");
     145    PXOPT_COPY_F64(config->args, where, "-posang_max", "posang", "<");
     146    PXOPT_COPY_STR(config->args, where, "-object", "object", "==");
     147    PXOPT_COPY_F32(config->args, where, "-solang_min", "solang", ">=");
     148    PXOPT_COPY_F32(config->args, where, "-solang_max", "solang", "<");
    193149
    194150    if (where->list->n < 1) {
    … …  
    197153    }
    198154
    199     bool status = false;
    200     psString workdir = psMetadataLookupStr(&status, config->args, "-set_workdir");
    201     if (!status) {
    202         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_workdir");
    203         return false;
    204     }
    205 
    206     psString label = psMetadataLookupStr(&status, config->args, "-set_label");
    207     if (!status) {
    208         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_label");
    209         return false;
    210     }
    211 
    212     psString reduction = psMetadataLookupStr(&status, config->args, "-set_reduction");
    213     if (!status) {
    214         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_reduction");
    215         return false;
    216     }
    217 
    218     psString expgroup = psMetadataLookupStr(&status, config->args, "-set_expgroup");
    219     if (!status) {
    220         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_expgroup");
    221         return false;
    222     }
    223 
    224     psString dvodb = psMetadataLookupStr(&status, config->args, "-set_dvodb");
    225     if (!status) {
    226         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_dvodb");
    227         return false;
    228     }
     155    PXOPT_LOOKUP_STR(workdir, config->args, "-set_workdir", false, false);
     156    PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
     157    PXOPT_LOOKUP_STR(reduction, config->args, "-set_reduction", false, false);
     158    PXOPT_LOOKUP_STR(expgroup, config->args, "-set_expgroup", false, false);
     159    PXOPT_LOOKUP_STR(dvodb, config->args, "-set_dvodb", false, false);
     160    PXOPT_LOOKUP_STR(tess_id, config->args, "-set_tess_id", false, false);
     161    PXOPT_LOOKUP_STR(end_stage, config->args, "-set_end_stage", false, false);
    229162
    230163    // find the exp_id of all the exposures that we want to queue up.
    … …  
    272205        psMetadata *md = output->data[i];
    273206
     207        bool status;
    274208        psS64 exp_id = psMetadataLookupS64(&status, md, "exp_id");
    275209        if (!status) {
    … …  
    280214
    281215        // queue the exp
    282         if (!pxchipQueueByExpTag(config, exp_id, workdir, label, reduction, expgroup, dvodb)) {
     216        if (!pxchipQueueByExpTag(config, exp_id, workdir, label, reduction, expgroup, dvodb, tess_id, end_stage)) {
    283217            if (!psDBRollback(config->dbh)) {
    284218                psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    304238    PS_ASSERT_PTR_NON_NULL(config, NULL);
    305239
    306     bool status = false;
    307     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    308     if (!status) {
    309         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
    310         return false;
    311     }
     240    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     241    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    312242
    313243    // XXX does this need to be constrained so that it won't return any results
    … …  
    350280    }
    351281
    352     bool simple = false;
    353     {
    354         bool status = false;
    355         simple = psMetadataLookupBool(&status, config->args, "-simple");
    356         if (!status) {
    357             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    358             return false;
    359         }
    360     }
    361 
    362282    if (!convertIdToStr(output)) {
    363283        psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    … …  
    383303    PS_ASSERT_PTR_NON_NULL(config, false);
    384304
    385     bool status = false;
    386305    // chip_id, ext_tag, class_id are required
    387     psString chip_id = psMetadataLookupStr(&status, config->args, "-chip_id");
    388     if (!status) {
    389         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -chip_id");
    390         return false;
    391     }
    392     if (!chip_id) {
    393         psError(PS_ERR_UNKNOWN, true, "-chip_id is required");
    394         return false;
    395     }
    396 
    397     psString exp_id = psMetadataLookupStr(&status, config->args, "-exp_id");
    398     if (!status) {
    399         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_id");
    400         return false;
    401     }
    402     if (!exp_id) {
    403         psError(PS_ERR_UNKNOWN, true, "-exp_id is required");
    404         return false;
    405     }
    406 
    407     psString class_id = psMetadataLookupStr(&status, config->args, "-class_id");
    408     if (!status) {
    409         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -class_id");
    410         return false;
    411     }
    412     if (!class_id) {
    413         psError(PS_ERR_UNKNOWN, true, "-class_id is required");
    414         return false;
    415     }
    416 
    417     psString uri = psMetadataLookupStr(&status, config->args, "-uri");
    418     if (!status) {
    419         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -uri");
    420         return false;
    421     }
    422 
    423     psF32 bg = psMetadataLookupF32(&status, config->args, "-bg");
    424     if (!status) {
    425         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg");
    426         return false;
    427     }
    428 
    429     psF32 bg_stdev = psMetadataLookupF32(&status, config->args, "-bg_stdev");
    430     if (!status) {
    431         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg_stdev");
    432         return false;
    433     }
    434 
    435     psF32 bg_mean_stdev = psMetadataLookupF32(&status, config->args, "-bg_mean_stdev");
    436     if (!status) {
    437         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg_mean_stdev");
    438         return false;
    439     }
    440 
    441     psF32 bias = psMetadataLookupF32(&status, config->args, "-bias");
    442     if (!status) {
    443         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bias");
    444         return false;
    445     }
    446 
    447     psF32 bias_stdev = psMetadataLookupF32(&status, config->args, "-bias_stdev");
    448     if (!status) {
    449         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bias_stdev");
    450         return false;
    451     }
    452 
    453     psF32 fringe_0 = psMetadataLookupF32(&status, config->args, "-fringe_0");
    454     if (!status) {
    455         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -fringe_0");
    456         return false;
    457     }
    458 
    459     psF32 fringe_1 = psMetadataLookupF32(&status, config->args, "-fringe_1");
    460     if (!status) {
    461         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -fringe_1");
    462         return false;
    463     }
    464 
    465     psF32 fringe_2 = psMetadataLookupF32(&status, config->args, "-fringe_2");
    466     if (!status) {
    467         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -fringe_2");
    468         return false;
    469     }
    470 
    471     psF32 sigma_ra = psMetadataLookupF32(&status, config->args, "-sigma_ra");
    472     if (!status) {
    473         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -sigma_ra");
    474         return false;
    475     }
    476 
    477     psF32 sigma_dec = psMetadataLookupF32(&status, config->args, "-sigma_dec");
    478     if (!status) {
    479         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -sigma_dec");
    480         return false;
    481     }
    482 
    483     psF32 ap_resid = psMetadataLookupF32(&status, config->args, "-ap_resid");
    484     if (!status) {
    485         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -ap_resid");
    486         return false;
    487     }
    488 
    489     psF32 ap_resid_stdev = psMetadataLookupF32(&status, config->args, "-ap_resid_stdev");
    490     if (!status) {
    491         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -ap_resid_stdev");
    492         return false;
    493     }
    494 
    495     psF32 fwhm = psMetadataLookupF32(&status, config->args, "-fwhm");
    496     if (!status) {
    497         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -fwhm");
    498         return false;
    499     }
    500 
    501     psF32 fwhm_range = psMetadataLookupF32(&status, config->args, "-fwhm_range");
    502     if (!status) {
    503         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -fwhm_range");
    504         return false;
    505     }
    506 
    507     psS32 n_stars = psMetadataLookupS32(&status, config->args, "-n_stars");
    508     if (!status) {
    509         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -n_stars");
    510         return false;
    511     }
    512 
    513     psS32 n_extended = psMetadataLookupS32(&status, config->args, "-n_extended");
    514     if (!status) {
    515         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -n_extended");
    516         return false;
    517     }
    518 
    519     psS32 n_cr = psMetadataLookupS32(&status, config->args, "-n_cr");
    520     if (!status) {
    521         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -n_cr");
    522         return false;
    523     }
    524 
    525     psS32 n_astrom = psMetadataLookupS32(&status, config->args, "-n_astrom");
    526     if (!status) {
    527         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -n_astrom");
    528         return false;
    529     }
     306    PXOPT_LOOKUP_STR(chip_id, config->args, "-chip_id", true, false);
     307    PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", true, false);
     308    PXOPT_LOOKUP_STR(class_id, config->args, "-class_id", true, false);
    530309
    531310    // optional
    532     psString path_base = psMetadataLookupStr(&status, config->args, "-path_base");
    533     if (!status) {
    534         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -path_base");
    535         return false;
    536     }
     311    PXOPT_LOOKUP_STR(uri, config->args, "-uri", false, false);
     312    PXOPT_LOOKUP_F32(bg, config->args, "-bg", false, false);
     313    PXOPT_LOOKUP_F32(bg_stdev, config->args, "-bg_stdev", false, false);
     314    PXOPT_LOOKUP_F32(bg_mean_stdev, config->args, "-bg_mean_stdev", false, false);
     315    PXOPT_LOOKUP_F32(bias, config->args, "-bias", false, false);
     316    PXOPT_LOOKUP_F32(bias_stdev, config->args, "-bias_stdev", false, false);
     317    PXOPT_LOOKUP_F32(fringe_0, config->args, "-fringe_0", false, false);
     318    PXOPT_LOOKUP_F32(fringe_1, config->args, "-fringe_1", false, false);
     319    PXOPT_LOOKUP_F32(fringe_2, config->args, "-fringe_2", false, false);
     320    PXOPT_LOOKUP_F32(sigma_ra, config->args, "-sigma_ra", false, false);
     321    PXOPT_LOOKUP_F32(sigma_dec, config->args, "-sigma_dec", false, false);
     322    PXOPT_LOOKUP_F32(ap_resid, config->args, "-ap_resid", false, false);
     323    PXOPT_LOOKUP_F32(ap_resid_stdev, config->args, "-ap_resid_stdev", false, false);
     324    PXOPT_LOOKUP_F32(fwhm, config->args, "-fwhm", false, false);
     325    PXOPT_LOOKUP_F32(fwhm_range, config->args, "-fwhm_range", false, false);
     326    PXOPT_LOOKUP_F32(n_stars, config->args, "-n_stars", false, false);
     327    PXOPT_LOOKUP_F32(n_extended, config->args, "-n_extended", false, false);
     328    PXOPT_LOOKUP_F32(n_cr, config->args, "-n_cr", false, false);
     329    PXOPT_LOOKUP_F32(n_astrom, config->args, "-n_astrom", false, false);
     330    PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", false, false);
    537331
    538332    // default values
    539     psS16 code = psMetadataLookupS16(&status, config->args, "-code");
    540     if (!status) {
    541         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -code");
    542         return false;
    543     }
     333    PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
    544334
    545335    if (!psDBTransaction(config->dbh)) {
    … …  
    548338    }
    549339
    550     chipProcessedImfileRow *imfile = chipProcessedImfileRowAlloc(
     340    if (!chipProcessedImfileInsert(config->dbh,
    551341        (psS64)atoll(chip_id),
    552342        (psS64)atoll(exp_id),
    … …  
    573363        path_base,
    574364        code
    575     );
    576     if (!imfile) {
     365    )) {
    577366        // rollback
    578367        if (!psDBRollback(config->dbh)) {
    579368            psError(PS_ERR_UNKNOWN, false, "database error");
    580369        }
    581         psError(PS_ERR_UNKNOWN, false, "failed to alloc chipProcessedImfileRow object");
    582         return false;
    583     }
    584     if (!chipProcessedImfileInsertObject(config->dbh, imfile)) {
    585         // rollback
    586         if (!psDBRollback(config->dbh)) {
    587             psError(PS_ERR_UNKNOWN, false, "database error");
    588         }
    589         psError(PS_ERR_UNKNOWN, false, "database error");
    590         psFree(imfile);
    591         return false;
    592     }
    593 
    594 
     370        psError(PS_ERR_UNKNOWN, false, "database error");
     371        return false;
     372    }
    595373
    596374    // XXX I've decided to make the transaction cover the Exp migration as
    … …  
    621399    PS_ASSERT_PTR_NON_NULL(config, NULL);
    622400
    623     bool status = false;
    624     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    625     if (!status) {
    626         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
    627         return false;
    628     }
    629 
    630     bool faulted = psMetadataLookupU64(&status, config->args, "-faulted");
    631     if (!status) {
    632         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -faulted");
    633         return false;
    634     }
     401    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     402    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     403    PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    635404
    636405    // XXX does this need to be constrained so that it won't return any results
    … …  
    681450    }
    682451
    683     bool simple = false;
    684     {
    685         bool status = false;
    686         simple = psMetadataLookupBool(&status, config->args, "-simple");
    687         if (!status) {
    688             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    689             return false;
    690         }
    691     }
    692 
    693452    if (!convertIdToStr(output)) {
    694453        psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    … …  
    744503    PS_ASSERT_PTR_NON_NULL(config, false);
    745504
    746     bool status = false;
    747     psS16 code = psMetadataLookupS16(&status, config->args, "-code");
    748     if (!status) {
    749         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -code");
    750         return false;
    751     }
    752     if (code == INT16_MAX) {
    753         psError(PS_ERR_UNKNOWN, true, "-code is required");
    754         return false;
    755     }
     505    PXOPT_LOOKUP_S16(code, config->args, "-code", true, false);
    756506
    757507    if (!pxSetFaultCode(config->dbh, "chipProcessedImfile", config->where, code)) {
    … …  
    768518    PS_ASSERT_PTR_NON_NULL(config, false);
    769519
    770     bool status = false;
    771     psString label = psMetadataLookupStr(&status, config->args, "-label");
    772     if (!status) {
    773         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -label");
    774         return false;
    775     }
    776     if (!label) {
    777         psError(PS_ERR_UNKNOWN, true, "-label is required");
    778         return false;
    779     }
     520    PXOPT_LOOKUP_STR(label, config->args, "-label", true, false);
    780521
    781522    if (!chipMaskInsert(config->dbh, label)) {
    … …  
    791532{
    792533    PS_ASSERT_PTR_NON_NULL(config, false);
     534
     535    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    793536
    794537    psString query = psStringCopy("SELECT * FROM chipMask");
    … …  
    810553        psFree(output);
    811554        return true;
    812     }
    813 
    814     bool simple = false;
    815     {
    816         bool status = false;
    817         simple = psMetadataLookupBool(&status, config->args, "-simple");
    818         if (!status) {
    819             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    820             return false;
    821         }
    822555    }
    823556
    … …  
    845578    PS_ASSERT_PTR_NON_NULL(config, false);
    846579
    847     bool status = false;
    848     psString label = psMetadataLookupStr(&status, config->args, "-label");
    849     if (!status) {
    850         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -label");
    851         return false;
    852     }
    853     if (!label) {
    854         psError(PS_ERR_UNKNOWN, true, "-label is required");
    855         return false;
    856     }
     580    PXOPT_LOOKUP_STR(label, config->args, "-label", true, false);
    857581
    858582    char *query = "DELETE FROM chipMask WHERE label = '%s'";
    … …  
    860584    if (!p_psDBRunQuery(config->dbh, query, label)) {
    861585        psError(PS_ERR_UNKNOWN, false, "database error");
    862         psFree(query);
    863586        return false;
    864587    }
    … …  
    909632            return false;
    910633        }
     634
     635        // should we stop here or proceed on to the cam stage?
     636        if (psStrcasestr(chipRun->end_stage, "chip")) {
     637            psFree(chipRun);
     638            continue;
     639        }
     640        // else continue on...
    911641
    912642        // camQueueChipID() can only be run after chipRun.state has been set to
    … …  
    918648                    chipRun->reduction,
    919649                    chipRun->expgroup,
    920                     chipRun->dvodb
     650                    chipRun->dvodb,
     651                    chipRun->tess_id,
     652                    chipRun->end_stage
    921653        )) {
    922654            // rollback

  • trunk/ippTools/src/chiptoolConfig.c

    r14227 r16170  
    5555    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-telescope",  0,
    5656            "search for telescope", NULL);
    57     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-dateobs_begin", 0,   
     57    psMetadataAddTime(queueArgs, PS_LIST_TAIL, "-dateobs_begin", 0,   
    5858            "search for exposures by time (>=)", NULL);
    59     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-dateobs_end", 0,
     59    psMetadataAddTime(queueArgs, PS_LIST_TAIL, "-dateobs_end", 0,
    6060            "search for exposures by time (<)", NULL);
    6161    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-exp_tag",  0,
    … …  
    269269    psMetadata *modes = psMetadataAlloc();
    270270
    271     PXTOOL_ADD_MODE("-queue",               "", CHIPTOOL_MODE_QUEUE,          queueArgs);
    272     PXTOOL_ADD_MODE("-pendingimfile",       "", CHIPTOOL_MODE_PENDINGIMFILE,  pendingimfileArgs);
    273     PXTOOL_ADD_MODE("-addprocessedimfile",  "", CHIPTOOL_MODE_ADDPROCESSEDIMFILE,addprocessedimfileArgs);
    274     PXTOOL_ADD_MODE("-processedimfile",     "", CHIPTOOL_MODE_PROCESSEDIMFILE, processedimfileArgs);
    275     PXTOOL_ADD_MODE("-updateprocessedimfile", "", CHIPTOOL_MODE_UPDATEPROCESSEDIMFILE,    updateprocessedimfileArgs);
    276     PXTOOL_ADD_MODE("-revertprocessedimfile", "", CHIPTOOL_MODE_REVERTPROCESSEDIMFILE,    revertprocessedimfileArgs);
    277     PXTOOL_ADD_MODE("-block",               "", CHIPTOOL_MODE_BLOCK,          blockArgs);
    278     PXTOOL_ADD_MODE("-masked",              "", CHIPTOOL_MODE_MASKED,         maskedArgs);
    279     PXTOOL_ADD_MODE("-unblock",             "",  CHIPTOOL_MODE_UNBLOCK,        unblockArgs);
     271    PXOPT_ADD_MODE("-queue",               "", CHIPTOOL_MODE_QUEUE,          queueArgs);
     272    PXOPT_ADD_MODE("-pendingimfile",       "", CHIPTOOL_MODE_PENDINGIMFILE,  pendingimfileArgs);
     273    PXOPT_ADD_MODE("-addprocessedimfile",  "", CHIPTOOL_MODE_ADDPROCESSEDIMFILE,addprocessedimfileArgs);
     274    PXOPT_ADD_MODE("-processedimfile",     "", CHIPTOOL_MODE_PROCESSEDIMFILE, processedimfileArgs);
     275    PXOPT_ADD_MODE("-updateprocessedimfile", "", CHIPTOOL_MODE_UPDATEPROCESSEDIMFILE,    updateprocessedimfileArgs);
     276    PXOPT_ADD_MODE("-revertprocessedimfile", "", CHIPTOOL_MODE_REVERTPROCESSEDIMFILE,    revertprocessedimfileArgs);
     277    PXOPT_ADD_MODE("-block",               "", CHIPTOOL_MODE_BLOCK,          blockArgs);
     278    PXOPT_ADD_MODE("-masked",              "", CHIPTOOL_MODE_MASKED,         maskedArgs);
     279    PXOPT_ADD_MODE("-unblock",             "",  CHIPTOOL_MODE_UNBLOCK,        unblockArgs);
    280280
    281281    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {

  • trunk/ippTools/src/detselect.c

    r15857 r16170  
    7575    PS_ASSERT_PTR_NON_NULL(config, false);
    7676
     77    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     78    PXOPT_LOOKUP_BOOL(unlimit, config->args, "-unlimit", false);
     79
     80    PXOPT_LOOKUP_TIME(time, config->args, "-time", false, false);
     81
    7782    psMetadata *where = psMetadataAlloc();
    7883
    7984    // airmass_min  < airmass  < airmass_max
    80     {
    81         bool status = false;
    82         psF32 airmass = psMetadataLookupF32(&status, config->args, "-airmass");
    83         if (!status) {
    84             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -airmass");
    85             psFree(where);
    86             return false;
    87         }
    88 
    89         if (!isnan(airmass)) {
    90             psMetadataAddF32(where, PS_LIST_TAIL, "airmass_min", 0, "<=", airmass);
    91             psMetadataAddF32(where, PS_LIST_TAIL, "airmass_max", 0, ">=", airmass);
    92         }
    93     }
     85    PXOPT_COPY_F32(config->args, where, "-airmass", "airmass_min", "<=");
     86    PXOPT_COPY_F32(config->args, where, "-airmass", "airmass_max", ">=");
    9487
    9588    // exp_time_min < exp_time < exp_time_max
    96     {
    97         bool status = false;
    98         psF32 exp_time = psMetadataLookupF32(&status, config->args, "-exp_time");
    99         if (!status) {
    100             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_time");
    101             psFree(where);
    102             return false;
    103         }
    104 
    105         if (!isnan(exp_time)) {
    106             psMetadataAddF32(where, PS_LIST_TAIL, "exp_time_min", 0, "<=", exp_time);
    107             psMetadataAddF32(where, PS_LIST_TAIL, "exp_time_max", 0, ">=", exp_time);
    108         }
    109     }
     89    PXOPT_COPY_F32(config->args, where, "-exp_time", "exp_time_min", "<=");
     90    PXOPT_COPY_F32(config->args, where, "-exp_time", "exp_time_max", ">=");
    11091
    11192    // ccd_temp_min < ccd_temp < ccd_temp_max
    112     {
    113         bool status = false;
    114         psF32 ccd_temp = psMetadataLookupF32(&status, config->args, "-ccd_temp");
    115         if (!status) {
    116             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -ccd_temp");
    117             psFree(where);
    118             return false;
    119         }
    120 
    121         if (!isnan(ccd_temp)) {
    122             psMetadataAddF32(where, PS_LIST_TAIL, "ccd_temp_min", 0, "<=", ccd_temp);
    123             psMetadataAddF32(where, PS_LIST_TAIL, "ccd_temp_max", 0, ">=", ccd_temp);
    124         }
    125     }
    126 
    127     {
    128         bool status = false;
    129         psF64 posang = psMetadataLookupF64(&status, config->args, "-posang");
    130         if (!status) {
    131             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -posang");
    132             psFree(where);
    133             return false;
    134         }
    135 
    136         if (!isnan(posang)) {
    137             psMetadataAddF32(where, PS_LIST_TAIL, "posang_min", 0, "<=", posang);
    138             psMetadataAddF32(where, PS_LIST_TAIL, "posang_max", 0, ">=", posang);
    139         }
    140     }
     93    PXOPT_COPY_F32(config->args, where, "-ccd_temp", "ccd_temp_min", "<=");
     94    PXOPT_COPY_F32(config->args, where, "-ccd_temp", "ccd_temp_max", ">=");
     95
     96    PXOPT_COPY_F64(config->args, where, "-posang", "posang_min", "<=");
     97    PXOPT_COPY_F64(config->args, where, "-posang", "posang_max", ">=");
    14198
    14299    // time_begin    < time     < time_end
    143     {
    144         bool status = false;
    145         psString timeStr = psMetadataLookupStr(&status, config->args, "-time");
    146         if (!status) {
    147             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -time");
    148             psFree(where);
    149             return false;
    150         }
    151 
    152         if (timeStr) {
    153             psTime *time = psTimeFromISO(timeStr, PS_TIME_UTC);
    154             if (!time) {
    155                 psError(PS_ERR_UNKNOWN, false, "error in time format %s", timeStr);
    156                 psFree(where);
    157                 return false;
    158             }
    159 
    160             // the == NULL tests invokes some psDB magic to make an OR
    161             // conditional query
    162             psMetadataAddTime(where, PS_LIST_TAIL, "time_begin", 0, "<=", time);
    163             psMetadataAddTime(where, PS_LIST_TAIL, "time_begin", PS_META_DUPLICATE_OK, "==", NULL);
    164             psMetadataAddTime(where, PS_LIST_TAIL, "time_end", 0, ">=", time);
    165             psMetadataAddTime(where, PS_LIST_TAIL, "time_end", PS_META_DUPLICATE_OK, "==", NULL);
    166             psFree(time);
    167         }
    168     }
     100    // the == NULL tests invokes some psDB magic to make an OR
     101    // conditional query
     102    psMetadataAddTime(where, PS_LIST_TAIL, "time_begin", 0, "<=", time);
     103    psMetadataAddTime(where, PS_LIST_TAIL, "time_begin", PS_META_DUPLICATE_OK, "==", NULL);
     104    psMetadataAddTime(where, PS_LIST_TAIL, "time_end", 0, ">=", time);
     105    psMetadataAddTime(where, PS_LIST_TAIL, "time_end", PS_META_DUPLICATE_OK, "==", NULL);
    169106
    170107    psString query = pxDataGet("detselect_search.sql");
    … …  
    189126    }
    190127
    191     // we choose the single detrend image which matches all criteria and has the latest
    192     // insertion date
     128    // we choose the single detrend image which matches all criteria and has
     129    // the latest insertion date
    193130
    194131    // unless explicitly specified by the user, list all possible matches
    195     if (!psMetadataLookupBool(NULL, config->args, "-unlimit")) {
    196         psStringAppend(&query, " ORDER BY registered DESC LIMIT 1");
     132    if (!unlimit) {
     133        psStringAppend(&query, " ORDER BY registered DESC LIMIT 1");
    197134    }
    198135
    … …  
    216153    }
    217154
    218     bool simple = false;
    219     {
    220         bool status = false;
    221         simple = psMetadataLookupBool(&status, config->args, "-simple");
    222         if (!status) {
    223             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    224             return false;
    225         }
    226     }
    227 
    228155    // negate simple so the default is true
    229156    if (!ippdbPrintMetadatas(stdout, output, "detExp", !simple)) {
    … …  
    241168{
    242169    PS_ASSERT_PTR_NON_NULL(config, false);
     170
     171    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    243172
    244173    psString query = pxDataGet("detselect_select.sql");
    … …  
    274203    }
    275204
    276     bool simple = false;
    277     {
    278         bool status = false;
    279         simple = psMetadataLookupBool(&status, config->args, "-simple");
    280         if (!status) {
    281             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    282             return false;
    283         }
    284     }
    285 
    286205    // negative simple so the default is true
    287206    if (!ippdbPrintMetadatas(stdout, output, "detNormalizedImfile", !simple)) {

  • trunk/ippTools/src/detselectConfig.c

    r15857 r16170  
    6262    psMetadataAddF64(searchArgs, PS_LIST_TAIL, "-posang", 0,
    6363            "search by rotator position angle", NAN);
    64     psMetadataAddStr(searchArgs, PS_LIST_TAIL, "-time", 0,
     64    psMetadataAddTime(searchArgs, PS_LIST_TAIL, "-time", 0,
    6565            "define time for desired detrend data", NULL);
    6666    psMetadataAddBool(searchArgs, PS_LIST_TAIL, "-simple",  0,
    … …  
    8383    psMetadata *modes = psMetadataAlloc();
    8484
    85     PXTOOL_ADD_MODE("-search",  "search for an appropriate detrend", DETSELECT_MODE_SEARCH, searchArgs);
    86     PXTOOL_ADD_MODE("-select",  "retreive detrend information", DETSELECT_MODE_SELECT, selectArgs);
     85    PXOPT_ADD_MODE("-search",  "search for an appropriate detrend", DETSELECT_MODE_SEARCH, searchArgs);
     86    PXOPT_ADD_MODE("-select",  "retreive detrend information", DETSELECT_MODE_SELECT, selectArgs);
    8787
    8888    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {

  • trunk/ippTools/src/dettool.c

    r15866 r16170  
    9292static bool register_detrendMode(pxConfig *config);
    9393
    94 static detNormalizedStatImfileRow *detStackedToDetNormalizedStatImfile(pxConfig *config, detStackedImfileRow *stackedImfile);
    95 static  detNormalizedImfileRow *detNormalizedStatToDetNormalizedmfile(pxConfig *config, detNormalizedStatImfileRow *statImfile);
    96 static detResidExpRow *mdToDetResidExp(pxConfig *config, psMetadata *row);
    9794static detRunSummaryRow *mdToDetRunSummary(pxConfig *config, psMetadata *row);
    9895//static psArray *validDetInputClassIds(pxConfig *config, const char *det_id);
    … …  
    212209    PS_ASSERT_PTR_NON_NULL(config, NULL);
    213210
    214      psString query = psStringCopy(
     211    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     212
     213    psString query = psStringCopy(
    215214        "SELECT"
    216215        "   rawExp.*"
    … …  
    247246    }
    248247
    249     bool simple = false;
    250     {
    251         bool status = false;
    252         simple = psMetadataLookupBool(&status, config->args, "-simple");
    253         if (!status) {
    254             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    255             return false;
    256         }
    257     }
    258 
    259248    // negative simple so the default is true
    260249    if (!ippdbPrintMetadatas(stdout, output, "rawExp", !simple)) {
    … …  
    271260static bool definebytagMode(pxConfig *config)
    272261{
    273     bool status     = false;
    274 
    275262    PS_ASSERT_PTR_NON_NULL(config, false);
    276263
    277264    // what type of detRun is this?
    278     // det_type is required
    279     psString det_type = psMetadataLookupStr(&status, config->args, "-det_type");
    280     if (!status) {
    281         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -det_type");
    282         return false;
    283     }
    284     if (!det_type) {
    285         psError(PS_ERR_UNKNOWN, true, "-det_type is required");
    286         return false;
    287     }
     265    // required
     266    PXOPT_LOOKUP_STR(det_type, config->args, "-det_type", true, false);
     267    PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false);
    288268
    289269    // optional
    290     psString filelevel = psMetadataLookupStr(&status, config->args, "-filelevel");
    291     if (!status) {
    292         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -filelevel");
    293         return false;
    294     }
    295 
    296     psString workdir = psMetadataLookupStr(&status, config->args, "-workdir");
    297     if (!status) {
    298         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -workdir");
    299         return false;
    300     }
    301     if (!workdir) {
    302         psError(PS_ERR_UNKNOWN, true, "-workdir is required");
    303         return false;
    304     }
    305 
    306     // optional
    307     psString mode = psMetadataLookupStr(&status, config->args, "-mode");
    308     if (!status) {
    309         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -mode");
    310         return false;
    311     }
     270    PXOPT_LOOKUP_STR(filelevel, config->args, "-filelevel", false, false);
     271    PXOPT_LOOKUP_STR(mode, config->args, "-mode", false, false);
    312272    // check mode
    313273    if (mode && !isValidMode(config, mode)) {
    … …  
    315275        return false;
    316276    }
    317     psString camera = psMetadataLookupStr(&status, config->args, "-inst");
    318     if (!status) {
    319         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -inst");
    320         return false;
    321     }
    322 
    323     psString telescope = psMetadataLookupStr(&status, config->args, "-telescope");
    324     if (!status) {
    325         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -telescope");
    326         return false;
    327     }
    328 
    329     psString exp_type = psMetadataLookupStr(&status, config->args, "-exp_type");
    330     if (!status) {
    331         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_type");
    332         return false;
    333     }
    334 
    335     psString filter = psMetadataLookupStr(&status, config->args, "-filter");
    336     if (!status) {
    337         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -filter");
    338         return false;
    339     }
    340 
    341     psF32 airmass_min = psMetadataLookupF32(&status, config->args, "-airmass_min");
    342     if (!status) {
    343         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -airmass_min");
    344         return false;
    345     }
    346 
    347     psF32 airmass_max = psMetadataLookupF32(&status, config->args, "-airmass_max");
    348     if (!status) {
    349         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -airmass_max");
    350         return false;
    351     }
    352 
    353     psF32 exp_time_min = psMetadataLookupF32(&status, config->args, "-exp_time_min");
    354     if (!status) {
    355         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_time_min");
    356         return false;
    357     }
    358 
    359     psF32 exp_time_max = psMetadataLookupF32(&status, config->args, "-exp_time_max");
    360     if (!status) {
    361         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_time_max");
    362         return false;
    363     }
    364 
    365     psF32 ccd_temp_min = psMetadataLookupF32(&status, config->args, "-ccd_temp_min");
    366     if (!status) {
    367         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -ccd_temp_min");
    368         return false;
    369     }
    370 
    371     psF32 ccd_temp_max = psMetadataLookupF32(&status, config->args, "-ccd_temp_max");
    372     if (!status) {
    373         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -ccd_temp_max");
    374         return false;
    375     }
    376 
    377     psF64 posang_min = psMetadataLookupF32(&status, config->args, "-posang_min");
    378     if (!status) {
    379         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -posang_min");
    380         return false;
    381     }
    382 
    383     psF64 posang_max = psMetadataLookupF32(&status, config->args, "-posang_max");
    384     if (!status) {
    385         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -posang_max");
    386         return false;
    387     }
    388     psF64 solang_min = psMetadataLookupF32(&status, config->args, "-solang_min");
    389     if (!status) {
    390         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -solang_min");
    391         return false;
    392     }
    393 
    394     psF64 solang_max = psMetadataLookupF32(&status, config->args, "-solang_max");
    395     if (!status) {
    396         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -solang_max");
    397         return false;
    398     }
    399 
    400     psTime *registered = NULL;
    401     {
    402         psString registeredStr = psMetadataLookupStr(&status, config->args, "-registered");
    403         if (!status) {
    404             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -registered");
    405             return false;
    406         }
    407         // pass through NULL as this is an optional field
    408         if (registeredStr) {
    409             registered = psTimeFromISO(registeredStr, PS_TIME_UTC);
    410             if (!registered) {
    411                 psError(PS_ERR_UNKNOWN, false, "error in time format %s", registeredStr);
    412                 return false;
    413             }
    414         } else {
    415             registered = NULL;
    416         }
    417     }
    418 
    419     psTime *time_begin = NULL;
    420     {
    421         psString time_beginStr = psMetadataLookupStr(&status, config->args, "-time_begin");
    422         if (!status) {
    423             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -time_begin");
    424             return false;
    425         }
    426         // pass through NULL as this is an optional field
    427         if (time_beginStr) {
    428             time_begin = psTimeFromISO(time_beginStr, PS_TIME_UTC);
    429             if (!time_begin) {
    430                 psError(PS_ERR_UNKNOWN, false, "error in time format %s", time_beginStr);
    431                 return false;
    432             }
    433         } else {
    434             time_begin = NULL;
    435         }
    436     }
    437 
    438     psTime *time_end = NULL;
    439     {
    440         psString time_endStr = psMetadataLookupStr(&status, config->args, "-time_end");
    441         if (!status) {
    442             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -time_end");
    443             return false;
    444         }
    445         // pass through NULL as this is an optional field
    446         if (time_endStr) {
    447             time_end = psTimeFromISO(time_endStr, PS_TIME_UTC);
    448             if (!time_end) {
    449                 psError(PS_ERR_UNKNOWN, false, "error in time format %s", time_endStr);
    450                 return false;
    451             }
    452         } else {
    453             time_end = NULL;
    454         }
    455     }
    456 
    457     psTime *use_begin = NULL;
    458     {
    459         psString use_beginStr = psMetadataLookupStr(&status, config->args, "-use_begin");
    460         if (!status) {
    461             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -use_begin");
    462             return false;
    463         }
    464         // pass through NULL as this is an optional field
    465         if (use_beginStr) {
    466             use_begin = psTimeFromISO(use_beginStr, PS_TIME_UTC);
    467             if (!use_begin) {
    468                 psError(PS_ERR_UNKNOWN, false, "error in time format %s", use_beginStr);
    469                 return false;
    470             }
    471         } else {
    472             use_begin = NULL;
    473         }
    474     }
    475 
    476     psTime *use_end = NULL;
    477     {
    478         psString use_endStr = psMetadataLookupStr(&status, config->args, "-use_end");
    479         if (!status) {
    480             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -use_end");
    481             return false;
    482         }
    483         // pass through NULL as this is an optional field
    484         if (use_endStr) {
    485             use_end = psTimeFromISO(use_endStr, PS_TIME_UTC);
    486             if (!use_end) {
    487                 psError(PS_ERR_UNKNOWN, false, "error in time format %s", use_endStr);
    488                 return false;
    489             }
    490         } else {
    491             use_end = NULL;
    492         }
    493     }
    494 
    495     psString reduction = psMetadataLookupStr(&status, config->args, "-reduction");
    496     if (!status) {
    497         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -reduction");
    498         return false;
    499     }
    500 
    501     psString label = psMetadataLookupStr(&status, config->args, "-label");
    502     if (!status) {
    503         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -label");
    504         return false;
    505     }
     277    PXOPT_LOOKUP_STR(camera, config->args, "-inst", false, false);
     278    PXOPT_LOOKUP_STR(telescope, config->args, "-telescope", false, false);
     279    PXOPT_LOOKUP_STR(exp_type, config->args, "-exp_type", false, false);
     280    PXOPT_LOOKUP_STR(filter, config->args, "-filter", false, false);
     281
     282    PXOPT_LOOKUP_F32(airmass_min, config->args, "-airmass_min", false, false);
     283    PXOPT_LOOKUP_F32(airmass_max, config->args, "-airmass_max", false, false);
     284    PXOPT_LOOKUP_F32(exp_time_min, config->args, "-exp_time_min", false, false);
     285    PXOPT_LOOKUP_F32(exp_time_max, config->args, "-exp_time_max", false, false);
     286    PXOPT_LOOKUP_F32(ccd_temp_min, config->args, "-ccd_temp_min", false, false);
     287    PXOPT_LOOKUP_F32(ccd_temp_max, config->args, "-ccd_temp_max", false, false);
     288    PXOPT_LOOKUP_F64(posang_min, config->args, "-posang_min", false, false);
     289    PXOPT_LOOKUP_F64(posang_max, config->args, "-posang_max", false, false);
     290    PXOPT_LOOKUP_F64(solang_min, config->args, "-solang_min", false, false);
     291    PXOPT_LOOKUP_F64(solang_max, config->args, "-solang_max", false, false);
     292    PXOPT_LOOKUP_TIME(time_begin, config->args, "-time_begin", false, false);
     293    PXOPT_LOOKUP_TIME(time_end, config->args, "-time_end", false, false);
     294    PXOPT_LOOKUP_TIME(use_begin, config->args, "-use_begin", false, false);
     295    PXOPT_LOOKUP_TIME(use_end, config->args, "-use_end", false, false);
     296    PXOPT_LOOKUP_STR(reduction, config->args, "-reduction", false, false);
     297    PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
     298
     299    // default
     300    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     301    PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
    506302
    507303    // we have to support multipe exp_ids
    … …  
    608404                 0       // parent
    609405        );
    610     psFree(registered);
    611     psFree(time_begin);
    612     psFree(time_end);
    613     psFree(use_begin);
    614     psFree(use_end);
    615406    psS64 det_id = psDBLastInsertID(config->dbh);
    616407
    … …  
    645436        psError(PS_ERR_UNKNOWN, false, "database error");
    646437        return false;
    647     }
    648 
    649     bool simple = false;
    650     {
    651         bool status = false;
    652         simple = psMetadataLookupBool(&status, config->args, "-simple");
    653         if (!status) {
    654             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    655             return false;
    656         }
    657438    }
    658439
    … …  
    721502static bool definebyqueryMode(pxConfig *config)
    722503{
    723     bool status     = false;
    724 
    725     PS_ASSERT_PTR_NON_NULL(config, false);
    726 
    727     // what type of detRun is this?
    728     // det_type is required
    729     psString det_type = psMetadataLookupStr(&status, config->args, "-det_type");
    730     if (!status) {
    731         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -det_type");
    732         return false;
    733     }
    734     if (!det_type) {
    735         psError(PS_ERR_UNKNOWN, true, "-det_type is required");
    736         return false;
    737     }
     504    PS_ASSERT_PTR_NON_NULL(config, false);
     505
     506    // required
     507    PXOPT_LOOKUP_STR(det_type, config->args, "-det_type", true, false);
     508    PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false);
     509    PXOPT_LOOKUP_STR(camera, config->args, "-inst", true, false);
    738510
    739511    // optional
    740     psString filelevel = psMetadataLookupStr(&status, config->args, "-filelevel");
    741     if (!status) {
    742         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -filelevel");
    743         return false;
    744     }
    745 
    746     psString workdir = psMetadataLookupStr(&status, config->args, "-workdir");
    747     if (!status) {
    748         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -workdir");
    749         return false;
    750     }
    751     if (!workdir) {
    752         psError(PS_ERR_UNKNOWN, true, "-workdir is required");
    753         return false;
    754     }
    755     psString camera = psMetadataLookupStr(&status, config->args, "-inst");
    756     if (!status) {
    757         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -inst");
    758         return false;
    759     }
    760     if (!camera) {
    761         psError(PS_ERR_UNKNOWN, false, "-inst is required");
    762         return false;
    763     }
     512    PXOPT_LOOKUP_STR(mode, config->args, "-mode", false, false);
     513    // check mode
     514    if (mode && !isValidMode(config, mode)) {
     515        psError(PS_ERR_UNKNOWN, false, "invalud mode");
     516        return false;
     517    }
     518    PXOPT_LOOKUP_STR(filelevel, config->args, "-filelevel", false, false);
     519    PXOPT_LOOKUP_STR(telescope, config->args, "-telescope", false, false);
     520    PXOPT_LOOKUP_STR(filter, config->args, "-filter", false, false);
     521    PXOPT_LOOKUP_F32(airmass_min, config->args, "-airmass_min", false, false);
     522    PXOPT_LOOKUP_F32(airmass_max, config->args, "-airmass_max", false, false);
     523    PXOPT_LOOKUP_F32(exp_time_min, config->args, "-exp_time_min", false, false);
     524    PXOPT_LOOKUP_F32(exp_time_max, config->args, "-exp_time_max", false, false);
     525    PXOPT_LOOKUP_F32(ccd_temp_min, config->args, "-ccd_temp_min", false, false);
     526    PXOPT_LOOKUP_F32(ccd_temp_max, config->args, "-ccd_temp_max", false, false);
     527    PXOPT_LOOKUP_F64(posang_min, config->args, "-posang_min", false, false);
     528    PXOPT_LOOKUP_F64(posang_max, config->args, "-posang_max", false, false);
     529    PXOPT_LOOKUP_F64(solang_min, config->args, "-solang_min", false, false);
     530    PXOPT_LOOKUP_F64(solang_max, config->args, "-solang_max", false, false);
     531
     532    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
     533    PXOPT_LOOKUP_STR(reduction, config->args, "-reduction", false, false);
     534    PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
     535    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     536
     537    PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
     538    PXOPT_LOOKUP_TIME(time_begin, config->args, "-time_begin", false, false);
     539    PXOPT_LOOKUP_TIME(time_end, config->args, "-time_end", false, false);
     540    PXOPT_LOOKUP_TIME(use_begin, config->args, "-use_begin", false, false);
     541    PXOPT_LOOKUP_TIME(use_end, config->args, "-use_end", false, false);
    764542
    765543    psMetadata *where = psMetadataAlloc();
    766     {
    767         bool status = false;
    768         psString exp_type = psMetadataLookupStr(&status, config->args, "-select_exp_type");
    769         if (!status) {
    770             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -select_exp_type");
    771             return false;
    772         }
    773         if (exp_type) {
    774             if (!psMetadataAddStr(where, PS_LIST_TAIL, "exp_type", 0, "==", exp_type)) {
    775                 psError(PS_ERR_UNKNOWN, false, "failed to add item exp_type");
    776                 psFree(where);
    777                 return false;
    778             }
    779         }
    780 
    781         // map -inst -> camera
    782         psString camera = psMetadataLookupStr(&status, config->args, "-select_inst");
    783         if (!status) {
    784             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -select_inst");
    785             return false;
    786         }
    787         if (camera) {
    788             if (!psMetadataAddStr(where, PS_LIST_TAIL, "camera", 0, "==", camera)) {
    789                 psError(PS_ERR_UNKNOWN, false, "failed to add item inst");
    790                 psFree(where);
    791                 return false;
    792             }
    793         }
    794 
    795         psString telescope = psMetadataLookupStr(&status, config->args, "-select_telescope");
    796         if (!status) {
    797             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -select_telescope");
    798             return false;
    799         }
    800         if (telescope) {
    801             if (!psMetadataAddStr(where, PS_LIST_TAIL, "telescope", 0, "==", telescope)) {
    802                 psError(PS_ERR_UNKNOWN, false, "failed to add item telescope");
    803                 psFree(where);
    804                 return false;
    805             }
    806         }
    807 
    808         psString filter = psMetadataLookupStr(&status, config->args, "-select_filter");
    809         if (!status) {
    810             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -select_filter");
    811             return false;
    812         }
    813         if (filter) {
    814             if (!psMetadataAddStr(where, PS_LIST_TAIL, "filter", 0, "==", filter)) {
    815                 psError(PS_ERR_UNKNOWN, false, "failed to add item filter");
    816                 psFree(where);
    817                 return false;
    818             }
    819         }
    820 
    821         psString uri = psMetadataLookupStr(&status, config->args, "-select_uri");
    822         if (!status) {
    823             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -select_uri");
    824             return false;
    825         }
    826         if (uri) {
    827             if (!psMetadataAddStr(where, PS_LIST_TAIL, "uri", 0, "==", uri)) {
    828                 psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
    829                 psFree(where);
    830                 return false;
    831             }
    832         }
    833 
    834         psString dateobs_begin = psMetadataLookupStr(&status, config->args, "-select_dateobs_begin");
    835         if (!status) {
    836             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -select_dateobs_begin");
    837             psFree(where);
    838             return false;
    839         }
    840         if (dateobs_begin) {
    841             psTime *time = psTimeFromISO(dateobs_begin, PS_TIME_UTC);
    842             if (!time) {
    843                 psError(PS_ERR_UNKNOWN, false, "error in time format %s", dateobs_begin);
    844                 psFree(time);
    845                 psFree(where);
    846                 return false;
    847             }
    848             if (!psMetadataAddTime(where, PS_LIST_TAIL, "dateobs", PS_META_DUPLICATE_OK, ">=", time)) {
    849                 psError(PS_ERR_UNKNOWN, false, "failed to add item dateobs");
    850                 psFree(time);
    851                 psFree(where);
    852                 return false;
    853             }
    854             psFree(time);
    855         }
    856 
    857         psString dateobs_end = psMetadataLookupStr(&status, config->args, "-select_dateobs_end");
    858         if (!status) {
    859             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -select_dateobs_end");
    860             psFree(where);
    861             return false;
    862         }
    863         if (dateobs_end) {
    864             psTime *time = psTimeFromISO(dateobs_end, PS_TIME_UTC);
    865             if (!time) {
    866                 psError(PS_ERR_UNKNOWN, false, "error in time format %s", dateobs_end);
    867                 psFree(time);
    868                 psFree(where);
    869                 return false;
    870             }
    871             if (!psMetadataAddTime(where, PS_LIST_TAIL, "dateobs", PS_META_DUPLICATE_OK, "<", time)) {
    872                 psError(PS_ERR_UNKNOWN, false, "failed to add item dateobs");
    873                 psFree(time);
    874                 psFree(where);
    875                 return false;
    876             }
    877             psFree(time);
    878         }
    879 
    880         /** selection based on airmass range **/
    881         psF32 select_airmass_min = psMetadataLookupF32(&status, config->args, "-select_airmass_min");
    882         if (!status) {
    883             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -select_airmass_min");
    884             psFree(where);
    885             return false;
    886         }
    887         if (isfinite(select_airmass_min)) {
    888             if (!psMetadataAddF32(where, PS_LIST_TAIL, "airmass", PS_META_DUPLICATE_OK, ">=", select_airmass_min)) {
    889                 psError(PS_ERR_UNKNOWN, false, "failed to add item airmass");
    890                 psFree(where);
    891                 return false;
    892             }
    893         }
    894         psF32 select_airmass_max = psMetadataLookupF32(&status, config->args, "-select_airmass_max");
    895         if (!status) {
    896             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -select_airmass_max");
    897             psFree(where);
    898             return false;
    899         }
    900         if (isfinite(select_airmass_max)) {
    901             if (!psMetadataAddF32(where, PS_LIST_TAIL, "airmass", PS_META_DUPLICATE_OK, "<=", select_airmass_max)) {
    902                 psError(PS_ERR_UNKNOWN, false, "failed to add item airmass");
    903                 psFree(where);
    904                 return false;
    905             }
    906         }
    907 
    908         psF32 select_sat_pixel_frac_max = psMetadataLookupF32(&status, config->args, "-select_sat_pixel_frac_max");
    909         if (!status) {
    910             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -select_sat_pixel_frac_max");
    911             psFree(where);
    912             return false;
    913         }
    914         if (isfinite(select_sat_pixel_frac_max)) {
    915             if (!psMetadataAddF32(where, PS_LIST_TAIL, "sat_pixel_frac", PS_META_DUPLICATE_OK, "<=", select_sat_pixel_frac_max)) {
    916                 psError(PS_ERR_UNKNOWN, false, "failed to add item sat_pixel_frac");
    917                 psFree(where);
    918                 return false;
    919             }
    920         }
    921 
    922         /** selection based on exp_time range **/
    923         psF32 select_exp_time_min = psMetadataLookupF32(&status, config->args, "-select_exp_time_min");
    924         if (!status) {
    925             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -select_exp_time_min");
    926             psFree(where);
    927             return false;
    928         }
    929         if (isfinite(select_exp_time_min)) {
    930             if (!psMetadataAddF32(where, PS_LIST_TAIL, "exp_time", PS_META_DUPLICATE_OK, ">=", select_exp_time_min)) {
    931                 psError(PS_ERR_UNKNOWN, false, "failed to add item exp_time");
    932                 psFree(where);
    933                 return false;
    934             }
    935         }
    936         psF32 select_exp_time_max = psMetadataLookupF32(&status, config->args, "-select_exp_time_max");
    937         if (!status) {
    938             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -select_exp_time_max");
    939             psFree(where);
    940             return false;
    941         }
    942         if (isfinite(select_exp_time_max)) {
    943             if (!psMetadataAddF32(where, PS_LIST_TAIL, "exp_time", PS_META_DUPLICATE_OK, "<=", select_exp_time_max)) {
    944                 psError(PS_ERR_UNKNOWN, false, "failed to add item exp_time");
    945                 psFree(where);
    946                 return false;
    947             }
    948         }
    949 
    950         /** selection based on ccd_temp range **/
    951         psF32 select_ccd_temp_min = psMetadataLookupF32(&status, config->args, "-select_ccd_temp_min");
    952         if (!status) {
    953             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -select_ccd_temp_min");
    954             psFree(where);
    955             return false;
    956         }
    957         if (isfinite(select_ccd_temp_min)) {
    958             if (!psMetadataAddF32(where, PS_LIST_TAIL, "ccd_temp", PS_META_DUPLICATE_OK, ">=", select_ccd_temp_min)) {
    959                 psError(PS_ERR_UNKNOWN, false, "failed to add item ccd_temp");
    960                 psFree(where);
    961                 return false;
    962             }
    963         }
    964         psF32 select_ccd_temp_max = psMetadataLookupF32(&status, config->args, "-select_ccd_temp_max");
    965         if (!status) {
    966             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -select_ccd_temp_max");
    967             psFree(where);
    968             return false;
    969         }
    970         if (isfinite(select_ccd_temp_max)) {
    971             if (!psMetadataAddF32(where, PS_LIST_TAIL, "ccd_temp", PS_META_DUPLICATE_OK, "<=", select_ccd_temp_max)) {
    972                 psError(PS_ERR_UNKNOWN, false, "failed to add item ccd_temp");
    973                 psFree(where);
    974                 return false;
    975             }
    976         }
    977 
    978         /** selection based on posang **/
    979         psF32 select_posang_min = psMetadataLookupF32(&status, config->args, "-select_posang_min");
    980         if (!status) {
    981             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -select_posang_min");
    982             psFree(where);
    983             return false;
    984         }
    985         if (isfinite(select_posang_min)) {
    986             if (!psMetadataAddF32(where, PS_LIST_TAIL, "posang", PS_META_DUPLICATE_OK, ">=", select_posang_min)) {
    987                 psError(PS_ERR_UNKNOWN, false, "failed to add item posang");
    988                 psFree(where);
    989                 return false;
    990             }
    991         }
    992         psF32 select_posang_max = psMetadataLookupF32(&status, config->args, "-select_posang_max");
    993         if (!status) {
    994             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -select_posang_max");
    995             psFree(where);
    996             return false;
    997         }
    998         if (isfinite(select_posang_max)) {
    999             if (!psMetadataAddF32(where, PS_LIST_TAIL, "posang", PS_META_DUPLICATE_OK, "<=", select_posang_max)) {
    1000                 psError(PS_ERR_UNKNOWN, false, "failed to add item posang");
    1001                 psFree(where);
    1002                 return false;
    1003             }
    1004         }
    1005 
    1006         /** selection based on solang **/
    1007         psF32 select_solang_min = psMetadataLookupF32(&status, config->args, "-select_solang_min");
    1008         if (!status) {
    1009             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -select_solang_min");
    1010             psFree(where);
    1011             return false;
    1012         }
    1013         if (isfinite(select_solang_min)) {
    1014             if (!psMetadataAddF32(where, PS_LIST_TAIL, "solang", PS_META_DUPLICATE_OK, ">=", select_solang_min)) {
    1015                 psError(PS_ERR_UNKNOWN, false, "failed to add item solang");
    1016                 psFree(where);
    1017                 return false;
    1018             }
    1019         }
    1020         psF32 select_solang_max = psMetadataLookupF32(&status, config->args, "-select_solang_max");
    1021         if (!status) {
    1022             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -select_solang_max");
    1023             psFree(where);
    1024             return false;
    1025         }
    1026         if (isfinite(select_solang_max)) {
    1027             if (!psMetadataAddF32(where, PS_LIST_TAIL, "solang", PS_META_DUPLICATE_OK, "<=", select_solang_max)) {
    1028                 psError(PS_ERR_UNKNOWN, false, "failed to add item solang");
    1029                 psFree(where);
    1030                 return false;
    1031             }
    1032         }
    1033 
    1034     }
     544    PXOPT_COPY_STR(config->args, where, "-select_exp_type", "exp_type", "==");
     545    // map -inst -> camera
     546    PXOPT_COPY_STR(config->args, where, "-select_inst", "camera", "==");
     547    PXOPT_COPY_STR(config->args, where, "-select_telescope", "telescope", "==");
     548    PXOPT_COPY_STR(config->args, where, "-select_filter", "filter", "==");
     549    PXOPT_COPY_STR(config->args, where, "-select_uri", "uri", "==");
     550    PXOPT_COPY_TIME(config->args, where, "-select_dateobs_begin", "dateobs", ">=");
     551    PXOPT_COPY_TIME(config->args, where, "-select_dateobs_end", "dateobs", "<");
     552    PXOPT_COPY_F32(config->args, where, "-select_airmass_min", "airmass", ">=");
     553    PXOPT_COPY_F32(config->args, where, "-select_airmass_max", "airmass", "<=");
     554    PXOPT_COPY_F32(config->args, where, "-select_sat_pixel_frac_max", "sat_pixel_frac", "<=");
     555    PXOPT_COPY_F32(config->args, where, "-select_exp_time_min", "exp_time", ">=");
     556    PXOPT_COPY_F32(config->args, where, "-select_exp_time_max", "exp_time", "<=");
     557    PXOPT_COPY_F32(config->args, where, "-select_ccd_temp_min", "ccd_temp", ">=");
     558    PXOPT_COPY_F32(config->args, where, "-select_ccd_temp_max", "ccd_temp", "<=");
     559    PXOPT_COPY_F32(config->args, where, "-select_posang_min", "posang", ">=");
     560    PXOPT_COPY_F32(config->args, where, "-select_posang_max", "posang", "<=");
     561    PXOPT_COPY_F32(config->args, where, "-select_solang_min", "solang", ">=");
     562    PXOPT_COPY_F32(config->args, where, "-select_solang_max", "solang", "<=");
    1035563
    1036564    if (!psListLength(where->list)) {
    … …  
    1043571    // like to assign values to so I've seperated them but prepending set- to
    1044572    // the assigned values
    1045 
    1046     // optional
    1047     psString mode = psMetadataLookupStr(&status, config->args, "-mode");
    1048     if (!status) {
    1049         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -mode");
    1050         return false;
    1051     }
    1052     // check mode
    1053     if (mode && !isValidMode(config, mode)) {
    1054         psError(PS_ERR_UNKNOWN, false, "invalud mode");
    1055         return false;
    1056     }
    1057 
    1058     psString telescope = psMetadataLookupStr(&status, config->args, "-telescope");
    1059     if (!status) {
    1060         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -telescope");
    1061         return false;
    1062     }
    1063 
    1064     psString filter = psMetadataLookupStr(&status, config->args, "-filter");
    1065     if (!status) {
    1066         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -filter");
    1067         return false;
    1068     }
    1069 
    1070     psF32 airmass_min = psMetadataLookupF32(&status, config->args, "-airmass_min");
    1071     if (!status) {
    1072         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -airmass_min");
    1073         return false;
    1074     }
    1075 
    1076     psF32 airmass_max = psMetadataLookupF32(&status, config->args, "-airmass_max");
    1077     if (!status) {
    1078         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -airmass_max");
    1079         return false;
    1080     }
    1081 
    1082     psF32 exp_time_min = psMetadataLookupF32(&status, config->args, "-exp_time_min");
    1083     if (!status) {
    1084         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_time_min");
    1085         return false;
    1086     }
    1087 
    1088     psF32 exp_time_max = psMetadataLookupF32(&status, config->args, "-exp_time_max");
    1089     if (!status) {
    1090         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_time_max");
    1091         return false;
    1092     }
    1093 
    1094     psF32 ccd_temp_min = psMetadataLookupF32(&status, config->args, "-ccd_temp_min");
    1095     if (!status) {
    1096         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -ccd_temp_min");
    1097         return false;
    1098     }
    1099 
    1100     psF32 ccd_temp_max = psMetadataLookupF32(&status, config->args, "-ccd_temp_max");
    1101     if (!status) {
    1102         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -ccd_temp_max");
    1103         return false;
    1104     }
    1105 
    1106     psF64 posang_min = psMetadataLookupF32(&status, config->args, "-posang_min");
    1107     if (!status) {
    1108         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -posang_min");
    1109         return false;
    1110     }
    1111 
    1112     psF64 posang_max = psMetadataLookupF32(&status, config->args, "-posang_max");
    1113     if (!status) {
    1114         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -posang_max");
    1115         return false;
    1116     }
    1117 
    1118     psF64 solang_min = psMetadataLookupF32(&status, config->args, "-solang_min");
    1119     if (!status) {
    1120         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -solang_min");
    1121         return false;
    1122     }
    1123 
    1124     psF64 solang_max = psMetadataLookupF32(&status, config->args, "-solang_max");
    1125     if (!status) {
    1126         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -solang_max");
    1127         return false;
    1128     }
    1129 
    1130     psTime *registered = NULL;
    1131     {
    1132         psString registeredStr = psMetadataLookupStr(&status, config->args, "-registered");
    1133         if (!status) {
    1134             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -registered");
    1135             return false;
    1136         }
    1137         // pass through NULL as this is an optional field
    1138         if (registeredStr) {
    1139             registered = psTimeFromISO(registeredStr, PS_TIME_UTC);
    1140             if (!registered) {
    1141                 psError(PS_ERR_UNKNOWN, false, "error in time format %s", registeredStr);
    1142                 return false;
    1143             }
    1144         } else {
    1145             registered = NULL;
    1146         }
    1147     }
    1148 
    1149     psTime *time_begin = NULL;
    1150     {
    1151         psString time_beginStr = psMetadataLookupStr(&status, config->args, "-time_begin");
    1152         if (!status) {
    1153             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -time_begin");
    1154             return false;
    1155         }
    1156         // pass through NULL as this is an optional field
    1157         if (time_beginStr) {
    1158             time_begin = psTimeFromISO(time_beginStr, PS_TIME_UTC);
    1159             if (!time_begin) {
    1160                 psError(PS_ERR_UNKNOWN, false, "error in time format %s", time_beginStr);
    1161                 return false;
    1162             }
    1163         } else {
    1164             time_begin = NULL;
    1165         }
    1166     }
    1167 
    1168     psTime *time_end = NULL;
    1169     {
    1170         psString time_endStr = psMetadataLookupStr(&status, config->args, "-time_end");
    1171         if (!status) {
    1172             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -time_end");
    1173             return false;
    1174         }
    1175         // pass through NULL as this is an optional field
    1176         if (time_endStr) {
    1177             time_end = psTimeFromISO(time_endStr, PS_TIME_UTC);
    1178             if (!time_end) {
    1179                 psError(PS_ERR_UNKNOWN, false, "error in time format %s", time_endStr);
    1180                 return false;
    1181             }
    1182         } else {
    1183             time_end = NULL;
    1184         }
    1185     }
    1186 
    1187     psTime *use_begin = NULL;
    1188     {
    1189         psString use_beginStr = psMetadataLookupStr(&status, config->args, "-use_begin");
    1190         if (!status) {
    1191             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -use_begin");
    1192             return false;
    1193         }
    1194         // pass through NULL as this is an optional field
    1195         if (use_beginStr) {
    1196             use_begin = psTimeFromISO(use_beginStr, PS_TIME_UTC);
    1197             if (!use_begin) {
    1198                 psError(PS_ERR_UNKNOWN, false, "error in time format %s", use_beginStr);
    1199                 return false;
    1200             }
    1201         } else {
    1202             use_begin = NULL;
    1203         }
    1204     }
    1205 
    1206     psTime *use_end = NULL;
    1207     {
    1208         psString use_endStr = psMetadataLookupStr(&status, config->args, "-use_end");
    1209         if (!status) {
    1210             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -use_end");
    1211             return false;
    1212         }
    1213         // pass through NULL as this is an optional field
    1214         if (use_endStr) {
    1215             use_end = psTimeFromISO(use_endStr, PS_TIME_UTC);
    1216             if (!use_end) {
    1217                 psError(PS_ERR_UNKNOWN, false, "error in time format %s", use_endStr);
    1218                 return false;
    1219             }
    1220         } else {
    1221             use_end = NULL;
    1222         }
    1223     }
    1224 
    1225     psString reduction = psMetadataLookupStr(&status, config->args, "-reduction");
    1226     if (!status) {
    1227         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -reduction");
    1228         return false;
    1229     }
    1230 
    1231     psString label = psMetadataLookupStr(&status, config->args, "-label");
    1232     if (!status) {
    1233         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -label");
    1234         return false;
    1235     }
    1236 
    1237     bool simple = psMetadataLookupBool(&status, config->args, "-simple");
    1238     if (!status) {
    1239         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    1240         psFree(registered);
    1241         psFree(use_begin);
    1242         psFree(use_end);
    1243         return false;
    1244     }
    1245 
    1246     bool pretend = psMetadataLookupBool(&status, config->args, "-pretend");
    1247     if (!status) {
    1248         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -pretend");
    1249         psFree(registered);
    1250         psFree(use_begin);
    1251         psFree(use_end);
    1252         return false;
    1253     }
    1254573
    1255574    // search for rawExps with the specified options
    … …  
    1259578    if (!detrendExps) {
    1260579        psError(PS_ERR_UNKNOWN, false, "database error");
    1261         psFree(registered);
    1262         psFree(use_begin);
    1263         psFree(use_end);
    1264580        return false;
    1265581    }
    … …  
    1267583        psTrace("dettool", PS_LOG_INFO, "no rows found");
    1268584        psFree(detrendExps);
    1269         psFree(registered);
    1270         psFree(use_begin);
    1271         psFree(use_end);
    1272585        return true;
    1273586    }
    … …  
    1283596            psError(PS_ERR_UNKNOWN, false, "failed to print array");
    1284597            psFree(detrendExps);
    1285             psFree(registered);
    1286             psFree(use_begin);
    1287             psFree(use_end);
    1288598            return false;
    1289599        }
    1290600        psFree(detrendExps);
    1291         psFree(registered);
    1292         psFree(use_begin);
    1293         psFree(use_end);
    1294601        return true;
    1295602    }
    … …  
    1299606        psError(PS_ERR_UNKNOWN, false, "database error");
    1300607        psFree(detrendExps);
    1301         psFree(registered);
    1302         psFree(use_begin);
    1303         psFree(use_end);
    1304608        return false;
    1305609    }
    … …  
    1338642                 0       // parent
    1339643        );
    1340     psFree(registered);
    1341     psFree(time_begin);
    1342     psFree(time_end);
    1343     psFree(use_end);
    1344     psFree(use_begin);
    1345     psFree(use_end);
    1346644    psS64 det_id = psDBLastInsertID(config->dbh);
    1347645
    … …  
    1417715static bool definebydetrunMode(pxConfig *config)
    1418716{
    1419     bool status     = false;
    1420 
    1421     PS_ASSERT_PTR_NON_NULL(config, false);
    1422 
    1423     // det_id is the only required input
    1424     psString det_id = psMetadataLookupStr(&status, config->args, "-det_id");
    1425     if (!status) {
    1426         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -det_id");
    1427         return false;
    1428     }
    1429     if (!det_id) {
    1430         psError(PS_ERR_UNKNOWN, true, "-det_id is required");
    1431         return false;
    1432     }
     717    PS_ASSERT_PTR_NON_NULL(config, false);
     718
     719    // required
     720    PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false);
     721
     722    // optional
     723    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     724    PXOPT_LOOKUP_STR(det_type, config->args, "-set_det_type", false, false);
     725    PXOPT_LOOKUP_STR(mode, config->args, "-set_mode", false, false);
     726    // check mode
     727    if (mode && !isValidMode(config, mode)) {
     728        psError(PS_ERR_UNKNOWN, false, "invalud mode");
     729        return false;
     730    }
     731    PXOPT_LOOKUP_STR(camera, config->args, "-set_inst", false, false);
     732    PXOPT_LOOKUP_STR(telescope, config->args, "-set_telescope", false, false);
     733    PXOPT_LOOKUP_STR(exp_type, config->args, "-set_exp_type", false, false);
     734    PXOPT_LOOKUP_STR(filelevel, config->args, "-set_filelevel", false, false);
     735    PXOPT_LOOKUP_STR(workdir, config->args, "-set_workdir", false, false);
     736    PXOPT_LOOKUP_STR(filter, config->args, "-set_filter", false, false);
     737
     738    PXOPT_LOOKUP_F32(airmass_min, config->args, "-set_airmass_min", false, false);
     739    PXOPT_LOOKUP_F32(airmass_max, config->args, "-set_airmass_max", false, false);
     740    PXOPT_LOOKUP_F32(exp_time_min, config->args, "-set_exp_time_min", false, false);
     741    PXOPT_LOOKUP_F32(exp_time_max, config->args, "-set_exp_time_max", false, false);
     742    PXOPT_LOOKUP_F32(ccd_temp_min, config->args, "-set_ccd_temp_min", false, false);
     743    PXOPT_LOOKUP_F32(ccd_temp_max, config->args, "-set_ccd_temp_max", false, false);
     744    PXOPT_LOOKUP_F32(posang_min, config->args, "-set_posang_min", false, false);
     745    PXOPT_LOOKUP_F32(posang_max, config->args, "-set_posang_max", false, false);
     746    PXOPT_LOOKUP_F32(solang_min, config->args, "-set_solang_min", false, false);
     747    PXOPT_LOOKUP_F32(solang_max, config->args, "-set_solang_max", false, false);
     748    PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
     749    PXOPT_LOOKUP_TIME(registered, config->args, "-set_registered", false, false);
     750    PXOPT_LOOKUP_TIME(time_begin, config->args, "-set_time_begin", false, false);
     751    PXOPT_LOOKUP_TIME(time_end, config->args, "-set_end", false, false);
     752    PXOPT_LOOKUP_TIME(use_begin, config->args, "-use_begin", false, false);
     753    PXOPT_LOOKUP_TIME(use_end, config->args, "-use_end", false, false);
     754    PXOPT_LOOKUP_STR(reduction, config->args, "-set_reduction", false, false);
     755
    1433756
    1434757    // lookup the detRun that we will be basing this one on
    … …  
    1467790
    1468791    // walk through the optional values and update the detRun as required
    1469     psString det_type = psMetadataLookupStr(&status, config->args, "-set_det_type");
    1470     if (!status) {
    1471         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_det_type");
    1472         return false;
    1473     }
    1474792    if (det_type) {
    1475793        psFree(detRun->det_type);
    … …  
    1477795    }
    1478796
    1479     psString mode = psMetadataLookupStr(&status, config->args, "-set_mode");
    1480     if (!status) {
    1481         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_mode");
    1482         return false;
    1483     }
    1484     // check mode
    1485     if (mode && !isValidMode(config, mode)) {
    1486         psError(PS_ERR_UNKNOWN, false, "invalud mode");
    1487         return false;
    1488     }
    1489797    if (mode) {
    1490798        psFree(detRun->mode);
    … …  
    1492800    }
    1493801
    1494     psString camera = psMetadataLookupStr(&status, config->args, "-set_inst");
    1495     if (!status) {
    1496         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_inst");
    1497         return false;
    1498     }
    1499802    if (camera) {
    1500803        psFree(detRun->camera);
    … …  
    1502805    }
    1503806
    1504     psString telescope = psMetadataLookupStr(&status, config->args, "-set_telescope");
    1505     if (!status) {
    1506         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_telescope");
    1507         return false;
    1508     }
    1509807    if (telescope) {
    1510808        psFree(detRun->telescope);
    … …  
    1512810    }
    1513811
    1514     psString exp_type = psMetadataLookupStr(&status, config->args, "-set_exp_type");
    1515     if (!status) {
    1516         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_exp_type");
    1517         return false;
    1518     }
    1519812    if (exp_type) {
    1520813        psFree(detRun->exp_type);
    … …  
    1522815    }
    1523816
    1524     psString filelevel = psMetadataLookupStr(&status, config->args, "-set_filelevel");
    1525     if (!status) {
    1526         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_filelevel");
    1527         return false;
    1528     }
    1529817    if (filelevel) {
    1530818        psFree(detRun->filelevel);
    … …  
    1532820    }
    1533821
    1534     psString workdir = psMetadataLookupStr(&status, config->args, "-set_workdir");
    1535     if (!status) {
    1536         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_workdir");
    1537         return false;
    1538     }
    1539822    if (workdir) {
    1540823        psFree(detRun->workdir);
    … …  
    1542825    }
    1543826
    1544     psString filter = psMetadataLookupStr(&status, config->args, "-set_filter");
    1545     if (!status) {
    1546         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_filter");
    1547         return false;
    1548     }
    1549827    if (filter) {
    1550828        psFree(detRun->filter);
    … …  
    1552830    }
    1553831
    1554     psF32 airmass_min = psMetadataLookupF32(&status, config->args, "-set_airmass_min");
    1555     if (!status) {
    1556         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_airmass_min");
    1557         return false;
    1558     }
    1559832    if (!isnan(airmass_min)) {
    1560833        detRun->airmass_min = airmass_min;
    1561834    }
    1562835
    1563     psF32 airmass_max = psMetadataLookupF32(&status, config->args, "-set_airmass_max");
    1564     if (!status) {
    1565         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_airmass_max");
    1566         return false;
    1567     }
    1568836    if (!isnan(airmass_max)) {
    1569837        detRun->airmass_max = airmass_max;
    1570838    }
    1571839
    1572     psF32 exp_time_min = psMetadataLookupF32(&status, config->args, "-set_exp_time_min");
    1573     if (!status) {
    1574         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_exp_time_min");
    1575         return false;
    1576     }
    1577840    if (!isnan(exp_time_min)) {
    1578841        detRun->exp_time_min = exp_time_min;
    1579842    }
    1580843
    1581     psF32 exp_time_max = psMetadataLookupF32(&status, config->args, "-set_exp_time_max");
    1582     if (!status) {
    1583         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_exp_time_max");
    1584         return false;
    1585     }
    1586844    if (!isnan(exp_time_max)) {
    1587845        detRun->exp_time_max = exp_time_max;
    1588846    }
    1589847
    1590     psF32 ccd_temp_min = psMetadataLookupF32(&status, config->args, "-set_ccd_temp_min");
    1591     if (!status) {
    1592         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_ccd_temp_min");
    1593         return false;
    1594     }
    1595848    if (!isnan(ccd_temp_min)) {
    1596849        detRun->ccd_temp_min = ccd_temp_min;
    1597850    }
    1598851
    1599     psF32 ccd_temp_max = psMetadataLookupF32(&status, config->args, "-set_ccd_temp_max");
    1600     if (!status) {
    1601         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_ccd_temp_max");
    1602         return false;
    1603     }
    1604852    if (!isnan(ccd_temp_max)) {
    1605853        detRun->ccd_temp_max = ccd_temp_max;
    1606854    }
    1607855
    1608     psF64 posang_min = psMetadataLookupF32(&status, config->args, "-set_posang_min");
    1609     if (!status) {
    1610         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_posang_min");
    1611         return false;
    1612     }
    1613856    if (!isnan(posang_min)) {
    1614857        detRun->posang_min = posang_min;
    1615858    }
    1616859
    1617     psF64 posang_max = psMetadataLookupF32(&status, config->args, "-set_posang_max");
    1618     if (!status) {
    1619         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_posang_max");
    1620         return false;
    1621     }
    1622860    if (!isnan(posang_max)) {
    1623861        detRun->posang_max = posang_max;
    1624862    }
    1625863
    1626     psF64 solang_min = psMetadataLookupF32(&status, config->args, "-set_solang_min");
    1627     if (!status) {
    1628         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_solang_min");
    1629         return false;
    1630     }
    1631864    if (!isnan(solang_min)) {
    1632865        detRun->solang_min = solang_min;
    1633866    }
    1634867
    1635     psF64 solang_max = psMetadataLookupF32(&status, config->args, "-set_solang_max");
    1636     if (!status) {
    1637         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_solang_max");
    1638         return false;
    1639     }
    1640868    if (!isnan(solang_max)) {
    1641869        detRun->solang_max = solang_max;
    1642870    }
    1643871
    1644     psString label = psMetadataLookupStr(&status, config->args, "-set_label");
    1645     if (!status) {
    1646         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_label");
    1647         return false;
    1648     }
    1649872    if (label) {
     873        psFree(detRun->label);
    1650874        detRun->label = label;
    1651875    }
    1652876
    1653     psTime *registered = NULL;
    1654     {
    1655         psString registeredStr = psMetadataLookupStr(&status, config->args, "-set_registered");
    1656         if (!status) {
    1657             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_registered");
    1658             return false;
    1659         }
    1660         // pass through NULL as this is an optional field
    1661         if (registeredStr) {
    1662             psFree(detRun->registered);
    1663             registered = psTimeFromISO(registeredStr, PS_TIME_UTC);
    1664             detRun->registered = psMemIncrRefCounter(registered);
    1665             psFree(registered);
    1666         }
    1667     }
    1668 
    1669     psTime *time_begin = NULL;
    1670     {
    1671         psString time_beginStr = psMetadataLookupStr(&status, config->args, "-set_time_begin");
    1672         if (!status) {
    1673             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_time_begin");
    1674             return false;
    1675         }
    1676         // pass through NULL as this is an optional field
    1677         if (time_beginStr) {
    1678             psFree(detRun->time_begin);
    1679             time_begin = psTimeFromISO(time_beginStr, PS_TIME_UTC);
    1680             detRun->time_begin = psMemIncrRefCounter(time_begin);
    1681             psFree(time_begin);
    1682         }
    1683     }
    1684 
    1685     psTime *time_end = NULL;
    1686     {
    1687         psString time_endStr = psMetadataLookupStr(&status, config->args, "-set_time_end");
    1688         if (!status) {
    1689             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_time_end");
    1690             return false;
    1691         }
    1692         // pass through NULL as this is an optional field
    1693         if (time_endStr) {
    1694             psFree(detRun->time_end);
    1695             time_end = psTimeFromISO(time_endStr, PS_TIME_UTC);
    1696             detRun->time_end = psMemIncrRefCounter(time_end);
    1697             psFree(time_end);
    1698         }
    1699     }
    1700 
    1701     psTime *use_begin = NULL;
    1702     {
    1703         psString use_beginStr = psMetadataLookupStr(&status, config->args, "-set_use_begin");
    1704         if (!status) {
    1705             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_use_begin");
    1706             return false;
    1707         }
    1708         // pass through NULL as this is an optional field
    1709         if (use_beginStr) {
    1710             psFree(detRun->use_begin);
    1711             use_begin = psTimeFromISO(use_beginStr, PS_TIME_UTC);
    1712             detRun->use_begin = psMemIncrRefCounter(use_begin);
    1713             psFree(use_begin);
    1714         }
    1715     }
    1716 
    1717     psTime *use_end = NULL;
    1718     {
    1719         psString use_endStr = psMetadataLookupStr(&status, config->args, "-set_use_end");
    1720         if (!status) {
    1721             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_use_end");
    1722             return false;
    1723         }
    1724         // pass through NULL as this is an optional field
    1725         if (use_endStr) {
    1726             psFree(detRun->use_end);
    1727             use_end = psTimeFromISO(use_endStr, PS_TIME_UTC);
    1728             detRun->use_end = psMemIncrRefCounter(use_end);
    1729             psFree(use_end);
    1730         }
    1731     }
    1732 
    1733     psString reduction = psMetadataLookupStr(&status, config->args, "-set_reduction");
    1734     if (!status) {
    1735         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_reduction");
    1736         return false;
    1737     }
     877    if (registered) {
     878        psFree(detRun->registered);
     879        detRun->registered = psMemIncrRefCounter(registered);
     880    }
     881
     882    if (time_begin) {
     883        psFree(detRun->time_begin);
     884        detRun->time_begin = psMemIncrRefCounter(time_begin);
     885    }
     886
     887    if (time_end) {
     888        psFree(detRun->time_end);
     889        detRun->time_end = psMemIncrRefCounter(time_end);
     890    }
     891
     892    if (use_begin) {
     893        psFree(detRun->use_begin);
     894        detRun->use_begin = psMemIncrRefCounter(use_begin);
     895    }
     896
     897    if (use_end) {
     898        psFree(detRun->use_end);
     899        detRun->use_end = psMemIncrRefCounter(use_end);
     900    }
     901
    1738902    if (reduction) {
    1739903        psFree(detRun->reduction);
    … …  
    1745909    psMetadata *time_filter = psMetadataAlloc();
    1746910
    1747     {
    1748         psString timeStr = psMetadataLookupStr(&status, config->args, "-filter_input_begin");
    1749         if (!status) {
    1750             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -filter_input_begin");
    1751             return false;
    1752         }
    1753         // pass through NULL as this is an optional field
    1754         if (timeStr) {
    1755             psTime *time = psTimeFromISO(timeStr, PS_TIME_UTC);
    1756             if (!psMetadataAddTime(time_filter, PS_LIST_TAIL, "dateobs", PS_META_DUPLICATE_OK, ">=", time)) {
    1757                 psError(PS_ERR_UNKNOWN, false, "failed to add item dateobs");
    1758                 psFree(time);
    1759                 psFree(time_filter);
    1760                 return false;
    1761             }
    1762             psFree(time);
    1763         }
    1764     }
    1765 
    1766     {
    1767         psString timeStr = psMetadataLookupStr(&status, config->args, "-filter_input_end");
    1768         if (!status) {
    1769             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -filter_input_end");
    1770             return false;
    1771         }
    1772         // pass through NULL as this is an optional field
    1773         if (timeStr) {
    1774             psTime *time = psTimeFromISO(timeStr, PS_TIME_UTC);
    1775             if (!psMetadataAddTime(time_filter, PS_LIST_TAIL, "dateobs", PS_META_DUPLICATE_OK, "<", time)) {
    1776                 psError(PS_ERR_UNKNOWN, false, "failed to add item dateobs");
    1777                 psFree(time);
    1778                 psFree(time_filter);
    1779                 return false;
    1780             }
    1781             psFree(time);
    1782         }
    1783     }
    1784 
     911    // XXX: possible mem leak: PXOPT_COPY* will free time_filter but NOTHING
     912    // that has previously been allocated
     913    PXOPT_COPY_TIME(config->args, time_filter, "-filter_input_begin", "dateobs", ">=");
     914    PXOPT_COPY_TIME(config->args, time_filter, "-filter_input_end", "dateobs", "<");
    1785915
    1786916    // start a transaction so we don't end up with childlessed det_ids
    … …  
    1840970    }
    1841971
    1842     bool simple = false;
    1843     {
    1844         bool status = false;
    1845         simple = psMetadataLookupBool(&status, config->args, "-simple");
    1846         if (!status) {
    1847             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    1848             return false;
    1849         }
    1850     }
    1851 
    1852972    // print the new det_id
    1853973    psArray *newDetRuns = NULL;
    … …  
    18901010    PS_ASSERT_PTR_NON_NULL(config, false);
    18911011
     1012    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1013
    18921014    // XXX fix the hard coding of the table name
    18931015    psArray *runs = psDBSelectRows(config->dbh, "detRun", config->where, 0);
    … …  
    19101032    }
    19111033
    1912     bool simple = false;
    1913     {
    1914         bool status = false;
    1915         simple = psMetadataLookupBool(&status, config->args, "-simple");
    1916         if (!status) {
    1917             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    1918             return false;
    1919         }
    1920     }
    1921 
    19221034    // negative simple so the default is true
    19231035    if (!ippdbPrintMetadatas(stdout, runs, "detRun", !simple)) {
    … …  
    19361048    PS_ASSERT_PTR_NON_NULL(config, false);
    19371049
    1938     bool status = false;
    1939     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    1940     if (!status) {
    1941         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
    1942         return false;
    1943     }
     1050    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1051    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    19441052
    19451053    psString query = psStringCopy(
    … …  
    19931101    }
    19941102
    1995     bool simple = false;
    1996     {
    1997         bool status = false;
    1998         simple = psMetadataLookupBool(&status, config->args, "-simple");
    1999         if (!status) {
    2000             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    2001             psFree(output);
    2002             return false;
    2003         }
    2004     }
    2005 
    20061103    // negative simple so the default is true
    20071104    if (!ippdbPrintMetadatas(stdout, output, "detRun", !simple)) {
    … …  
    20321129    PS_ASSERT_PTR_NON_NULL(config, false);
    20331130
     1131    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1132
    20341133    // select detInputExp.*
    20351134    // select rawExp.*
    … …  
    20681167    }
    20691168
    2070     bool simple = false;
    2071     {
    2072         bool status = false;
    2073         simple = psMetadataLookupBool(&status, config->args, "-simple");
    2074         if (!status) {
    2075             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    2076             return false;
    2077         }
    2078     }
    2079 
    20801169    // negative simple so the default is true
    20811170    if (!ippdbPrintMetadatas(stdout, output, "detInputExp", !simple)) {
    … …  
    20931182{
    20941183    PS_ASSERT_PTR_NON_NULL(config, false);
     1184
     1185    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    20951186
    20961187    psString query = pxDataGet("dettool_raw.sql");
    … …  
    21241215    }
    21251216
    2126     bool simple = false;
    2127     {
    2128         bool status = false;
    2129         simple = psMetadataLookupBool(&status, config->args, "-simple");
    2130         if (!status) {
    2131             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    2132             return false;
    2133         }
    2134     }
    2135 
    21361217    // negative simple so the default is true
    21371218    if (!ippdbPrintMetadatas(stdout, output, "rawImfile", !simple)) {
    … …  
    21501231    PS_ASSERT_PTR_NON_NULL(config, false);
    21511232
    2152     bool status = false;
    2153     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    2154     if (!status) {
    2155         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
    2156         return false;
    2157     }
     1233    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1234    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    21581235
    21591236    psString query = pxDataGet("dettool_toprocessedimfile.sql");
    … …  
    21921269        psFree(output);
    21931270        return true;
    2194     }
    2195 
    2196     bool simple = false;
    2197     {
    2198         bool status = false;
    2199         simple = psMetadataLookupBool(&status, config->args, "-simple");
    2200         if (!status) {
    2201             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    2202             return false;
    2203         }
    22041271    }
    22051272
    … …  
    22671334    // det_id, exp_id, class_id, uri, recipe, -bg, -bg_stdev
    22681335    // are required
    2269     bool status = false;
    2270     psString det_id = psMetadataLookupStr(&status, config->args, "-det_id");
    2271     if (!status) {
    2272         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -det_id");
    2273         return false;
    2274     }
    2275     if (!det_id) {
    2276         psError(PS_ERR_UNKNOWN, true, "-det_id is required");
    2277         return false;
    2278     }
    2279     psString exp_id = psMetadataLookupStr(&status, config->args, "-exp_id");
    2280     if (!status) {
    2281         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_id");
    2282         return false;
    2283     }
    2284     if (!exp_id) {
    2285         psError(PS_ERR_UNKNOWN, true, "-exp_id is required");
    2286         return false;
    2287     }
    2288     psString class_id = psMetadataLookupStr(&status, config->args, "-class_id");
    2289     if (!status) {
    2290         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -class_id");
    2291         return false;
    2292     }
    2293     if (!class_id) {
    2294         psError(PS_ERR_UNKNOWN, true, "-class_id is required");
    2295         return false;
    2296     }
    2297     psString uri    = psMetadataLookupStr(&status, config->args, "-uri");
    2298     if (!status) {
    2299         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -uri");
    2300         return false;
    2301     }
    2302     if (!uri) {
    2303         psError(PS_ERR_UNKNOWN, true, "-uri is required");
    2304         return false;
    2305     }
    2306     psString recipe = psMetadataLookupStr(&status, config->args, "-recip");
    2307     if (!status) {
    2308         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -recip");
    2309         return false;
    2310     }
    2311     if (!recipe) {
    2312         psError(PS_ERR_UNKNOWN, true, "-recip is required");
    2313         return false;
    2314     }
    2315     psF64 bg = psMetadataLookupF64(&status, config->args, "-bg");
    2316     if (!status) {
    2317         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg");
    2318         return false;
    2319     }
    2320     //if (isnan(bg)) {
    2321     //psError(PS_ERR_UNKNOWN, true, "-bg is required");
    2322     //return false;
    2323     //}
    2324     psF64 bg_stdev = psMetadataLookupF64(&status, config->args, "-bg_stdev");
    2325     if (!status) {
    2326         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg_stdev");
    2327         return false;
    2328     }
    2329     //if (isnan(bg_stdev)) {
    2330     //  psError(PS_ERR_UNKNOWN, true, "-bg_stdev is required");
    2331     //  return false;
    2332     //}
    2333     psF64 bg_mean_stdev = psMetadataLookupF64(&status, config->args, "-bg_mean_stdev");
    2334     if (!status) {
    2335         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg_mean_stdev");
    2336         return false;
    2337     }
    2338 
     1336    PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false);
     1337    PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", true, false);
     1338    PXOPT_LOOKUP_STR(class_id, config->args, "-class_id", true, false);
     1339    PXOPT_LOOKUP_STR(uri, config->args, "-uri", true, false);
     1340    PXOPT_LOOKUP_STR(recipe, config->args, "-recip", true, false);
     1341 
    23391342    // optional
    2340     psF64 fringe_0 = psMetadataLookupF64(&status, config->args, "-fringe_0");
    2341     if (!status) {
    2342         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -fringe_0");
    2343         return false;
    2344     }
    2345     psF64 fringe_1 = psMetadataLookupF64(&status, config->args, "-fringe_1");
    2346     if (!status) {
    2347         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -fringe_1");
    2348         return false;
    2349     }
    2350     psF64 fringe_2 = psMetadataLookupF64(&status, config->args, "-fringe_2");
    2351     if (!status) {
    2352         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -fringe_2");
    2353         return false;
    2354     }
    2355 
    2356     psF64 user_1 = psMetadataLookupF64(&status, config->args, "-user_1");
    2357     if (!status) {
    2358         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_1");
    2359         return false;
    2360     }
    2361     psF64 user_2 = psMetadataLookupF64(&status, config->args, "-user_2");
    2362     if (!status) {
    2363         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_2");
    2364         return false;
    2365     }
    2366     psF64 user_3 = psMetadataLookupF64(&status, config->args, "-user_3");
    2367     if (!status) {
    2368         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_3");
    2369         return false;
    2370     }
    2371     psF64 user_4 = psMetadataLookupF64(&status, config->args, "-user_4");
    2372     if (!status) {
    2373         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_4");
    2374         return false;
    2375     }
    2376     psF64 user_5 = psMetadataLookupF64(&status, config->args, "-user_5");
    2377     if (!status) {
    2378         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_5");
    2379         return false;
    2380     }
    2381 
    2382     psString path_base = psMetadataLookupStr(&status, config->args, "-path_base");
    2383     if (!status) {
    2384         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -path_base");
    2385         return false;
    2386     }
     1343    PXOPT_LOOKUP_F64(bg, config->args, "-bg", false, false);
     1344    PXOPT_LOOKUP_F64(bg_stdev, config->args, "-bg_stdev", false, false);
     1345    PXOPT_LOOKUP_F64(bg_mean_stdev, config->args, "-bg_mean_stdev", false, false);
     1346    PXOPT_LOOKUP_F64(fringe_0, config->args, "-fringe_0", false, false);
     1347    PXOPT_LOOKUP_F64(fringe_1, config->args, "-fringe_1", false, false);
     1348    PXOPT_LOOKUP_F64(fringe_2, config->args, "-fringe_2", false, false);
     1349    PXOPT_LOOKUP_F64(user_1, config->args, "-user_1", false, false);
     1350    PXOPT_LOOKUP_F64(user_2, config->args, "-user_2", false, false);
     1351    PXOPT_LOOKUP_F64(user_3, config->args, "-user_3", false, false);
     1352    PXOPT_LOOKUP_F64(user_4, config->args, "-user_4", false, false);
     1353    PXOPT_LOOKUP_F64(user_5, config->args, "-user_5", false, false);
     1354    PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", false, false);
     1355
     1356    // default values
     1357    PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
    23871358
    23881359    // find the matching rawImfile by exp_id/class_id
    … …  
    23961367        psError(PS_ERR_UNKNOWN, false, "failed to add item class_id");
    23971368        psFree(where);
    2398         return false;
    2399     }
    2400 
    2401     // default values
    2402     psS16 code = psMetadataLookupS16(&status, config->args, "-code");
    2403     if (!status) {
    2404         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -code");
    24051369        return false;
    24061370    }
    … …  
    24531417    PS_ASSERT_PTR_NON_NULL(config, false);
    24541418
    2455     bool status = false;
    2456     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    2457     if (!status) {
    2458         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
    2459         return false;
    2460     }
     1419    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1420    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    24611421
    24621422    psString query = pxDataGet("dettool_toprocessedexp.sql");
    … …  
    25001460    }
    25011461
    2502     bool simple = false;
    2503     {
    2504         bool status = false;
    2505         simple = psMetadataLookupBool(&status, config->args, "-simple");
    2506         if (!status) {
    2507             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    2508             return false;
    2509         }
    2510     }
    2511 
    25121462    // negative simple so the default is true
    25131463    if (!ippdbPrintMetadatas(stdout, output, "detPendingProcessedExp", !simple)) {
    … …  
    25281478    // det_id, exp_id, recip, -bg, -bg_stdev
    25291479    // are required
    2530     bool status = false;
    2531     psString det_id = psMetadataLookupStr(&status, config->args, "-det_id");
    2532     if (!status) {
    2533         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -det_id");
    2534         return false;
    2535     }
    2536     if (!det_id) {
    2537         psError(PS_ERR_UNKNOWN, true, "-det_id is required");
    2538         return false;
    2539     }
    2540     psString exp_id = psMetadataLookupStr(&status, config->args, "-exp_id");
    2541     if (!status) {
    2542         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_id");
    2543         return false;
    2544     }
    2545     if (!exp_id) {
    2546         psError(PS_ERR_UNKNOWN, true, "-exp_id is required");
    2547         return false;
    2548     }
    2549     psString recipe = psMetadataLookupStr(&status, config->args, "-recip");
    2550     if (!status) {
    2551         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -recip");
    2552         return false;
    2553     }
    2554     if (!recipe) {
    2555         psError(PS_ERR_UNKNOWN, true, "-recip is required");
    2556         return false;
    2557     }
    2558     psF64 bg = psMetadataLookupF64(&status, config->args, "-bg");
    2559     if (!status) {
    2560         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg");
    2561         return false;
    2562     }
    2563     //if (isnan(bg)) {
    2564     //  psError(PS_ERR_UNKNOWN, true, "-bg is required");
    2565     //  return false;
    2566     //}
    2567     psF64 bg_stdev = psMetadataLookupF64(&status, config->args, "-bg_stdev");
    2568     if (!status) {
    2569         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg_stdev");
    2570         return false;
    2571     }
    2572     //if (isnan(bg_stdev)) {
    2573     //  psError(PS_ERR_UNKNOWN, true, "-bg_stdev is required");
    2574     //  return false;
    2575     //}
    2576     psF64 bg_mean_stdev = psMetadataLookupF64(&status, config->args, "-bg_mean_stdev");
    2577     if (!status) {
    2578         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg_mean_stdev");
    2579         return false;
    2580     }
     1480    PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false);
     1481    PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", true, false);
     1482    PXOPT_LOOKUP_STR(recipe, config->args, "-recip", true, false);
     1483
    25811484    // optional
    2582     psF64 fringe_0 = psMetadataLookupF64(&status, config->args, "-fringe_0");
    2583     if (!status) {
    2584         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -fringe_0");
    2585         return false;
    2586     }
    2587     psF64 fringe_1 = psMetadataLookupF64(&status, config->args, "-fringe_1");
    2588     if (!status) {
    2589         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -fringe_1");
    2590         return false;
    2591     }
    2592     psF64 fringe_2 = psMetadataLookupF64(&status, config->args, "-fringe_2");
    2593     if (!status) {
    2594         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -fringe_2");
    2595         return false;
    2596     }
    2597 
    2598     psF64 user_1 = psMetadataLookupF64(&status, config->args, "-user_1");
    2599     if (!status) {
    2600         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_1");
    2601         return false;
    2602     }
    2603     psF64 user_2 = psMetadataLookupF64(&status, config->args, "-user_2");
    2604     if (!status) {
    2605         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_2");
    2606         return false;
    2607     }
    2608     psF64 user_3 = psMetadataLookupF64(&status, config->args, "-user_3");
    2609     if (!status) {
    2610         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_3");
    2611         return false;
    2612     }
    2613     psF64 user_4 = psMetadataLookupF64(&status, config->args, "-user_4");
    2614     if (!status) {
    2615         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_4");
    2616         return false;
    2617     }
    2618     psF64 user_5 = psMetadataLookupF64(&status, config->args, "-user_5");
    2619     if (!status) {
    2620         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_5");
    2621         return false;
    2622     }
    2623 
    2624     psString path_base = psMetadataLookupStr(&status, config->args, "-path_base");
    2625     if (!status) {
    2626         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -path_base");
    2627         return false;
    2628     }
    2629 
     1485    PXOPT_LOOKUP_F64(bg, config->args, "-bg", false, false);
     1486    PXOPT_LOOKUP_F64(bg_stdev, config->args, "-bg_stdev", false, false);
     1487    PXOPT_LOOKUP_F64(bg_mean_stdev, config->args, "-bg_mean_stdev", false, false);
     1488    PXOPT_LOOKUP_F64(fringe_0, config->args, "-fringe_0", false, false);
     1489    PXOPT_LOOKUP_F64(fringe_1, config->args, "-fringe_1", false, false);
     1490    PXOPT_LOOKUP_F64(fringe_2, config->args, "-fringe_2", false, false);
     1491    PXOPT_LOOKUP_F64(user_1, config->args, "-user_1", false, false);
     1492    PXOPT_LOOKUP_F64(user_2, config->args, "-user_2", false, false);
     1493    PXOPT_LOOKUP_F64(user_3, config->args, "-user_3", false, false);
     1494    PXOPT_LOOKUP_F64(user_4, config->args, "-user_4", false, false);
     1495    PXOPT_LOOKUP_F64(user_5, config->args, "-user_5", false, false);
     1496    PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", true, false);
     1497 
    26301498    // default values
    2631     psS16 code = psMetadataLookupS16(&status, config->args, "-code");
    2632     if (!status) {
    2633         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -code");
    2634         return false;
    2635     }
     1499    PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
    26361500
    26371501    psString query = psStringCopy(
    … …  
    27271591    PS_ASSERT_PTR_NON_NULL(config, false);
    27281592
    2729     bool status = false;
    2730     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    2731     if (!status) {
    2732         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
    2733         return false;
    2734     }
    2735 
    2736     bool faulted = psMetadataLookupU64(&status, config->args, "-faulted");
    2737     if (!status) {
    2738         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -faulted");
    2739         return false;
    2740     }
     1593    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1594    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1595    PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    27411596
    27421597    psString query = psStringCopy("SELECT * FROM detProcessedExp");
    … …  
    27811636    }
    27821637
    2783     bool simple = false;
    2784     {
    2785         bool status = false;
    2786         simple = psMetadataLookupBool(&status, config->args, "-simple");
    2787         if (!status) {
    2788             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    2789             return false;
    2790         }
    2791     }
    2792 
    27931638    // negative simple so the default is true
    27941639    if (!ippdbPrintMetadatas(stdout, output, "detProcessedExp", !simple)) {
    … …  
    28401685    PS_ASSERT_PTR_NON_NULL(config, false);
    28411686
    2842     bool status = false;
    2843     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    2844     if (!status) {
    2845         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
    2846         return false;
    2847     }
     1687    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1688    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    28481689
    28491690    psString query = pxDataGet("dettool_tostacked.sql");
    … …  
    28871728    }
    28881729
    2889     bool simple = false;
    2890     {
    2891         bool status = false;
    2892         simple = psMetadataLookupBool(&status, config->args, "-simple");
    2893         if (!status) {
    2894             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    2895             return false;
    2896         }
    2897     }
    2898 
    28991730    // negative simple so the default is true
    29001731    if (!ippdbPrintMetadatas(stdout, output, "detPendingStackedImfile", !simple)) {
    … …  
    29141745
    29151746    char *value = NULL;
    2916     bool status = false;
    2917 
    2918     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    2919     if (!status) {
    2920         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
    2921         return false;
    2922     }
    2923 
    2924     bool faulted = psMetadataLookupU64(&status, config->args, "-faulted");
    2925     if (!status) {
    2926         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -faulted");
    2927         return false;
    2928     }
     1747
     1748    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1749    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1750    PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    29291751
    29301752    psString query = psStringCopy(
    … …  
    29471769
    29481770    // add the two required restrictions: detRun.state and detRun.mode
    2949     if ((value = psMetadataLookupStr(&status, config->args, "-select_state"))) {
    2950         psStringAppend(&query, " detRun.state = '%s'", value);
    2951     } else {
    2952         psStringAppend(&query, " detRun.state = 'run'");
    2953     }
    2954     if ((value = psMetadataLookupStr(&status, config->args, "-select_mode"))) {
    2955         psStringAppend(&query, " AND detRun.mode = '%s'", value);
    2956     } else {
    2957         psStringAppend(&query, " AND detRun.mode = 'master'");
     1771    {
     1772        bool status;
     1773        if ((value = psMetadataLookupStr(&status, config->args, "-select_state"))) {
     1774            psStringAppend(&query, " detRun.state = '%s'", value);
     1775        } else {
     1776            psStringAppend(&query, " detRun.state = 'run'");
     1777        }
     1778        if ((value = psMetadataLookupStr(&status, config->args, "-select_mode"))) {
     1779            psStringAppend(&query, " AND detRun.mode = '%s'", value);
     1780        } else {
     1781            psStringAppend(&query, " AND detRun.mode = 'master'");
     1782        }
    29581783    }
    29591784
    … …  
    30101835    }
    30111836
    3012     bool simple = false;
    3013     {
    3014         bool status = false;
    3015         simple = psMetadataLookupBool(&status, config->args, "-simple");
    3016         if (!status) {
    3017             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    3018             return false;
    3019         }
    3020     }
    3021 
    30221837    // negative simple so the default is true
    30231838    if (!ippdbPrintMetadatas(stdout, output, "rawImfile", !simple)) {
    … …  
    30701885
    30711886    // det_id, class_id, uri, & recipe are required
    3072     bool status = false;
    3073     psString det_id = psMetadataLookupStr(&status, config->args, "-det_id");
    3074     if (!status) {
    3075         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -det_id");
    3076         return false;
    3077     }
    3078     if (!det_id) {
    3079         psError(PS_ERR_UNKNOWN, true, "-det_id is required");
    3080         return false;
    3081     }
    3082     psString class_id = psMetadataLookupStr(&status, config->args, "-class_id");
    3083     if (!status) {
    3084         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -class_id");
    3085         return false;
    3086     }
    3087     if (!class_id) {
    3088         psError(PS_ERR_UNKNOWN, true, "-class_id is required");
    3089         return false;
    3090     }
    3091     psString uri    = psMetadataLookupStr(&status, config->args, "-uri");
    3092     if (!status) {
    3093         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -uri");
    3094         return false;
    3095     }
    3096     if (!uri) {
    3097         psError(PS_ERR_UNKNOWN, true, "-uri is required");
    3098         return false;
    3099     }
    3100     psString recipe = psMetadataLookupStr(&status, config->args, "-recip");
    3101     if (!status) {
    3102         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -recip");
    3103         return false;
    3104     }
    3105     if (!recipe) {
    3106         psError(PS_ERR_UNKNOWN, true, "-recip is required");
    3107         return false;
    3108     }
    3109     psF64 bg = psMetadataLookupF64(&status, config->args, "-bg");
    3110     if (!status) {
    3111         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg");
    3112         return false;
    3113     }
    3114     //if (isnan(bg)) {
    3115     //  psError(PS_ERR_UNKNOWN, true, "-bg is required");
    3116     //  return false;
    3117     //}
    3118     psF64 bg_stdev = psMetadataLookupF64(&status, config->args, "-bg_stdev");
    3119     if (!status) {
    3120         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg_stdev");
    3121         return false;
    3122     }
    3123     //if (isnan(bg_stdev)) {
    3124     //  psError(PS_ERR_UNKNOWN, true, "-bg_stdev is required");
    3125     //  return false;
    3126     //}
    3127     psF64 bg_mean_stdev = psMetadataLookupF64(&status, config->args, "-bg_mean_stdev");
    3128     if (!status) {
    3129         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg_mean_stdev");
    3130         return false;
    3131     }
    3132 
    3133     // optional values
    3134     psF64 user_1 = psMetadataLookupF64(&status, config->args, "-user_1");
    3135     if (!status) {
    3136         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_1");
    3137         return false;
    3138     }
    3139     psF64 user_2 = psMetadataLookupF64(&status, config->args, "-user_2");
    3140     if (!status) {
    3141         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_2");
    3142         return false;
    3143     }
    3144     psF64 user_3 = psMetadataLookupF64(&status, config->args, "-user_3");
    3145     if (!status) {
    3146         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_3");
    3147         return false;
    3148     }
    3149     psF64 user_4 = psMetadataLookupF64(&status, config->args, "-user_4");
    3150     if (!status) {
    3151         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_4");
    3152         return false;
    3153     }
    3154     psF64 user_5 = psMetadataLookupF64(&status, config->args, "-user_5");
    3155     if (!status) {
    3156         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_5");
    3157         return false;
    3158     }
     1887    PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false);
     1888    PXOPT_LOOKUP_STR(class_id, config->args, "-class_id", true, false);
     1889    PXOPT_LOOKUP_STR(uri, config->args, "-uri", true, false);
     1890    PXOPT_LOOKUP_STR(recipe, config->args, "-recip", true, false);
     1891 
     1892    // optional
     1893    PXOPT_LOOKUP_F64(bg, config->args, "-bg", false, false);
     1894    PXOPT_LOOKUP_F64(bg_stdev, config->args, "-bg_stdev", false, false);
     1895    PXOPT_LOOKUP_F64(bg_mean_stdev, config->args, "-bg_mean_stdev", false, false);
     1896    PXOPT_LOOKUP_F64(user_1, config->args, "-user_1", false, false);
     1897    PXOPT_LOOKUP_F64(user_2, config->args, "-user_2", false, false);
     1898    PXOPT_LOOKUP_F64(user_3, config->args, "-user_3", false, false);
     1899    PXOPT_LOOKUP_F64(user_4, config->args, "-user_4", false, false);
     1900    PXOPT_LOOKUP_F64(user_5, config->args, "-user_5", false, false);
    31591901
    31601902    // default values
    3161     psS32 iteration = psMetadataLookupS32(&status, config->args, "-iteration");
    3162     if (!status) {
    3163         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -iteration");
    3164         return false;
    3165     }
    3166 
    3167     psS16 code = psMetadataLookupS16(&status, config->args, "-code");
    3168     if (!status) {
    3169         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -code");
    3170         return false;
    3171     }
     1903    PXOPT_LOOKUP_S32(iteration, config->args, "-iteration", false, false);
     1904    PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
    31721905
    31731906    // correlate the class_id against the input exposure(s)
    … …  
    32461979    PS_ASSERT_PTR_NON_NULL(config, false);
    32471980
    3248     bool status = false;
    3249     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    3250     if (!status) {
    3251         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
    3252         return false;
    3253     }
    3254 
    3255     bool faulted = psMetadataLookupU64(&status, config->args, "-faulted");
    3256     if (!status) {
    3257         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -faulted");
    3258         return false;
    3259     }
     1981    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1982    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1983    PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    32601984
    32611985    // select detStackedImfile.*
    … …  
    33132037    }
    33142038
    3315     bool simple = false;
    3316     {
    3317         bool status = false;
    3318         simple = psMetadataLookupBool(&status, config->args, "-simple");
    3319         if (!status) {
    3320             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    3321             psFree(output);
    3322             return false;
    3323         }
    3324     }
    3325 
    33262039    // negative simple so the default is true
    33272040    if (!ippdbPrintMetadatas(stdout, output, "rawImfile", !simple)) {
    … …  
    33722085    PS_ASSERT_PTR_NON_NULL(config, false);
    33732086
    3374     bool status = false;
    3375     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    3376     if (!status) {
    3377         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
    3378         return false;
    3379     }
     2087    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     2088    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    33802089
    33812090    psString query = pxDataGet("dettool_tonormalizedstat.sql");
    … …  
    34192128    }
    34202129
    3421     bool simple = false;
    3422     {
    3423         bool status = false;
    3424         simple = psMetadataLookupBool(&status, config->args, "-simple");
    3425         if (!status) {
    3426             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    3427             return false;
    3428         }
    3429     }
    3430 
    34312130    // negative simple so the default is true
    34322131    if (!ippdbPrintMetadatas(stdout, output, "detPendingNormStatImfile", !simple)) {
    … …  
    34452144    PS_ASSERT_PTR_NON_NULL(config, NULL);
    34462145
    3447     // select * from detStackedImfile
    3448     // by det_id, iteration, class_id
    3449     // where det_id, iteration, class_id is not in detNormalizedStatImfile
    3450     psString query = psStringCopy(
    3451         "SELECT DISTINCT"
    3452         "   detStackedImfile.*"
    3453         " FROM detStackedImfile"
    3454         " LEFT JOIN detNormalizedStatImfile"
    3455         "   USING(det_id, iteration, class_id)"
    3456         " WHERE"
    3457         "  detNormalizedStatImfile.det_id IS NULL"
    3458         "  AND detNormalizedStatImfile.iteration IS NULL"
    3459         "  AND detNormalizedStatImfile.class_id IS NULL"
    3460         );
    3461 
    3462     if (config->where) {
    3463         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "detStackedImfile");
    3464         psStringAppend(&query, " AND %s", whereClause);
    3465         psFree(whereClause);
    3466     }
    3467 
    3468     if (!p_psDBRunQuery(config->dbh, query)) {
    3469         psError(PS_ERR_UNKNOWN, false, "database error");
    3470         psFree(query);
    3471         return false;
    3472     }
    3473     psFree(query);
    3474 
    3475     psArray *output = p_psDBFetchResult(config->dbh);
    3476     if (!output) {
    3477         psError(PS_ERR_UNKNOWN, false, "database error");
    3478         return false;
    3479     }
    3480     if (!psArrayLength(output)) {
    3481         psTrace("dettool", PS_LOG_INFO, "no rows found");
    3482         psFree(output);
    3483         return true;
    3484     }
    3485 
    3486     // start a transaction so it's all rows or nothing
    3487     if (!psDBTransaction(config->dbh)) {
    3488         psError(PS_ERR_UNKNOWN, false, "database error");
    3489         psFree(output);
    3490         return false;
    3491     }
    3492 
    3493     for (long i = 0; i < psArrayLength(output); i++) {
    3494         psMetadata *row = output->data[i];
    3495         // convert metadata into a detStackedImfile object
    3496         detStackedImfileRow *stackedImfile = detStackedImfileObjectFromMetadata(row);
    3497         // convert detStackedImfile object into a detNormalizedStat object
    3498         detNormalizedStatImfileRow *stat = detStackedToDetNormalizedStatImfile(config, stackedImfile);
    3499         psFree(stackedImfile);
    3500         if (!stat) {
    3501             if (!psDBRollback(config->dbh)) {
    3502                 psError(PS_ERR_UNKNOWN, false, "database error");
    3503             }
    3504             psError(PS_ERR_UNKNOWN, false, "failed to convert detStackedImfile to detNormalizedStatImfile");
    3505             psFree(output);
    3506             return false;
    3507         }
    3508         // insert detNormlized Stat object into the database
    3509         if (!detNormalizedStatImfileInsertObject(config->dbh, stat)) {
    3510             if (!psDBRollback(config->dbh)) {
    3511                 psError(PS_ERR_UNKNOWN, false, "database error");
    3512             }
    3513             psError(PS_ERR_UNKNOWN, false, "database error");
    3514             psFree(stat);
    3515             psFree(output);
    3516         }
    3517         psFree(stat);
    3518     }
    3519 
    3520     psFree(output);
    3521 
    3522     if (!psDBCommit(config->dbh)) {
    3523         psError(PS_ERR_UNKNOWN, false, "database error");
    3524         return false;
    3525     }
    3526 
    3527     return true;
    3528 }
    3529 
    3530 static detNormalizedStatImfileRow *detStackedToDetNormalizedStatImfile(pxConfig *config, detStackedImfileRow *stackedImfile)
    3531 {
    3532     PS_ASSERT_PTR_NON_NULL(config, NULL);
    3533     PS_ASSERT_PTR_NON_NULL(stackedImfile, NULL);
    3534 
    3535     bool status = false;
    3536     psF32 norm = psMetadataLookupF32(&status, config->args, "-norm");
    3537     if (!status) {
    3538         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -norm");
    3539         return false;
    3540     }
    3541     //if (isnan(norm)) {
    3542     //  psError(PS_ERR_UNKNOWN, true, "-norm is required");
    3543     //  return false;
    3544     //}
    3545 
    3546     // default values
    3547     psS16 code = psMetadataLookupS16(&status, config->args, "-code");
    3548     if (!status) {
    3549         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -code");
    3550         return false;
    3551     }
    3552 
    3553     return detNormalizedStatImfileRowAlloc(
    3554         stackedImfile->det_id,
    3555         stackedImfile->iteration,
    3556         stackedImfile->class_id,
     2146    // required
     2147    PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false);
     2148    PXOPT_LOOKUP_STR(class_id, config->args, "-class_id", true, false);
     2149
     2150    // optional
     2151    PXOPT_LOOKUP_F32(norm, config->args, "-norm", false, false);
     2152
     2153    // default
     2154    PXOPT_LOOKUP_S32(iteration, config->args, "-iteration", false, false);
     2155    PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
     2156
     2157    if (!detNormalizedStatImfileInsert(config->dbh,
     2158        (psS64)atoll(det_id),
     2159        iteration,
     2160        class_id,
    35572161        norm,
    35582162        code
    3559     );
     2163    )) {
     2164        psError(PS_ERR_UNKNOWN, false, "database error");
     2165        return false;
     2166    }
     2167
     2168    return true;
    35602169}
    35612170
    … …  
    35652174    PS_ASSERT_PTR_NON_NULL(config, false);
    35662175
    3567     bool status = false;
    3568     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    3569     if (!status) {
    3570         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
    3571         return false;
    3572     }
    3573 
    3574     bool faulted = psMetadataLookupU64(&status, config->args, "-faulted");
    3575     if (!status) {
    3576         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -faulted");
    3577         return false;
    3578     }
     2176    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     2177    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     2178    PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    35792179
    35802180    psString query = pxDataGet("dettool_normalizedstat.sql");
    … …  
    36232223    }
    36242224
    3625     bool simple = false;
    3626     {
    3627         bool status = false;
    3628         simple = psMetadataLookupBool(&status, config->args, "-simple");
    3629         if (!status) {
    3630             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    3631             psFree(output);
    3632             return false;
    3633         }
    3634     }
    3635 
    36362225    // negative simple so the default is true
    36372226    if (!ippdbPrintMetadatas(stdout, output, "detNormalizedStatImfile", !simple)) {
    … …  
    36812270    PS_ASSERT_PTR_NON_NULL(config, false);
    36822271
    3683     bool status = false;
    3684     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    3685     if (!status) {
    3686         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
    3687         return false;
    3688     }
     2272    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     2273    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    36892274
    36902275    // select detNormalizedStatImfile.*
    … …  
    37552340    }
    37562341
    3757     bool simple = false;
    3758     {
    3759         bool status = false;
    3760         simple = psMetadataLookupBool(&status, config->args, "-simple");
    3761         if (!status) {
    3762             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    3763             psFree(output);
    3764             return false;
    3765         }
    3766     }
    3767 
    37682342    // negative simple so the default is true
    37692343    if (!ippdbPrintMetadatas(stdout, output, "detPendingNormImfile", !simple)) {
    … …  
    38732447    PS_ASSERT_PTR_NON_NULL(config, false);
    38742448
    3875     // make sure that there is a respondoing entry in detNormalizedStatImfile
    3876     // select * from detNormalizedStatImfile
    3877     // by det_id, iteration, class_id
    3878     // where det_id, iteration, class_id is not in detNormalizedImfile
    3879     psString query = psStringCopy(
    3880         "SELECT"
    3881         "   detNormalizedStatImfile.*"
    3882         " FROM detNormalizedStatImfile"
    3883         " LEFT JOIN detNormalizedImfile"
    3884         "   USING(det_id, iteration, class_id)"
    3885         " WHERE"
    3886         "  detNormalizedImfile.det_id IS NULL"
    3887         "  AND detNormalizedImfile.iteration IS NULL"
    3888         "  AND detNormalizedImfile.class_id IS NULL"
    3889         );
    3890 
    3891     {
    3892         // build a query to search by det_id, iteration, class_id
    3893         psMetadata *where = psMetadataAlloc();
    3894         bool status = false;
    3895         psString det_id = psMetadataLookupStr(&status, config->args, "-det_id");
    3896         if (!status) {
    3897             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -det_id");
    3898             psFree(where);
    3899             psFree(query);
    3900             return false;
    3901         }
    3902         if (det_id) {
    3903             if (!psMetadataAddStr(where, PS_LIST_TAIL, "det_id", 0, "==", det_id)) {
    3904                 psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    3905                 psFree(where);
    3906                 psFree(query);
    3907                 return false;
    3908             }
    3909         }
    3910         psS32 iteration = psMetadataLookupS32(&status, config->args, "-iteration");
    3911         if (!status) {
    3912             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -iteration");
    3913             psFree(where);
    3914             psFree(query);
    3915             return false;
    3916         }
    3917         // always set iteration
    3918         if (!psMetadataAddS32(where, PS_LIST_TAIL, "iteration", 0, "==", iteration)) {
    3919             psError(PS_ERR_UNKNOWN, false, "failed to add item iteration");
    3920             psFree(where);
    3921             psFree(query);
    3922             return false;
    3923         }
    3924         psString class_id = psMetadataLookupStr(&status, config->args, "-class_id");
    3925         if (!status) {
    3926             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -class_id");
    3927             psFree(where);
    3928             psFree(query);
    3929             return false;
    3930         }
    3931         if (class_id) {
    3932             if (!psMetadataAddStr(where, PS_LIST_TAIL, "class_id", 0, "==", class_id)) {
    3933                 psError(PS_ERR_UNKNOWN, false, "failed to add item class_id");
    3934                 psFree(where);
    3935                 psFree(query);
    3936                 return false;
    3937             }
    3938         }
    3939 
    3940         // there's not
    3941         psString whereClause = psDBGenerateWhereConditionSQL(where, "detNormalizedStatImfile");
    3942         psFree(where);
    3943         if (whereClause) {
    3944             psStringAppend(&query, " AND %s", whereClause);
    3945             psFree(whereClause);
    3946         }
    3947     }
    3948 
    3949     if (!p_psDBRunQuery(config->dbh, query)) {
    3950         psError(PS_ERR_UNKNOWN, false, "database error");
    3951         psFree(query);
    3952         return false;
    3953     }
    3954     psFree(query);
    3955 
    3956     psArray *output = p_psDBFetchResult(config->dbh);
    3957     if (!output) {
    3958         psError(PS_ERR_UNKNOWN, false, "database error");
    3959         return false;
    3960     }
    3961     if (!psArrayLength(output)) {
    3962         psTrace("dettool", PS_LOG_INFO, "no rows found");
    3963         psFree(output);
    3964         return true;
    3965     }
    3966 
    3967     // start a transaction so it's all rows or nothing
    3968     if (!psDBTransaction(config->dbh)) {
    3969         psError(PS_ERR_UNKNOWN, false, "database error");
    3970         psFree(output);
    3971         return false;
    3972     }
    3973 
    3974     for (long i = 0; i < psArrayLength(output); i++) {
    3975         psMetadata *row = output->data[i];
    3976         // convert metadata into a detNormalizedStatImfile object
    3977         detNormalizedStatImfileRow *statImfile = detNormalizedStatImfileObjectFromMetadata(row);
    3978         // convert detNormalizedStatImfile object into a detNormalizedImfile
    3979         detNormalizedImfileRow *normalizedImfile  = detNormalizedStatToDetNormalizedmfile(config, statImfile);
    3980         psFree(statImfile);
    3981         if (!normalizedImfile) {
    3982             if (!psDBRollback(config->dbh)) {
    3983                 psError(PS_ERR_UNKNOWN, false, "database error");
    3984             }
    3985             psError(PS_ERR_UNKNOWN, false, "failed to convert detStackedImfile to detNormalizedStatImfile");
    3986             psFree(output);
    3987             return false;
    3988         }
    3989         // insert detNormlized Stat object into the database
    3990         if (!detNormalizedImfileInsertObject(config->dbh, normalizedImfile)) {
    3991             if (!psDBRollback(config->dbh)) {
    3992                 psError(PS_ERR_UNKNOWN, false, "database error");
    3993             }
    3994             psError(PS_ERR_UNKNOWN, false, "database error");
    3995             psFree(normalizedImfile);
    3996             psFree(output);
    3997         }
    3998         psFree(normalizedImfile);
    3999     }
    4000 
    4001     psFree(output);
    4002 
    4003     if (!psDBCommit(config->dbh)) {
     2449    // required
     2450    PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false);
     2451    PXOPT_LOOKUP_STR(class_id, config->args, "-class_id", true, false);
     2452    PXOPT_LOOKUP_STR(uri, config->args, "-uri", true, false);
     2453
     2454    // optional
     2455    PXOPT_LOOKUP_F64(bg, config->args, "-bg", false, false);
     2456    PXOPT_LOOKUP_F64(bg_stdev, config->args, "-bg_stdev", false, false);
     2457    PXOPT_LOOKUP_F64(bg_mean_stdev, config->args, "-bg_mean_stdev", false, false);
     2458    PXOPT_LOOKUP_F64(user_1, config->args, "-user_1", false, false);
     2459    PXOPT_LOOKUP_F64(user_2, config->args, "-user_2", false, false);
     2460    PXOPT_LOOKUP_F64(user_3, config->args, "-user_3", false, false);
     2461    PXOPT_LOOKUP_F64(user_4, config->args, "-user_4", false, false);
     2462    PXOPT_LOOKUP_F64(user_5, config->args, "-user_5", false, false);
     2463    PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", false, false);
     2464
     2465    // default values
     2466    PXOPT_LOOKUP_S32(iteration, config->args, "-iteration", false, false);
     2467    PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
     2468
     2469    if (!detNormalizedImfileInsert(config->dbh,
     2470        (psS64)atoll(det_id),
     2471        iteration,
     2472        class_id,
     2473        uri,
     2474        bg,
     2475        bg_stdev,
     2476        bg_mean_stdev,
     2477        user_1,
     2478        user_2,
     2479        user_3,
     2480        user_4,
     2481        user_5,
     2482        path_base,
     2483        code
     2484    )) {
    40042485        psError(PS_ERR_UNKNOWN, false, "database error");
    40052486        return false;
    … …  
    40142495    PS_ASSERT_PTR_NON_NULL(config, false);
    40152496
    4016     bool status = false;
    4017     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    4018     if (!status) {
    4019         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
    4020         return false;
    4021     }
    4022 
    4023     bool faulted = psMetadataLookupU64(&status, config->args, "-faulted");
    4024     if (!status) {
    4025         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -faulted");
    4026         return false;
    4027     }
     2497    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     2498    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     2499    PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    40282500
    40292501    psString query = psStringCopy(
    … …  
    40832555    }
    40842556
    4085     bool simple = false;
    4086     {
    4087         bool status = false;
    4088         simple = psMetadataLookupBool(&status, config->args, "-simple");
    4089         if (!status) {
    4090             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    4091             return false;
    4092         }
    4093     }
    4094 
    40952557    // negative simple so the default is true
    40962558    if (!ippdbPrintMetadatas(stdout, output, "detNormalizedImfile", !simple)) {
    … …  
    41422604    PS_ASSERT_PTR_NON_NULL(config, false);
    41432605
    4144     bool status = false;
    4145     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    4146     if (!status) {
    4147         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
    4148         return false;
    4149     }
     2606    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     2607    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    41502608
    41512609    psString query = pxDataGet("dettool_tonormalizedexp.sql");
    … …  
    41892647    }
    41902648
    4191     bool simple = false;
    4192     {
    4193         bool status = false;
    4194         simple = psMetadataLookupBool(&status, config->args, "-simple");
    4195         if (!status) {
    4196             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    4197             return false;
    4198         }
    4199     }
    4200 
    42012649    // negative simple so the default is true
    42022650    if (!ippdbPrintMetadatas(stdout, output, "detPendingNormExp", !simple)) {
    … …  
    42152663    PS_ASSERT_PTR_NON_NULL(config, false);
    42162664
    4217     // det_id, recip, -bg, -bg_stdev
    4218     // are required
    4219     bool status = false;
    4220     psString det_id = psMetadataLookupStr(&status, config->args, "-det_id");
    4221     if (!status) {
    4222         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -det_id");
    4223         return false;
    4224     }
    4225     if (!det_id) {
    4226         psError(PS_ERR_UNKNOWN, true, "-det_id is required");
    4227         return false;
    4228     }
    4229     psString recipe = psMetadataLookupStr(&status, config->args, "-recip");
    4230     if (!status) {
    4231         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -recip");
    4232         return false;
    4233     }
    4234     if (!recipe) {
    4235         psError(PS_ERR_UNKNOWN, true, "-recip is required");
    4236         return false;
    4237     }
    4238     psF64 bg = psMetadataLookupF64(&status, config->args, "-bg");
    4239     if (!status) {
    4240         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg");
    4241         return false;
    4242     }
    4243     //if (isnan(bg)) {
    4244     //  psError(PS_ERR_UNKNOWN, true, "-bg is required");
    4245     //  return false;
    4246     //}
    4247     psF64 bg_stdev = psMetadataLookupF64(&status, config->args, "-bg_stdev");
    4248     if (!status) {
    4249         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg_stdev");
    4250         return false;
    4251     }
    4252     //if (isnan(bg_stdev)) {
    4253     //  psError(PS_ERR_UNKNOWN, true, "-bg_stdev is required");
    4254     //  return false;
    4255     //}
    4256     psF64 bg_mean_stdev = psMetadataLookupF64(&status, config->args, "-bg_mean_stdev");
    4257     if (!status) {
    4258         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg_mean_stdev");
    4259         return false;
    4260     }
     2665    // required
     2666    PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false);
     2667    PXOPT_LOOKUP_STR(recipe, config->args, "-recip", true, false);
    42612668
    42622669    // optional
    4263     psF64 user_1 = psMetadataLookupF64(&status, config->args, "-user_1");
    4264     if (!status) {
    4265         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_1");
    4266         return false;
    4267     }
    4268     psF64 user_2 = psMetadataLookupF64(&status, config->args, "-user_2");
    4269     if (!status) {
    4270         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_2");
    4271         return false;
    4272     }
    4273     psF64 user_3 = psMetadataLookupF64(&status, config->args, "-user_3");
    4274     if (!status) {
    4275         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_3");
    4276         return false;
    4277     }
    4278     psF64 user_4 = psMetadataLookupF64(&status, config->args, "-user_4");
    4279     if (!status) {
    4280         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_4");
    4281         return false;
    4282     }
    4283     psF64 user_5 = psMetadataLookupF64(&status, config->args, "-user_5");
    4284     if (!status) {
    4285         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_5");
    4286         return false;
    4287     }
    4288 
    4289     // iteration has a default value
    4290     psS32 iteration = psMetadataLookupS32(&status, config->args, "-iteration");
    4291     if (!status) {
    4292         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -iteration");        return false;
    4293     }
    4294 
    4295     psS16 code = psMetadataLookupS16(&status, config->args, "-code");
    4296     if (!status) {
    4297         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -code");
    4298         return false;
    4299     }
    4300 
    4301     // optional
    4302     psString path_base = psMetadataLookupStr(&status, config->args, "-path_base");
    4303     if (!status) {
    4304         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -path_base");
    4305         return false;
    4306     }
     2670    PXOPT_LOOKUP_F64(bg, config->args, "-bg", false, false);
     2671    PXOPT_LOOKUP_F64(bg_stdev, config->args, "-bg_stdev", false, false);
     2672    PXOPT_LOOKUP_F64(bg_mean_stdev, config->args, "-bg_mean_stdev", false, false);
     2673    PXOPT_LOOKUP_F64(user_1, config->args, "-user_1", false, false);
     2674    PXOPT_LOOKUP_F64(user_2, config->args, "-user_2", false, false);
     2675    PXOPT_LOOKUP_F64(user_3, config->args, "-user_3", false, false);
     2676    PXOPT_LOOKUP_F64(user_4, config->args, "-user_4", false, false);
     2677    PXOPT_LOOKUP_F64(user_5, config->args, "-user_5", false, false);
     2678    PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", false, false);
     2679
     2680    // default values
     2681    PXOPT_LOOKUP_S32(iteration, config->args, "-iteration", false, false);
     2682    PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
    43072683
    43082684    psString query = pxDataGet("dettool_tonormalizedexp.sql");
    … …  
    43362712    psFree(output);
    43372713
    4338     // create a new detProcessedImfile object
    4339     detNormalizedExpRow *detRow = detNormalizedExpRowAlloc(
    4340         (psS32)atoll(det_id),
     2714    // insert the new row into the detProcessedImfile table
     2715    if (!detNormalizedExpInsert(config->dbh,
     2716        (psS64)atoll(det_id),
    43412717        iteration,
    43422718        recipe,
    … …  
    43512727        path_base,
    43522728        code
    4353     );
    4354 
    4355     // insert the new row into the detProcessedImfile table
    4356     if (!detNormalizedExpInsertObject(config->dbh, detRow)) {
    4357         psError(PS_ERR_UNKNOWN, false, "database error");
    4358         psFree(detRow);
    4359         return false;
    4360     }
    4361 
    4362     psFree(detRow);
     2729    )) {
     2730        psError(PS_ERR_UNKNOWN, false, "database error");
     2731        return false;
     2732    }
    43632733
    43642734    return true;
    … …  
    43702740    PS_ASSERT_PTR_NON_NULL(config, false);
    43712741
    4372     bool status = false;
    4373     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    4374     if (!status) {
    4375         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
    4376         return false;
    4377     }
    4378 
    4379     bool faulted = psMetadataLookupU64(&status, config->args, "-faulted");
    4380     if (!status) {
    4381         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -faulted");
    4382         return false;
    4383     }
     2742    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     2743    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     2744    PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    43842745
    43852746    psString query = psStringCopy(
    … …  
    44332794    }
    44342795
    4435     bool simple = false;
    4436     {
    4437         bool status = false;
    4438         simple = psMetadataLookupBool(&status, config->args, "-simple");
    4439         if (!status) {
    4440             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    4441             return false;
    4442         }
    4443     }
    4444 
    44452796    // negative simple so the default is true
    44462797    if (!ippdbPrintMetadatas(stdout, output, "detNormalizedExp", !simple)) {
    … …  
    44552806}
    44562807
    4457 
    4458 static  detNormalizedImfileRow *detNormalizedStatToDetNormalizedmfile(pxConfig *config, detNormalizedStatImfileRow *statImfile)
    4459 {
    4460     PS_ASSERT_PTR_NON_NULL(config, NULL);
    4461     PS_ASSERT_PTR_NON_NULL(statImfile, NULL);
    4462 
    4463     bool status = false;
    4464     psString uri = psMetadataLookupStr(&status, config->args, "-uri");
    4465     if (!status) {
    4466         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -uri");
    4467         return false;
    4468     }
    4469     if (!uri) {
    4470         psError(PS_ERR_UNKNOWN, true, "-uri is required");
    4471         return false;
    4472     }
    4473     psF64 bg = psMetadataLookupF64(&status, config->args, "-bg");
    4474     if (!status) {
    4475         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg");
    4476         return false;
    4477     }
    4478     //if (isnan(bg)) {
    4479     //  psError(PS_ERR_UNKNOWN, true, "-bg is required");
    4480     //  return false;
    4481     //}
    4482     psF64 bg_stdev = psMetadataLookupF64(&status, config->args, "-bg_stdev");
    4483     if (!status) {
    4484         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg_stdev");
    4485         return false;
    4486     }
    4487     //if (isnan(bg_stdev)) {
    4488     //  psError(PS_ERR_UNKNOWN, true, "-bg_stdev is required");
    4489     //  return false;
    4490     //}
    4491     psF64 bg_mean_stdev = psMetadataLookupF64(&status, config->args, "-bg_mean_stdev");
    4492     if (!status) {
    4493         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg_mean_stdev");
    4494         return false;
    4495     }
    4496     // optional
    4497     psF64 user_1 = psMetadataLookupF64(&status, config->args, "-user_1");
    4498     if (!status) {
    4499         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_1");
    4500         return false;
    4501     }
    4502     psF64 user_2 = psMetadataLookupF64(&status, config->args, "-user_2");
    4503     if (!status) {
    4504         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_2");
    4505         return false;
    4506     }
    4507     psF64 user_3 = psMetadataLookupF64(&status, config->args, "-user_3");
    4508     if (!status) {
    4509         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_3");
    4510         return false;
    4511     }
    4512     psF64 user_4 = psMetadataLookupF64(&status, config->args, "-user_4");
    4513     if (!status) {
    4514         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_4");
    4515         return false;
    4516     }
    4517     psF64 user_5 = psMetadataLookupF64(&status, config->args, "-user_5");
    4518     if (!status) {
    4519         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_5");
    4520         return false;
    4521     }
    4522 
    4523     // optional
    4524     psString path_base = psMetadataLookupStr(&status, config->args, "-path_base");
    4525     if (!status) {
    4526         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -path_base");
    4527         return false;
    4528     }
    4529 
    4530     // default values
    4531     psS16 code = psMetadataLookupS16(&status, config->args, "-code");
    4532     if (!status) {
    4533         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -code");
    4534         return false;
    4535     }
    4536 
    4537     return detNormalizedImfileRowAlloc(
    4538         statImfile->det_id,
    4539         statImfile->iteration,
    4540         statImfile->class_id,
    4541         uri,
    4542         bg,
    4543         bg_stdev,
    4544         bg_mean_stdev,
    4545         user_1,
    4546         user_2,
    4547         user_3,
    4548         user_4,
    4549         user_5,
    4550         path_base,
    4551         code
    4552     );
    4553 }
    45542808
    45552809
    … …  
    45902844    PS_ASSERT_PTR_NON_NULL(config, false);
    45912845
    4592     bool status = false;
    4593     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    4594     if (!status) {
    4595         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
    4596         return false;
    4597     }
     2846    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     2847    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    45982848
    45992849    psString query = pxDataGet("dettool_toresidimfile.sql");
    … …  
    46372887    }
    46382888
    4639     bool simple = false;
    4640     {
    4641         bool status = false;
    4642         simple = psMetadataLookupBool(&status, config->args, "-simple");
    4643         if (!status) {
    4644             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    4645             psFree(output);
    4646             return false;
    4647         }
    4648     }
    4649 
    46502889    // negative simple so the default is true
    46512890    if (!ippdbPrintMetadatas(stdout, output, "detPendingResidImfile", !simple)) {
    … …  
    46652904    PS_ASSERT_PTR_NON_NULL(config, false);
    46662905
    4667     bool status = false;
    4668     psString det_id = psMetadataLookupStr(&status, config->args, "-det_id");
    4669     if (!status) {
    4670         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -det_id");
    4671         return false;
    4672     }
    4673     if (!det_id) {
    4674         psError(PS_ERR_UNKNOWN, true, "-det_id is required");
    4675         return false;
    4676     }
    4677 
    4678     // defaults to 0
    4679     psS32 iteration = psMetadataLookupS32(&status, config->args, "-iteration");
    4680     if (!status) {
    4681         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -iteration");
    4682         return false;
    4683     }
    4684 
    4685     psString class_id = psMetadataLookupStr(&status, config->args, "-class_id");
    4686     if (!status) {
    4687         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -class_id");
    4688         return false;
    4689     }
    4690     if (!class_id) {
    4691         psError(PS_ERR_UNKNOWN, false, "-class_id is required");
    4692         return false;
    4693     }
    4694 
    4695     psString exp_id = psMetadataLookupStr(&status, config->args, "-exp_id");
    4696     if (!status) {
    4697         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_id");
    4698         return false;
    4699     }
    4700     if (!exp_id) {
    4701         psError(PS_ERR_UNKNOWN, true, "-exp_id is required");
    4702         return false;
    4703     }
    4704     psString uri = psMetadataLookupStr(&status, config->args, "-uri");
    4705     if (!status) {
    4706         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -uri");
    4707         return false;
    4708     }
    4709     if (!uri) {
    4710         psError(PS_ERR_UNKNOWN, true, "-uri is required");
    4711         return false;
    4712     }
    4713     psString recipe = psMetadataLookupStr(&status, config->args, "-recip");
    4714     if (!status) {
    4715         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -recip");
    4716         return false;
    4717     }
    4718     if (!recipe) {
    4719         psError(PS_ERR_UNKNOWN, true, "-recip is required");
    4720         return false;
    4721     }
    4722     psF64 bg = psMetadataLookupF64(&status, config->args, "-bg");
    4723     if (!status) {
    4724         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg");
    4725         return false;
    4726     }
    4727     //if (isnan(bg)) {
    4728     //  psError(PS_ERR_UNKNOWN, true, "-bg is required");
    4729     //  return false;
    4730     //}
    4731     psF64 bg_stdev = psMetadataLookupF64(&status, config->args, "-bg_stdev");
    4732     if (!status) {
    4733         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg_stdev");
    4734         return false;
    4735     }
    4736     //if (isnan(bg_stdev)) {
    4737     //  psError(PS_ERR_UNKNOWN, true, "-bg_stdev is required");
    4738     //  return false;
    4739     //}
    4740     psF64 bg_mean_stdev = psMetadataLookupF64(&status, config->args, "-bg_mean_stdev");
    4741     if (!status) {
    4742         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg_mean_stdev");
    4743         return false;
    4744     }
    4745     psF64 bg_skewness = psMetadataLookupF64(&status, config->args, "-bg_skewness");
    4746     if (!status) {
    4747         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg_skewness");
    4748         return false;
    4749     }
    4750     psF64 bg_kurtosis = psMetadataLookupF64(&status, config->args, "-bg_kurtosis");
    4751     if (!status) {
    4752         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg_kurtosis");
    4753         return false;
    4754     }
    4755     psF64 bin_stdev = psMetadataLookupF64(&status, config->args, "-bin_stdev");
    4756     if (!status) {
    4757         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bin_stdev");
    4758         return false;
    4759     }
     2906    // required
     2907    PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false);
     2908    PXOPT_LOOKUP_STR(class_id, config->args, "-class_id", true, false);
     2909    PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", true, false);
     2910    PXOPT_LOOKUP_STR(uri, config->args, "-uri", true, false);
     2911    PXOPT_LOOKUP_STR(recipe, config->args, "-recip", true, false);
    47602912
    47612913    // optional
    4762     psString path_base = psMetadataLookupStr(&status, config->args, "-path_base");
    4763     if (!status) {
    4764         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -path_base");
    4765         return false;
    4766     }
    4767 
    4768     // optional
    4769     psF64 fringe_0 = psMetadataLookupF64(&status, config->args, "-fringe_0");
    4770     if (!status) {
    4771         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -fringe_0");
    4772         return false;
    4773     }
    4774     psF64 fringe_1 = psMetadataLookupF64(&status, config->args, "-fringe_1");
    4775     if (!status) {
    4776         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -fringe_1");
    4777         return false;
    4778     }
    4779     psF64 fringe_2 = psMetadataLookupF64(&status, config->args, "-fringe_2");
    4780     if (!status) {
    4781         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -fringe_2");
    4782         return false;
    4783     }
    4784 
    4785     psF64 fringe_resid_0 = psMetadataLookupF64(&status, config->args, "-fringe_resid_0");
    4786     if (!status) {
    4787         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -fringe_resid_0");
    4788         return false;
    4789     }
    4790     psF64 fringe_resid_1 = psMetadataLookupF64(&status, config->args, "-fringe_resid_1");
    4791     if (!status) {
    4792         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -fringe_resid_1");
    4793         return false;
    4794     }
    4795     psF64 fringe_resid_2 = psMetadataLookupF64(&status, config->args, "-fringe_resid_2");
    4796     if (!status) {
    4797         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -fringe_resid_2");
    4798         return false;
    4799     }
    4800 
    4801     psF64 user_1 = psMetadataLookupF64(&status, config->args, "-user_1");
    4802     if (!status) {
    4803         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_1");
    4804         return false;
    4805     }
    4806     psF64 user_2 = psMetadataLookupF64(&status, config->args, "-user_2");
    4807     if (!status) {
    4808         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_2");
    4809         return false;
    4810     }
    4811     psF64 user_3 = psMetadataLookupF64(&status, config->args, "-user_3");
    4812     if (!status) {
    4813         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_3");
    4814         return false;
    4815     }
    4816     psF64 user_4 = psMetadataLookupF64(&status, config->args, "-user_4");
    4817     if (!status) {
    4818         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_4");
    4819         return false;
    4820     }
    4821     psF64 user_5 = psMetadataLookupF64(&status, config->args, "-user_5");
    4822     if (!status) {
    4823         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_5");
    4824         return false;
    4825     }
     2914    PXOPT_LOOKUP_F64(bg, config->args, "-bg", false, false);
     2915    PXOPT_LOOKUP_F64(bg_stdev, config->args, "-bg_stdev", false, false);
     2916    PXOPT_LOOKUP_F64(bg_mean_stdev, config->args, "-bg_mean_stdev", false, false);
     2917    PXOPT_LOOKUP_F64(bg_skewness, config->args, "-bg_skewness", false, false);
     2918    PXOPT_LOOKUP_F64(bg_kurtosis, config->args, "-bg_kurtosis", false, false);
     2919    PXOPT_LOOKUP_F64(bin_stdev, config->args, "-bin_stdev", false, false);
     2920
     2921    PXOPT_LOOKUP_F64(fringe_0, config->args, "-fringe_0", false, false);
     2922    PXOPT_LOOKUP_F64(fringe_1, config->args, "-fringe_1", false, false);
     2923    PXOPT_LOOKUP_F64(fringe_2, config->args, "-fringe_2", false, false);
     2924    PXOPT_LOOKUP_F64(fringe_resid_0, config->args, "-fringe_resid_0", false, false);
     2925    PXOPT_LOOKUP_F64(fringe_resid_1, config->args, "-fringe_resid_1", false, false);
     2926    PXOPT_LOOKUP_F64(fringe_resid_2, config->args, "-fringe_resid_2", false, false);
     2927
     2928    PXOPT_LOOKUP_F64(user_1, config->args, "-user_1", false, false);
     2929    PXOPT_LOOKUP_F64(user_2, config->args, "-user_2", false, false);
     2930    PXOPT_LOOKUP_F64(user_3, config->args, "-user_3", false, false);
     2931    PXOPT_LOOKUP_F64(user_4, config->args, "-user_4", false, false);
     2932    PXOPT_LOOKUP_F64(user_5, config->args, "-user_5", false, false);
     2933    PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", false, false);
    48262934
    48272935    // default values
    4828     psS16 code = psMetadataLookupS16(&status, config->args, "-code");
    4829     if (!status) {
    4830         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -code");
    4831         return false;
    4832     }
    4833 
    4834     // create a new detResidImfileRow and insert it
    4835     if (!detResidImfileInsert(
    4836             config->dbh,
     2936    PXOPT_LOOKUP_S32(iteration, config->args, "-iteration", false, false);
     2937    PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
     2938
     2939    if (!detResidImfileInsert(config->dbh,
    48372940            (psS64)atoll(det_id),
    48382941            iteration,
    … …  
    48682971}
    48692972
     2973
    48702974static bool residimfileMode(pxConfig *config)
    48712975{
    48722976    PS_ASSERT_PTR_NON_NULL(config, false);
    48732977
    4874     char *value = NULL;
    4875     bool status = false;
    4876     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    4877     if (!status) {
    4878         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
    4879         return false;
    4880     }
    4881 
    4882     bool faulted = psMetadataLookupU64(&status, config->args, "-faulted");
    4883     if (!status) {
    4884         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -faulted");
    4885         return false;
    4886     }
     2978    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     2979    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     2980    PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    48872981
    48882982    // select detResidImfile.*
    … …  
    49052999    // NOTE the above WHERE is completed with the following line:
    49063000
     3001    char *value = NULL;
     3002
    49073003    // add the two required restrictions: detRun.state and detRun.mode
     3004    bool status;
    49083005    if ((value = psMetadataLookupStr(&status, config->args, "-select_state"))) {
    49093006        psStringAppend(&query, " detRun.state = '%s'", value);
    … …  
    49513048    }
    49523049
    4953     bool simple = false;
    4954     {
    4955         bool status = false;
    4956         simple = psMetadataLookupBool(&status, config->args, "-simple");
    4957         if (!status) {
    4958             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    4959             psFree(output);
    4960             return false;
    4961         }
    4962     }
    4963 
    49643050    // negative simple so the default is true
    49653051    if (!ippdbPrintMetadatas(stdout, output, "rawResidImfile", !simple)) {
    … …  
    50183104    */
    50193105
    5020 
    5021     bool status = false;
    5022     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    5023     if (!status) {
    5024         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
    5025         return false;
    5026     }
     3106    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     3107    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    50273108
    50283109    psString query = pxDataGet("dettool_toresidexp.sql");
    … …  
    50663147    }
    50673148
    5068     bool simple = false;
    5069     {
    5070         bool status = false;
    5071         simple = psMetadataLookupBool(&status, config->args, "-simple");
    5072         if (!status) {
    5073             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    5074             return false;
    5075         }
    5076     }
    5077 
    50783149    // negative simple so the default is true
    50793150    if (!ippdbPrintMetadatas(stdout, output, "detPendingResidExp", !simple)) {
    … …  
    50913162{
    50923163    PS_ASSERT_PTR_NON_NULL(config, false);
     3164
     3165    // required
     3166    PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false);
     3167    PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", true, false);
     3168    PXOPT_LOOKUP_STR(recipe, config->args, "-recip", true, false);
     3169
     3170    // optional
     3171    PXOPT_LOOKUP_F64(bg, config->args, "-bg", false, false);
     3172    PXOPT_LOOKUP_F64(bg_stdev, config->args, "-bg_stdev", false, false);
     3173    PXOPT_LOOKUP_F64(bg_mean_stdev, config->args, "-bg_mean_stdev", false, false);
     3174    PXOPT_LOOKUP_F64(bg_skewness, config->args, "-bg_skewness", false, false);
     3175    PXOPT_LOOKUP_F64(bg_kurtosis, config->args, "-bg_kurtosis", false, false);
     3176    PXOPT_LOOKUP_F64(bin_stdev, config->args, "-bin_stdev", false, false);
     3177
     3178    PXOPT_LOOKUP_F64(fringe_0, config->args, "-fringe_0", false, false);
     3179    PXOPT_LOOKUP_F64(fringe_1, config->args, "-fringe_1", false, false);
     3180    PXOPT_LOOKUP_F64(fringe_2, config->args, "-fringe_2", false, false);
     3181    PXOPT_LOOKUP_F64(fringe_resid_0, config->args, "-fringe_resid_0", false, false);
     3182    PXOPT_LOOKUP_F64(fringe_resid_1, config->args, "-fringe_resid_1", false, false);
     3183    PXOPT_LOOKUP_F64(fringe_resid_2, config->args, "-fringe_resid_2", false, false);
     3184
     3185    PXOPT_LOOKUP_F64(user_1, config->args, "-user_1", false, false);
     3186    PXOPT_LOOKUP_F64(user_2, config->args, "-user_2", false, false);
     3187    PXOPT_LOOKUP_F64(user_3, config->args, "-user_3", false, false);
     3188    PXOPT_LOOKUP_F64(user_4, config->args, "-user_4", false, false);
     3189    PXOPT_LOOKUP_F64(user_5, config->args, "-user_5", false, false);
     3190    PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", false, false);
     3191
     3192    // default values
     3193    PXOPT_LOOKUP_S32(iteration, config->args, "-iteration", false, false);
     3194    PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
     3195    PXOPT_LOOKUP_BOOL(reject, config->args, "-reject", false);
    50933196
    50943197    /*
    … …  
    50993202    */
    51003203
    5101 
    5102     // select detRun.det_id
    5103     // select detRun.iteration
    5104     // select detRun.det_type
    5105     // select detInputExp.exp_id
    5106     // select detInputExp.include
    5107     // by:
    5108     // find the current iteration bassed on det_id
    5109     // find all exp_ids in the current det_id/iteration from detInputExp
    5110     // compare to detInputExp.imfiles to derResidImfile by class_id
    5111     // and:
    5112     // detResidImfile.{det_id, iteration, exp_id} is not in detResidExp
    5113 
    51143204    psString query = pxDataGet("dettool_toresidexp.sql");
    51153205    if (!query) {
    … …  
    51213211        // build a query to search by det_id, iteration, exp_id
    51223212        psMetadata *where = psMetadataAlloc();
    5123         bool status = false;
    5124         psString det_id = psMetadataLookupStr(&status, config->args, "-det_id");
    5125         if (!status) {
    5126             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -det_id");
    5127             return false;
    5128         }
    5129         if (!det_id) {
    5130             psError(PS_ERR_UNKNOWN, true, "-det_id is required");
    5131             return false;
    5132         }
    5133         if (!psMetadataAddS64(where, PS_LIST_TAIL, "det_id", 0, "==", (psS64)atoll(det_id))) {
    5134             psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    5135             psFree(where);
    5136             psFree(query);
    5137             return false;
    5138         }
    5139 
    5140         psS32 iteration = psMetadataLookupS32(&status, config->args, "-iteration");
    5141         if (!status) {
    5142             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -iteration");
    5143             psFree(where);
    5144             psFree(query);
    5145             return false;
    5146         }
    5147         // always set iteration
    5148         if (!psMetadataAddS32(where, PS_LIST_TAIL, "iteration", 0, "==", iteration)) {
    5149             psError(PS_ERR_UNKNOWN, false, "failed to add item iteration");
    5150             psFree(where);
    5151             psFree(query);
    5152             return false;
    5153         }
    5154         psString exp_id = psMetadataLookupStr(&status, config->args, "-exp_id");
    5155         if (!status) {
    5156             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_id");
    5157             psFree(where);
    5158             psFree(query);
    5159             return false;
    5160         }
    5161         if (exp_id) {
    5162             if (!psMetadataAddStr(where, PS_LIST_TAIL, "exp_id", 0, "==", exp_id)) {
    5163                 psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    5164                 psFree(where);
    5165                 psFree(query);
    5166                 return false;
    5167             }
    5168         }
     3213
     3214        PXOPT_COPY_STR(config->args, where, "-det_id", "det_id", "==");
     3215        PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
     3216        PXOPT_COPY_STR(config->args, where, "-exp_id", "exp_id", "==");
     3217
    51693218
    51703219        // there's not
    … …  
    51953244        return false;
    51963245    }
    5197 
    5198     // start a transaction so it's all rows or nothing
    5199     if (!psDBTransaction(config->dbh)) {
    5200         psError(PS_ERR_UNKNOWN, false, "database error");
    5201         psFree(output);
    5202         return false;
    5203     }
    5204 
    5205     for (long i = 0; i < psArrayLength(output); i++) {
    5206         psMetadata *row = output->data[i];
    5207         // convert metadata into a detResidExp object
    5208         detResidExpRow *residExp = mdToDetResidExp(config, row);
    5209         if (!residExp) {
    5210             if (!psDBRollback(config->dbh)) {
    5211                 psError(PS_ERR_UNKNOWN, false, "database error");
    5212             }
    5213             psError(PS_ERR_UNKNOWN, false, "failed to convert metadata to detResidExp");
    5214             psFree(output);
    5215             return false;
    5216         }
    5217         // insert detResidExp object into the database
    5218         if (!detResidExpInsertObject(config->dbh, residExp)) {
    5219             if (!psDBRollback(config->dbh)) {
    5220                 psError(PS_ERR_UNKNOWN, false, "database error");
    5221             }
    5222             psError(PS_ERR_UNKNOWN, false, "database error");
    5223             psFree(residExp);
    5224             psFree(output);
    5225         }
    5226         psFree(residExp);
    5227     }
    5228 
    52293246    psFree(output);
    52303247
    5231     if (!psDBCommit(config->dbh)) {
    5232         psError(PS_ERR_UNKNOWN, false, "database error");
    5233         return false;
    5234     }
    5235 
    5236     return true;
    5237 }
    5238 
    5239 static detResidExpRow *mdToDetResidExp(pxConfig *config, psMetadata *row)
    5240 {
    5241     PS_ASSERT_PTR_NON_NULL(config, NULL);
    5242     PS_ASSERT_PTR_NON_NULL(row, NULL);
    5243 
    5244     bool status = false;
    5245     // values from row
    5246     psS64 det_id = psMetadataLookupS64(&status, row, "det_id");
    5247     if (!status) {
    5248         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for det_id");
    5249         return false;
    5250     }
    5251     //if (isnan(det_id)) {
    5252     //  psError(PS_ERR_UNKNOWN, true, "det_id is required");
    5253     //  return false;
    5254     //}
    5255     psS32 iteration = psMetadataLookupS32(&status, row, "iteration");
    5256     if (!status) {
    5257         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for iteration");
    5258         return false;
    5259     }
    5260     psS64 exp_id = psMetadataLookupS64(&status, row, "exp_id");
    5261     if (!status) {
    5262         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for exp_id");
    5263         return false;
    5264     }
    5265     if (!exp_id) {
    5266         psError(PS_ERR_UNKNOWN, true, "exp_id is required");
    5267         return false;
    5268     }
    5269 
    5270     // values from config
    5271     psString recipe = psMetadataLookupStr(&status, config->args, "-recip");
    5272     if (!status) {
    5273         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -recip");
    5274         return false;
    5275     }
    5276     if (!recipe) {
    5277         psError(PS_ERR_UNKNOWN, true, "-recip is required");
    5278         return false;
    5279     }
    5280     psF64 bg = psMetadataLookupF64(&status, config->args, "-bg");
    5281     if (!status) {
    5282         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg");
    5283         return false;
    5284     }
    5285     //if (isnan(bg)) {
    5286     //  psError(PS_ERR_UNKNOWN, true, "-bg is required");
    5287     //  return false;
    5288     //}
    5289     psF64 bg_stdev = psMetadataLookupF64(&status, config->args, "-bg_stdev");
    5290     if (!status) {
    5291         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg_stdev");
    5292         return false;
    5293     }
    5294     //if (isnan(bg_stdev)) {
    5295     //  psError(PS_ERR_UNKNOWN, true, "-bg_stdev is required");
    5296     //  return false;
    5297     //}
    5298     psF64 bg_mean_stdev = psMetadataLookupF64(&status, config->args, "-bg_mean_stdev");
    5299     if (!status) {
    5300         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg_mean_stdev");
    5301         return false;
    5302     }
    5303     psF64 bg_skewness = psMetadataLookupF64(&status, config->args, "-bg_skewness");
    5304     if (!status) {
    5305         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg_skewness");
    5306         return false;
    5307     }
    5308     psF64 bg_kurtosis = psMetadataLookupF64(&status, config->args, "-bg_kurtosis");
    5309     if (!status) {
    5310         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg_kurtosis");
    5311         return false;
    5312     }
    5313     psF64 bin_stdev = psMetadataLookupF64(&status, config->args, "-bin_stdev");
    5314     if (!status) {
    5315         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bin_stdev");
    5316         return false;
    5317     }
    5318     // optional
    5319     psF64 fringe_0 = psMetadataLookupF64(&status, config->args, "-fringe_0");
    5320     if (!status) {
    5321         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -fringe_0");
    5322         return false;
    5323     }
    5324     psF64 fringe_1 = psMetadataLookupF64(&status, config->args, "-fringe_1");
    5325     if (!status) {
    5326         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -fringe_1");
    5327         return false;
    5328     }
    5329     psF64 fringe_2 = psMetadataLookupF64(&status, config->args, "-fringe_2");
    5330     if (!status) {
    5331         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -fringe_2");
    5332         return false;
    5333     }
    5334 
    5335     psF64 fringe_resid_0 = psMetadataLookupF64(&status, config->args, "-fringe_resid_0");
    5336     if (!status) {
    5337         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -fringe_resid_0");
    5338         return false;
    5339     }
    5340     psF64 fringe_resid_1 = psMetadataLookupF64(&status, config->args, "-fringe_resid_1");
    5341     if (!status) {
    5342         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -fringe_resid_1");
    5343         return false;
    5344     }
    5345     psF64 fringe_resid_2 = psMetadataLookupF64(&status, config->args, "-fringe_resid_2");
    5346     if (!status) {
    5347         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -fringe_resid_2");
    5348         return false;
    5349     }
    5350 
    5351     psF64 user_1 = psMetadataLookupF64(&status, config->args, "-user_1");
    5352     if (!status) {
    5353         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_1");
    5354         return false;
    5355     }
    5356     psF64 user_2 = psMetadataLookupF64(&status, config->args, "-user_2");
    5357     if (!status) {
    5358         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_2");
    5359         return false;
    5360     }
    5361     psF64 user_3 = psMetadataLookupF64(&status, config->args, "-user_3");
    5362     if (!status) {
    5363         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_3");
    5364         return false;
    5365     }
    5366     psF64 user_4 = psMetadataLookupF64(&status, config->args, "-user_4");
    5367     if (!status) {
    5368         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_4");
    5369         return false;
    5370     }
    5371     psF64 user_5 = psMetadataLookupF64(&status, config->args, "-user_5");
    5372     if (!status) {
    5373         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_5");
    5374         return false;
    5375     }
    5376 
    5377     // optional
    5378     bool reject = psMetadataLookupBool(&status, config->args, "-reject");
    5379     if (!status) {
    5380         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -reject");
    5381         return false;
    5382     }
    5383     psString path_base = psMetadataLookupStr(&status, config->args, "-path_base");
    5384     if (!status) {
    5385         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -path_base");
    5386         return false;
    5387     }
    5388     if (!path_base) {
    5389         psError(PS_ERR_UNKNOWN, true, "-path_base is required");
    5390         return false;
    5391     }
    5392 
    5393     // default values
    5394     psS16 code = psMetadataLookupS16(&status, config->args, "-code");
    5395     if (!status) {
    5396         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -code");
    5397         return false;
    5398     }
    5399 
    5400     // create a new detResidImfileRow and insert it
    5401     return detResidExpRowAlloc(
    5402             det_id,
     3248    if (!detResidExpInsert(config->dbh,
     3249            (psS64)atoll(det_id),
    54033250            iteration,
    5404             exp_id,
     3251            (psS64)atoll(exp_id),
    54053252            recipe,
    54063253            bg,
    … …  
    54243271            !reject,
    54253272            code
    5426         );
     3273        )) {
     3274        psError(PS_ERR_UNKNOWN, false, "database error");
     3275        return false;
     3276    }
     3277
     3278    return true;
    54273279}
    54283280
    … …  
    54313283    PS_ASSERT_PTR_NON_NULL(config, false);
    54323284
    5433     bool status = false;
    5434     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    5435     if (!status) {
    5436         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
    5437         return false;
    5438     }
    5439 
    5440     bool faulted = psMetadataLookupU64(&status, config->args, "-faulted");
    5441     if (!status) {
    5442         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -faulted");
    5443         return false;
    5444     }
     3285    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     3286    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     3287    PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    54453288
    54463289    psString query = psStringCopy(
    … …  
    54973340    }
    54983341
    5499     bool simple = false;
    5500     {
    5501         bool status = false;
    5502         simple = psMetadataLookupBool(&status, config->args, "-simple");
    5503         if (!status) {
    5504             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    5505             return false;
    5506         }
    5507     }
    5508 
    55093342    // negative simple so the default is true
    55103343    if (!ippdbPrintMetadatas(stdout, output, "detResidExp", !simple)) {
    … …  
    55563389    PS_ASSERT_PTR_NON_NULL(config, false);
    55573390
    5558     bool status = false;
    5559     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    5560     if (!status) {
    5561         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
    5562         return false;
    5563     }
     3391    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     3392    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    55643393
    55653394    /* which returns a list of detrend runs (with detrend id, iteration and
    … …  
    56073436    }
    56083437
    5609     bool simple = false;
    5610     {
    5611         bool status = false;
    5612         simple = psMetadataLookupBool(&status, config->args, "-simple");
    5613         if (!status) {
    5614             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    5615             return false;
    5616         }
    5617     }
    5618 
    56193438    // negative simple so the default is true
    56203439    if (!ippdbPrintMetadatas(stdout, output, "detRejectExp", !simple)) {
    … …  
    56333452    PS_ASSERT_PTR_NON_NULL(config, false);
    56343453
     3454    PXOPT_LOOKUP_BOOL(reject, config->args, "-reject", false);
     3455
    56353456    // build a query to search by det_id, iteration, exp_id
    56363457    psMetadata *where = psMetadataAlloc();
    5637     bool status = false;
    5638     psString det_id = psMetadataLookupStr(&status, config->args, "-det_id");
    5639     if (!status) {
    5640         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -det_id");
    5641         psFree(where);
    5642         return false;
    5643     }
    5644     if (det_id) {
    5645         if (!psMetadataAddStr(where, PS_LIST_TAIL, "det_id", 0, "==", det_id)) {
    5646             psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    5647             psFree(where);
    5648             return false;
    5649         }
    5650     }
    5651     psS32 iteration = psMetadataLookupS32(&status, config->args, "-iteration");
    5652     if (!status) {
    5653         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -iteration");
    5654         psFree(where);
    5655         return false;
    5656     }
    5657     // always where iteration
    5658     if (!psMetadataAddS32(where, PS_LIST_TAIL, "iteration", 0, "==", iteration)) {
    5659         psError(PS_ERR_UNKNOWN, false, "failed to add item iteration");
    5660         psFree(where);
    5661         return false;
    5662     }
    5663     psString exp_id = psMetadataLookupStr(&status, config->args, "-exp_id");
    5664     if (!status) {
    5665         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_id");
    5666         psFree(where);
    5667         return false;
    5668     }
    5669     if (exp_id) {
    5670         if (!psMetadataAddStr(where, PS_LIST_TAIL, "exp_id", 0, "==", exp_id)) {
    5671             psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    5672             psFree(where);
    5673             return false;
    5674         }
    5675     }
     3458    PXOPT_COPY_STR(config->args, where, "-det_id", "det_id", "==");
     3459    PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
     3460    PXOPT_COPY_STR(config->args, where, "-exp_id", "exp_id", "==");
    56763461
    56773462    // find the values we're going to set
    … …  
    56793464    // remove the '-' prefix
    56803465    psMetadata *set = psMetadataAlloc();
    5681     psString recipe = psMetadataLookupStr(&status, config->args, "-recip");
    5682     if (!status) {
    5683         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -recip");
    5684         psFree(set);
    5685         psFree(where);
    5686         return false;
    5687     }
    5688     if (recipe) {
    5689         if (!psMetadataAddStr(set, PS_LIST_TAIL, "recipe", 0, "==", recipe)) {
    5690             psError(PS_ERR_UNKNOWN, false, "failed to add item recipe");
    5691             psFree(set);
    5692             psFree(where);
    5693             return false;
    5694         }
    5695     }
    5696 
    5697     psF64 bg = psMetadataLookupF64(&status, config->args, "-bg");
    5698     if (!status) {
    5699         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg");
    5700         psFree(set);
    5701         psFree(where);
    5702         return false;
    5703     }
    5704     if (!isnan(bg)) {
    5705         if (!psMetadataAddF64(set, PS_LIST_TAIL, "bg", 0, "==", bg)) {
    5706             psError(PS_ERR_UNKNOWN, false, "failed to add item bg");
    5707             psFree(set);
    5708             psFree(where);
    5709             return false;
    5710         }
    5711     }
    5712 
    5713     psF64 bg_stdev = psMetadataLookupF64(&status, config->args, "-bg_stdev");
    5714     if (!status) {
    5715         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg_stdev");
    5716         psFree(set);
    5717         psFree(where);
    5718         return false;
    5719     }
    5720     if (!isnan(bg_stdev)) {
    5721         if (!psMetadataAddF64(set, PS_LIST_TAIL, "bg_stdev", 0, "==", bg_stdev)) {
    5722             psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev");
    5723             psFree(set);
    5724             psFree(where);
    5725             return false;
    5726         }
    5727     }
    5728 
    5729     psF64 bg_mean_stdev = psMetadataLookupF64(&status, config->args, "-bg_mean_stdev");
    5730     if (!status) {
    5731         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg_mean_stdev");
    5732         psFree(set);
    5733         psFree(where);
    5734         return false;
    5735     }
    5736     if (!isnan(bg_mean_stdev)) {
    5737         if (!psMetadataAddF64(set, PS_LIST_TAIL, "bg_mean_stdev", 0, "==", bg_mean_stdev)) {
    5738             psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev");
    5739             psFree(set);
    5740             psFree(where);
    5741             return false;
    5742         }
    5743     }
    5744 
    5745     psString path_base = psMetadataLookupStr(&status, config->args, "-path_base");
    5746     if (!status) {
    5747         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -path_base");
    5748         psFree(set);
    5749         psFree(where);
    5750         return false;
    5751     }
    5752     if (path_base) {
    5753         if (!psMetadataAddStr(set, PS_LIST_TAIL, "path_base", 0, "==", path_base)) {
    5754             psError(PS_ERR_UNKNOWN, false, "failed to add item path_base");
    5755             psFree(set);
    5756             psFree(where);
    5757             return false;
    5758         }
    5759     }
    5760 
    5761     bool reject = psMetadataLookupBool(&status, config->args, "-reject");
    5762     if (!status) {
    5763         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -reject");
    5764         psFree(set);
    5765         psFree(where);
    5766         return false;
    5767     }
     3466    // XXX if PXOPT_COPY_* errors here the where md will leak
     3467    PXOPT_COPY_STR(config->args, set, "-recip", "recipe", "==");
     3468    PXOPT_COPY_F64(config->args, set, "-bg", "bg", "==");
     3469    PXOPT_COPY_F64(config->args, set, "-bg_stdev", "bg_stdev", "==");
     3470    PXOPT_COPY_F64(config->args, set, "-bg_mean_stdev", "bg_mean_stdev", "==");
     3471    PXOPT_COPY_STR(config->args, set, "-path_base", "path_base", "==");
     3472
     3473    // this can't be PXOPT_ macro-ized as reject is !'d
    57683474    if (!psMetadataAddBool(set, PS_LIST_TAIL, "accept", 0, "==", !reject)) {
    57693475        psError(PS_ERR_UNKNOWN, false, "failed to add item accept");
    … …  
    57903496
    57913497    // required
    5792     bool status = false;
    5793     psString det_id = psMetadataLookupStr(&status, config->args, "-det_id");
    5794     if (!status) {
    5795         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -det_id");
    5796         return false;
    5797     }
    5798     if (!det_id) {
    5799         psError(PS_ERR_UNKNOWN, true, "-det_id is required");
    5800         return false;
    5801     }
     3498    PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false);
    58023499
    58033500    // optional
    5804     bool again = psMetadataLookupBool(&status, config->args, "-again");
    5805     if (!status) {
    5806         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -again");
    5807         return false;
    5808     }
     3501    PXOPT_LOOKUP_BOOL(again, config->args, "-again", false);
    58093502
    58103503    psString query = pxDataGet("dettool_find_completed_runs.sql");
    … …  
    58143507    }
    58153508
     3509    // build a query to search by det_id, iteration, exp_id
     3510    psMetadata *where = psMetadataAlloc();
     3511    PXOPT_COPY_STR(config->args, where, "-det_id", "det_id", "==");
     3512    PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
     3513
    58163514    {
    5817         // build a query to search by det_id, iteration, exp_id
    5818         psMetadata *where = psMetadataAlloc();
    5819         bool status = false;
    5820         if (det_id) {
    5821             if (!psMetadataAddS64(where, PS_LIST_TAIL, "det_id", 0, "==", (psS64)atoll(det_id))) {
    5822                 psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    5823                 psFree(where);
    5824                 psFree(query);
    5825                 return false;
    5826             }
    5827         }
    5828         psS32 iteration = psMetadataLookupS32(&status, config->args, "-iteration");
    5829         if (!status) {
    5830             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -iteration");
    5831             psFree(where);
    5832             psFree(query);
    5833             return false;
    5834         }
    5835         // always set iteration
    5836         if (!psMetadataAddS32(where, PS_LIST_TAIL, "iteration", 0, "==", iteration)) {
    5837             psError(PS_ERR_UNKNOWN, false, "failed to add item iteration");
    5838             psFree(where);
    5839             psFree(query);
    5840             return false;
    5841         }
    5842 
    58433515        // there's not
    58443516        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    … …  
    59463618    }
    59473619
    5948     // from config->args
    5949     psF64 bg = psMetadataLookupF64(&status, config->args, "-bg");
    5950     if (!status) {
    5951         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg");
    5952         return NULL;
    5953     }
    5954     //if (isnan(bg)) {
    5955     //  psError(PS_ERR_UNKNOWN, true, "-bg is required");
    5956     //  return NULL;
    5957     //}
    5958     psF64 bg_stdev = psMetadataLookupF64(&status, config->args, "-bg_stdev");
    5959     if (!status) {
    5960         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg_stdev");
    5961         return NULL;
    5962     }
    5963     //if (isnan(bg_stdev)) {
    5964     //  psError(PS_ERR_UNKNOWN, true, "-bg_stdev is required");
    5965     //  return NULL;
    5966     //}
    5967     psF64 bg_mean_stdev = psMetadataLookupF64(&status, config->args, "-bg_mean_stdev");
    5968     if (!status) {
    5969         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg_mean_stdev");
    5970         return NULL;
    5971     }
    59723620    // optional
    5973     bool accept = psMetadataLookupBool(&status, config->args, "-accept");
    5974     if (!status) {
    5975         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -accept");
    5976         return NULL;
    5977     }
     3621    PXOPT_LOOKUP_F64(bg, config->args, "-bg", false, false);
     3622    PXOPT_LOOKUP_F64(bg_stdev, config->args, "-bg_stdev", false, false);
     3623    PXOPT_LOOKUP_F64(bg_mean_stdev, config->args, "-bg_mean_stdev", false, false);
    59783624    // default values
    5979     psS16 code = psMetadataLookupS16(&status, config->args, "-code");
    5980     if (!status) {
    5981         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -code");
    5982         return false;
    5983     }
     3625    PXOPT_LOOKUP_BOOL(accept, config->args, "-accept", false);
     3626    PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
    59843627
    59853628    return detRunSummaryRowAlloc(
    … …  
    59983641    PS_ASSERT_PTR_NON_NULL(config, false);
    59993642
    6000     bool status = false;
    6001     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    6002     if (!status) {
    6003         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
    6004         return false;
    6005     }
    6006 
    6007     bool faulted = psMetadataLookupU64(&status, config->args, "-faulted");
    6008     if (!status) {
    6009         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -faulted");
    6010         return false;
    6011     }
     3643    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     3644    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     3645    PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    60123646
    60133647    psString query = psStringCopy(
    … …  
    60623696    }
    60633697
    6064     bool simple = false;
    6065     {
    6066         bool status = false;
    6067         simple = psMetadataLookupBool(&status, config->args, "-simple");
    6068         if (!status) {
    6069             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    6070             return false;
    6071         }
    6072     }
    6073 
    60743698    // negative simple so the default is true
    60753699    if (!ippdbPrintMetadatas(stdout, output, "rawDetrendImfile", !simple)) {
    … …  
    61243748    // XXX this isn't strictly nessicary but not having the det_id complicates
    61253749    // incrementing the iteration number
    6126     bool status = false;
    6127     psString det_id = psMetadataLookupStr(&status, config->args, "-det_id");
    6128     if (!status) {
    6129         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -det_id");
    6130         return false;
    6131     }
    6132     if (!det_id) {
    6133         psError(PS_ERR_UNKNOWN, true, "-det_id is required");
    6134         return false;
    6135     }
     3750    PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false);
     3751
     3752    PXOPT_LOOKUP_BOOL(again, config->args, "-again", false);
     3753    PXOPT_LOOKUP_STR(state, config->args, "-state", false, false);
    61363754    // either -rerun or -state must be specified
    6137     bool again = psMetadataLookupBool(&status, config->args, "-again");
    6138     if (!status) {
    6139         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -again");
    6140         return false;
    6141     }
    6142     psString state = psMetadataLookupStr(&status, config->args, "-state");
    6143     if (!status) {
    6144         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -state");
    6145         return false;
    6146     }
    61473755    if (!(again || state)) {
    61483756        psError(PS_ERR_UNKNOWN, true, "either -again or -state must be specified");
    … …  
    62833891
    62843892    // det_id is required
    6285     bool status = false;
    6286     psString det_id = psMetadataLookupStr(&status, config->args, "-det_id");
    6287     if (!status) {
    6288         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -det_id");
    6289         return false;
    6290     }
    6291     if (!det_id) {
    6292         psError(PS_ERR_UNKNOWN, true, "-det_id is required");
    6293         return false;
    6294     }
     3893    PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false);
    62953894
    62963895    // we have to support multipe exp_ids
    … …  
    64434042    PS_ASSERT_PTR_NON_NULL(config, false);
    64444043
    6445     // required options
    6446     bool status = false;
    6447     psString det_type = psMetadataLookupStr(&status, config->args, "-det_type");
    6448     if (!status) {
    6449         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -det_type");
    6450         return false;
    6451     }
    6452     if (!det_type) {
    6453         psError(PS_ERR_UNKNOWN, true, "-det_type is required");
    6454         return false;
    6455     }
    6456 
    6457     psString filelevel = psMetadataLookupStr(&status, config->args, "-filelevel");
    6458     if (!status) {
    6459         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -filelevel");
    6460         return false;
    6461     }
    6462     if (!filelevel) {
    6463         psError(PS_ERR_UNKNOWN, true, "-filelevel is required");
    6464         return false;
    6465     }
    6466 
    6467     psString workdir = psMetadataLookupStr(&status, config->args, "-workdir");
    6468     if (!status) {
    6469         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -workdir");
    6470         return false;
    6471     }
    6472 
    6473     psString camera = psMetadataLookupStr(&status, config->args, "-inst");
    6474     if (!status) {
    6475         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -inst");
    6476         return false;
    6477     }
    6478 
    6479     psString telescope = psMetadataLookupStr(&status, config->args, "-telescope");
    6480     if (!status) {
    6481         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -telescope");
    6482         return false;
    6483     }
    6484 
    6485     psString exp_type = psMetadataLookupStr(&status, config->args, "-exp_type");
    6486     if (!status) {
    6487         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_type");
    6488         return false;
    6489     }
    6490 
    6491     psString filter = psMetadataLookupStr(&status, config->args, "-filter");
    6492     if (!status) {
    6493         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -filter");
    6494         return false;
    6495     }
    6496 
    6497     psF32 airmass_min = psMetadataLookupF32(&status, config->args, "-airmass_min");
    6498     if (!status) {
    6499         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -airmass_min");
    6500         return false;
    6501     }
    6502 
    6503     psF32 airmass_max = psMetadataLookupF32(&status, config->args, "-airmass_max");
    6504     if (!status) {
    6505         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -airmass_max");
    6506         return false;
    6507     }
    6508 
    6509     psF32 exp_time_min = psMetadataLookupF32(&status, config->args, "-exp_time_min");
    6510     if (!status) {
    6511         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_time_min");
    6512         return false;
    6513     }
    6514 
    6515     psF32 exp_time_max = psMetadataLookupF32(&status, config->args, "-exp_time_max");
    6516     if (!status) {
    6517         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_time_max");
    6518         return false;
    6519     }
    6520 
    6521     psF32 ccd_temp_min = psMetadataLookupF32(&status, config->args, "-ccd_temp_min");
    6522     if (!status) {
    6523         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -ccd_temp_min");
    6524         return false;
    6525     }
    6526 
    6527     psF32 ccd_temp_max = psMetadataLookupF32(&status, config->args, "-ccd_temp_max");
    6528     if (!status) {
    6529         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -ccd_temp_max");
    6530         return false;
    6531     }
    6532 
    6533     psF64 posang_min = psMetadataLookupF32(&status, config->args, "-posang_min");
    6534     if (!status) {
    6535         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -posang_min");
    6536         return false;
    6537     }
    6538 
    6539     psF64 posang_max = psMetadataLookupF32(&status, config->args, "-posang_max");
    6540     if (!status) {
    6541         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -posang_max");
    6542         return false;
    6543     }
    6544 
    6545     psF64 solang_min = psMetadataLookupF32(&status, config->args, "-solang_min");
    6546     if (!status) {
    6547         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -solang_min");
    6548         return false;
    6549     }
    6550 
    6551     psF64 solang_max = psMetadataLookupF32(&status, config->args, "-solang_max");
    6552     if (!status) {
    6553         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -solang_max");
    6554         return false;
    6555     }
    6556 
    6557     psTime *registered = NULL;
    6558     {
    6559         psString registeredStr = psMetadataLookupStr(&status, config->args, "-registered");
    6560         if (!status) {
    6561             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -registered");
    6562             return false;
    6563         }
    6564         // pass through NULL as this is an optional field
    6565         if (registeredStr) {
    6566             registered = psTimeFromISO(registeredStr, PS_TIME_UTC);
    6567         } else {
    6568             registered = NULL;
    6569         }
    6570     }
    6571 
    6572     psTime *time_begin = NULL;
    6573     {
    6574         psString time_beginStr = psMetadataLookupStr(&status, config->args, "-time_begin");
    6575         if (!status) {
    6576             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -time_begin");
    6577             return false;
    6578         }
    6579         // pass through NULL as this is an optional field
    6580         if (time_beginStr) {
    6581             time_begin = psTimeFromISO(time_beginStr, PS_TIME_UTC);
    6582         } else {
    6583             time_begin = NULL;
    6584         }
    6585     }
    6586 
    6587     psTime *time_end = NULL;
    6588     {
    6589         psString time_endStr = psMetadataLookupStr(&status, config->args, "-time_end");
    6590         if (!status) {
    6591             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -time_end");
    6592             return false;
    6593         }
    6594         // pass through NULL as this is an optional field
    6595         if (time_endStr) {
    6596             time_end = psTimeFromISO(time_endStr, PS_TIME_UTC);
    6597         } else {
    6598             time_end = NULL;
    6599         }
    6600     }
    6601 
    6602     psTime *use_begin = NULL;
    6603     {
    6604         psString use_beginStr = psMetadataLookupStr(&status, config->args, "-use_begin");
    6605         if (!status) {
    6606             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -use_begin");
    6607             return false;
    6608         }
    6609         // pass through NULL as this is an optional field
    6610         if (use_beginStr) {
    6611             use_begin = psTimeFromISO(use_beginStr, PS_TIME_UTC);
    6612         } else {
    6613             use_begin = NULL;
    6614         }
    6615     }
    6616 
    6617     psTime *use_end = NULL;
    6618     {
    6619         psString use_endStr = psMetadataLookupStr(&status, config->args, "-use_end");
    6620         if (!status) {
    6621             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -use_end");
    6622             return false;
    6623         }
    6624         // pass through NULL as this is an optional field
    6625         if (use_endStr) {
    6626             use_end = psTimeFromISO(use_endStr, PS_TIME_UTC);
    6627         } else {
    6628             use_end = NULL;
    6629         }
    6630     }
    6631 
    6632     psString parent = psMetadataLookupStr(&status, config->args, "-parent");
    6633     if (!status) {
    6634         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -parent");
    6635         return false;
    6636     }
    6637 
    6638     psString label = psMetadataLookupStr(&status, config->args, "-label");
    6639     if (!status) {
    6640         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -label");
    6641         return false;
    6642     }
     4044    // required
     4045    PXOPT_LOOKUP_STR(det_type, config->args, "-det_type", true, false);
     4046    PXOPT_LOOKUP_STR(filelevel, config->args, "-filelevel", false, false);
     4047
     4048    // optional
     4049    PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", false, false);
     4050    PXOPT_LOOKUP_STR(camera, config->args, "-inst", false, false);
     4051    PXOPT_LOOKUP_STR(telescope, config->args, "-telescope", false, false);
     4052    PXOPT_LOOKUP_STR(exp_type, config->args, "-exp_type", false, false);
     4053    PXOPT_LOOKUP_STR(filter, config->args, "-filter", false, false);
     4054    PXOPT_LOOKUP_F32(airmass_min, config->args, "-airmass_min", false, false);
     4055    PXOPT_LOOKUP_F32(airmass_max, config->args, "-airmass_max", false, false);
     4056    PXOPT_LOOKUP_F32(exp_time_min, config->args, "-exp_time_min", false, false);
     4057    PXOPT_LOOKUP_F32(exp_time_max, config->args, "-exp_time_max", false, false);
     4058    PXOPT_LOOKUP_F32(ccd_temp_min, config->args, "-ccd_temp_min", false, false);
     4059    PXOPT_LOOKUP_F32(ccd_temp_max, config->args, "-ccd_temp_max", false, false);
     4060    PXOPT_LOOKUP_F64(posang_min, config->args, "-posang_min", false, false);
     4061    PXOPT_LOOKUP_F64(posang_max, config->args, "-posang_max", false, false);
     4062    PXOPT_LOOKUP_F64(solang_min, config->args, "-solang_min", false, false);
     4063    PXOPT_LOOKUP_F64(solang_max, config->args, "-solang_max", false, false);
     4064    PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
     4065    PXOPT_LOOKUP_TIME(time_begin, config->args, "-time_begin", false, false);
     4066    PXOPT_LOOKUP_TIME(time_end, config->args, "-time_end", false, false);
     4067    PXOPT_LOOKUP_TIME(use_begin, config->args, "-use_begin", false, false);
     4068    PXOPT_LOOKUP_TIME(use_end, config->args, "-use_end", false, false);
     4069    PXOPT_LOOKUP_STR(parent, config->args, "-parent", false, false);
     4070    PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
     4071
     4072    // default
     4073    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    66434074
    66444075    if (!psDBTransaction(config->dbh)) {
    … …  
    66834114            psError(PS_ERR_UNKNOWN, false, "database error");
    66844115        }
    6685         psFree(registered);
    6686         return false;
    6687     }
    6688     psFree(registered);
     4116        return false;
     4117    }
    66894118
    66904119    // print the new detRun
    … …  
    67194148    }
    67204149
    6721     bool simple = false;
    6722     {
    6723         bool status = false;
    6724         simple = psMetadataLookupBool(&status, config->args, "-simple");
    6725         if (!status) {
    6726             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    6727             return false;
    6728         }
    6729     }
    6730 
    67314150    // negative simple so the default is true
    67324151    if (!ippdbPrintMetadatas(stdout, detRuns, "detRun", !simple)) {
    … …  
    67444163    PS_ASSERT_PTR_NON_NULL(config, false);
    67454164
    6746     // required options
    6747     bool status = false;
    6748     psString det_id = psMetadataLookupStr(&status, config->args, "-det_id");
    6749     if (!status) {
    6750         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -det_id");
    6751         return false;
    6752     }
    6753     if (!det_id) {
    6754         psError(PS_ERR_UNKNOWN, true, "-det_id is required");
    6755         return false;
    6756     }
    6757 
    6758     psString class_id = psMetadataLookupStr(&status, config->args, "-class_id");
    6759     if (!status) {
    6760         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -class_id");
    6761         return false;
    6762     }
    6763     if (!class_id) {
    6764         psError(PS_ERR_UNKNOWN, true, "-class_id is required");
    6765         return false;
    6766     }
    6767 
    6768     psString uri    = psMetadataLookupStr(&status, config->args, "-uri");
    6769     if (!status) {
    6770         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -uri");
    6771         return false;
    6772     }
    6773     if (!uri) {
    6774         psError(PS_ERR_UNKNOWN, true, "-uri is required");
    6775         return false;
    6776     }
    6777 
    6778     // everything else is optional
    6779     psF64 bg = psMetadataLookupF64(&status, config->args, "-bg");
    6780     if (!status) {
    6781         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg");
    6782         return false;
    6783     }
    6784 
    6785     psF64 bg_stdev = psMetadataLookupF64(&status, config->args, "-bg_stdev");
    6786     if (!status) {
    6787         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg_stdev");
    6788         return false;
    6789     }
    6790 
    6791     psF64 bg_mean_stdev = psMetadataLookupF64(&status, config->args, "-bg_mean_stdev");
    6792     if (!status) {
    6793         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg_mean_stdev");
    6794         return false;
    6795     }
    6796 
    6797     psF64 user_1 = psMetadataLookupF64(&status, config->args, "-user_1");
    6798     if (!status) {
    6799         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_1");
    6800         return false;
    6801     }
    6802     psF64 user_2 = psMetadataLookupF64(&status, config->args, "-user_2");
    6803     if (!status) {
    6804         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_2");
    6805         return false;
    6806     }
    6807     psF64 user_3 = psMetadataLookupF64(&status, config->args, "-user_3");
    6808     if (!status) {
    6809         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_3");
    6810         return false;
    6811     }
    6812     psF64 user_4 = psMetadataLookupF64(&status, config->args, "-user_4");
    6813     if (!status) {
    6814         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_4");
    6815         return false;
    6816     }
    6817     psF64 user_5 = psMetadataLookupF64(&status, config->args, "-user_5");
    6818     if (!status) {
    6819         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_5");
    6820         return false;
    6821     }
    6822 
    6823     psString path_base = psMetadataLookupStr(&status, config->args, "-path_base");
    6824     if (!status) {
    6825         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -path_base");
    6826         return false;
    6827     }
     4165    // required
     4166    PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false);
     4167    PXOPT_LOOKUP_STR(class_id, config->args, "-class_id", true, false);
     4168    PXOPT_LOOKUP_STR(uri, config->args, "-uri", true, false);
     4169
     4170    // optional
     4171    PXOPT_LOOKUP_F64(bg, config->args, "-bg", false, false);
     4172    PXOPT_LOOKUP_F64(bg_stdev, config->args, "-bg_stdev", false, false);
     4173    PXOPT_LOOKUP_F64(bg_mean_stdev, config->args, "-bg_mean_stdev", false, false);
     4174    PXOPT_LOOKUP_F64(user_1, config->args, "-user_1", false, false);
     4175    PXOPT_LOOKUP_F64(user_2, config->args, "-user_2", false, false);
     4176    PXOPT_LOOKUP_F64(user_3, config->args, "-user_3", false, false);
     4177    PXOPT_LOOKUP_F64(user_4, config->args, "-user_4", false, false);
     4178    PXOPT_LOOKUP_F64(user_5, config->args, "-user_5", false, false);
     4179    PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", false, false);
    68284180
    68294181    if (!detRegisteredImfileInsert(config->dbh,
    6830                                    (psS64)atoll(det_id),
    6831                                    0,  // the iteration is fixed at 0
    6832                                    class_id,
    6833                                    uri,
    6834                                    bg,
    6835                                    bg_stdev,
    6836                                    bg_mean_stdev,
    6837                                    user_1,
    6838                                    user_2,
    6839                                    user_3,
    6840                                    user_4,
    6841                                    user_5,
    6842                                    path_base,
    6843                                    0       // fault code
    6844             )) {
     4182        (psS64)atoll(det_id),
     4183        0,  // the iteration is fixed at 0
     4184        class_id,
     4185        uri,
     4186        bg,
     4187        bg_stdev,
     4188        bg_mean_stdev,
     4189        user_1,
     4190        user_2,
     4191        user_3,
     4192        user_4,
     4193        user_5,
     4194        path_base,
     4195        0       // fault code
     4196    )) {
    68454197        psError(PS_ERR_UNKNOWN, false, "database error");
    68464198        return false;

  • trunk/ippTools/src/dettoolConfig.c

    r15830 r16170  
    4343    }
    4444
    45     psTime *time = psTimeGetNow(PS_TIME_TAI);
    46     psString now = psTimeToISO(time);
    47     psFree(time);
     45    psTime *now = psTimeGetNow(PS_TIME_TAI);
    4846
    4947    // -pending
    … …  
    105103    psMetadataAddF64(definebytagArgs, PS_LIST_TAIL, "-solang_max",  0,
    106104            "define max solar angle", NAN);
    107     psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-registered",  0,
     105    psMetadataAddTime(definebytagArgs, PS_LIST_TAIL, "-registered",  0,
    108106            "time detrend run was registered", now);
    109     psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-time_begin",  0,
     107    psMetadataAddTime(definebytagArgs, PS_LIST_TAIL, "-time_begin",  0,
    110108            "detrend applyes to exposures taken during this peroid", NULL);
    111     psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-time_end",  0,
     109    psMetadataAddTime(definebytagArgs, PS_LIST_TAIL, "-time_end",  0,
    112110            "detrend applyes to exposures taken during this peroid", NULL);
    113     psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-use_begin",  0,
     111    psMetadataAddTime(definebytagArgs, PS_LIST_TAIL, "-use_begin",  0,
    114112            "start of detrend run applicable peroid", NULL);
    115     psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-use_end",  0,
     113    psMetadataAddTime(definebytagArgs, PS_LIST_TAIL, "-use_end",  0,
    116114            "end of detrend run applicable peroid", NULL);
    117115    psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-reduction",  0,
    … …  
    158156    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-solang_max",  0,
    159157            "define max solar angle", NAN);
    160     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-registered",  0,
     158    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-registered",  0,
    161159            "time detrend run was registered", now);
    162     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-time_begin",  0,
     160    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-time_begin",  0,
    163161            "detrend applyes to exposures taken during this peroid", NULL);
    164     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-time_end",  0,
     162    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-time_end",  0,
    165163            "detrend applyes to exposures taken during this peroid", NULL);
    166     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-use_begin",  0,
     164    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-use_begin",  0,
    167165            "start of detrend run applicable peroid", NULL);
    168     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-use_end",  0,
     166    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-use_end",  0,
    169167            "end of detrend run applicable peroid", NULL);
    170168    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_exp_type",  0,
    … …  
    178176    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_uri",  0,
    179177            "search for uri", NULL);
    180     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_dateobs_begin", 0,
     178    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-select_dateobs_begin", 0,
    181179            "search for exposures by time (>=)", NULL);
    182     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_dateobs_end", 0,
     180    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-select_dateobs_end", 0,
    183181            "search for exposures by time (<)", NULL);
    184182    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_airmass_min",  0,
    … …  
    245243    psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_posang_max",  0,
    246244            "define rotator position angle", NAN);
    247     psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-set_registered",  0,
     245    psMetadataAddTime(definebydetrunArgs, PS_LIST_TAIL, "-set_registered",  0,
    248246            "time detrend run was registered", now);
    249     psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-set_time_begin",  0,
     247    psMetadataAddTime(definebydetrunArgs, PS_LIST_TAIL, "-set_time_begin",  0,
    250248            "start of peroid to apply detrend too", NULL);
    251     psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-set_time_end",  0,
     249    psMetadataAddTime(definebydetrunArgs, PS_LIST_TAIL, "-set_time_end",  0,
    252250            "end of peroid to apply detrend too", NULL);
    253     psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-set_use_begin",  0,
     251    psMetadataAddTime(definebydetrunArgs, PS_LIST_TAIL, "-set_use_begin",  0,
    254252            "start of detrend run applicable peroid", NULL);
    255     psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-set_use_end",  0,
     253    psMetadataAddTime(definebydetrunArgs, PS_LIST_TAIL, "-set_use_end",  0,
    256254            "end of detrend run applicable peroid", NULL);
    257255    psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_solang_min",  0,
    … …  
    10611059    psMetadataAddF64(register_detrendArgs, PS_LIST_TAIL, "-solang_max",  0,
    10621060            "define max solar angle", NAN);
    1063     psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-registered",  0,
     1061    psMetadataAddTime(register_detrendArgs, PS_LIST_TAIL, "-registered",  0,
    10641062            "time detrend run was registered", now);
    1065     psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-time_begin",  0,
     1063    psMetadataAddTime(register_detrendArgs, PS_LIST_TAIL, "-time_begin",  0,
    10661064            "detrend applyes to exposures taken during this peroid", NULL);
    1067     psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-time_end",  0,
     1065    psMetadataAddTime(register_detrendArgs, PS_LIST_TAIL, "-time_end",  0,
    10681066            "detrend applyes to exposures taken during this peroid", NULL);
    1069     psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-use_begin",  0,
     1067    psMetadataAddTime(register_detrendArgs, PS_LIST_TAIL, "-use_begin",  0,
    10701068            "start of detrend run applicable peroid", NULL);
    1071     psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-use_end",  0,
     1069    psMetadataAddTime(register_detrendArgs, PS_LIST_TAIL, "-use_end",  0,
    10721070            "end of detrend run applicable peroid", NULL);
    10731071    psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-parent",  0,
    … …  
    11101108    psMetadata *modes = psMetadataAlloc();
    11111109
    1112     PXTOOL_ADD_MODE("-pending",         "list active detruns", DETTOOL_MODE_PENDING,       pendingArgs);
    1113     PXTOOL_ADD_MODE("-definebytag",     "", DETTOOL_MODE_DEFINEBYTAG,   definebytagArgs);
    1114     PXTOOL_ADD_MODE("-definebyquery",   "", DETTOOL_MODE_DEFINEBYQUERY, definebyqueryArgs);
    1115     PXTOOL_ADD_MODE("-definebydetrun",  "", DETTOOL_MODE_DEFINEBYDETRUN, definebydetrunArgs);
    1116     PXTOOL_ADD_MODE("-makecorrection",  "", DETTOOL_MODE_MAKECORRECTION, makecorrectionArgs);
    1117     PXTOOL_ADD_MODE("-tocorrectexp",    "", DETTOOL_MODE_TOCORRECTEXP, tocorrectexpArgs);
    1118     PXTOOL_ADD_MODE("-tocorrectimfile", "", DETTOOL_MODE_TOCORRECTIMFILE, tocorrectimfileArgs);
    1119     PXTOOL_ADD_MODE("-addcorrectimfile", "", DETTOOL_MODE_ADDCORRECTIMFILE, addcorrectimfileArgs);
    1120     PXTOOL_ADD_MODE("-raw",             "", DETTOOL_MODE_RAW,           rawArgs);
    1121     PXTOOL_ADD_MODE("-runs",            "", DETTOOL_MODE_RUNS,          runsArgs);
    1122     PXTOOL_ADD_MODE("-childlessrun",    "", DETTOOL_MODE_CHILDLESSRUN,  childlessrunArgs);
    1123     PXTOOL_ADD_MODE("-input",           "", DETTOOL_MODE_INPUT,         inputArgs);
    1124     PXTOOL_ADD_MODE("-toprocessedimfile", "", DETTOOL_MODE_TOPROCESSEDIMFILE, toprocessedimfileArgs);
    1125     PXTOOL_ADD_MODE("-addprocessedimfile", "", DETTOOL_MODE_ADDPROCESSEDIMFILE,  addprocessedimfileArgs);
    1126     PXTOOL_ADD_MODE("-processedimfile", "", DETTOOL_MODE_PROCESSEDIMFILE, processedimfileArgs);
    1127     PXTOOL_ADD_MODE("-revertprocessedimfile", "", DETTOOL_MODE_REVERTPROCESSEDIMFILE, revertprocessedimfileArgs);
    1128     PXTOOL_ADD_MODE("-toprocessedexp",  "", DETTOOL_MODE_TOPROCESSEDEXP,  toprocessedexpArgs);
    1129     PXTOOL_ADD_MODE("-addprocessedexp", "", DETTOOL_MODE_ADDPROCESSEDEXP, addprocessedexpArgs);
    1130     PXTOOL_ADD_MODE("-revertprocessedexp", "", DETTOOL_MODE_REVERTPROCESSEDEXP, revertprocessedexpArgs);
    1131     PXTOOL_ADD_MODE("-processedexp",    "", DETTOOL_MODE_PROCESSEDEXP, processedexpArgs);
    1132     PXTOOL_ADD_MODE("-tostacked",       "", DETTOOL_MODE_TOSTACKED,     tostackedArgs);
    1133     PXTOOL_ADD_MODE("-addstacked",      "", DETTOOL_MODE_ADDSTACKED,    addstackedArgs);
    1134     PXTOOL_ADD_MODE("-stacked",         "", DETTOOL_MODE_STACKED,       stackedArgs);
    1135     PXTOOL_ADD_MODE("-revertstacked",   "", DETTOOL_MODE_REVERTSTACKED,  revertstackedArgs);
    1136     PXTOOL_ADD_MODE("-tonormalize",     "", DETTOOL_MODE_TONORMALIZE,   tonormalizeArgs);
    1137     PXTOOL_ADD_MODE("-addnormalizedstat",     "", DETTOOL_MODE_ADDNORMALIZEDSTAT,   addnormstatArgs);
    1138     PXTOOL_ADD_MODE("-normalizedstat",  "", DETTOOL_MODE_NORMALIZEDSTAT,   normalizedstatArgs);
    1139     PXTOOL_ADD_MODE("-revertnormalizedstat",  "", DETTOOL_MODE_REVERTNORMALIZEDSTAT,   revertnormalizedstatArgs);
    1140 
    1141     PXTOOL_ADD_MODE("-tonormalizedstat",      "", DETTOOL_MODE_TONORMALIZEDSTAT,    tonormstatArgs);
    1142     PXTOOL_ADD_MODE("-addnormalizedimfile", "", DETTOOL_MODE_ADDNORMALIZEDIMFILE,addnormalizedimfileArgs);
    1143     PXTOOL_ADD_MODE("-normalizedimfile","", DETTOOL_MODE_NORMALIZEDIMFILE, normalizedimfileArgs);
    1144     PXTOOL_ADD_MODE("-revertnormalizedimfile","", DETTOOL_MODE_REVERTNORMALIZEDIMFILE, revertnormalizedimfileArgs);
    1145     PXTOOL_ADD_MODE("-tonormalizedexp", "", DETTOOL_MODE_TONORMALIZEDEXP, tonormalizedexpArgs);
    1146     PXTOOL_ADD_MODE("-addnormalizedexp", "", DETTOOL_MODE_ADDNORMALIZEDEXP, addnormalizedexpArgs);
    1147     PXTOOL_ADD_MODE("-normalizedexp",   "", DETTOOL_MODE_NORMALIZEDEXP, normalizedexpArgs);
    1148     PXTOOL_ADD_MODE("-revertnormalizedexp","", DETTOOL_MODE_REVERTNORMALIZEDEXP, revertnormalizedexpArgs);
    1149     PXTOOL_ADD_MODE("-toresidimfile",   "", DETTOOL_MODE_TORESIDIMFILE, toresidimfileArgs);
    1150     PXTOOL_ADD_MODE("-addresidimfile",  "", DETTOOL_MODE_ADDRESIDIMFILE, addresidimfileArgs);
    1151     PXTOOL_ADD_MODE("-residimfile",     "", DETTOOL_MODE_RESIDIMFILE, residimfileArgs);
    1152     PXTOOL_ADD_MODE("-revertresidimfile", "", DETTOOL_MODE_REVERTRESIDIMFILE, revertresidimfileArgs);
    1153     PXTOOL_ADD_MODE("-toresidexp",      "", DETTOOL_MODE_TORESIDEXP,    toresidexpArgs);
    1154     PXTOOL_ADD_MODE("-addresidexp",     "", DETTOOL_MODE_ADDRESIDEXP,  addresidexpArgs);
    1155     PXTOOL_ADD_MODE("-residexp",        "", DETTOOL_MODE_RESIDEXP,     residexpArgs);
    1156     PXTOOL_ADD_MODE("-revertresidexp",  "", DETTOOL_MODE_REVERTRESIDEXP, revertresidexpArgs);
    1157     PXTOOL_ADD_MODE("-todetrunsummary",  "", DETTOOL_MODE_TODETRUNSUMMARY,  todetrunsummaryArgs);
    1158     PXTOOL_ADD_MODE("-updateresidexp", "", DETTOOL_MODE_UPDATERESIDEXP,updateresidexpArgs);
    1159     PXTOOL_ADD_MODE("-adddetrunsummary", "", DETTOOL_MODE_ADDDETRUNSUMMARY,adddetrunsummaryArgs);
    1160     PXTOOL_ADD_MODE("-detrunsummary", "", DETTOOL_MODE_DETRUNSUMMARY,detrunsummaryArgs);
    1161     PXTOOL_ADD_MODE("-revertdetrunsummary", "", DETTOOL_MODE_REVERTDETRUNSUMMARY, revertdetrunsummaryArgs);
    1162     PXTOOL_ADD_MODE("-updatedetrun", "", DETTOOL_MODE_UPDATEDETRUN, updatedetrunArgs);
    1163     PXTOOL_ADD_MODE("-rerun",           "", DETTOOL_MODE_RERUN,         rerunArgs);
    1164     PXTOOL_ADD_MODE("-register_detrend", "", DETTOOL_MODE_REGISTER_DETREND, register_detrendArgs);
    1165     PXTOOL_ADD_MODE("-register_detrend_imfile", "", DETTOOL_MODE_REGISTER_DETREND_IMFILE, register_detrend_imfileArgs);
     1110    PXOPT_ADD_MODE("-pending",         "list active detruns", DETTOOL_MODE_PENDING,       pendingArgs);
     1111    PXOPT_ADD_MODE("-definebytag",     "", DETTOOL_MODE_DEFINEBYTAG,   definebytagArgs);
     1112    PXOPT_ADD_MODE("-definebyquery",   "", DETTOOL_MODE_DEFINEBYQUERY, definebyqueryArgs);
     1113    PXOPT_ADD_MODE("-definebydetrun",  "", DETTOOL_MODE_DEFINEBYDETRUN, definebydetrunArgs);
     1114    PXOPT_ADD_MODE("-makecorrection",  "", DETTOOL_MODE_MAKECORRECTION, makecorrectionArgs);
     1115    PXOPT_ADD_MODE("-tocorrectexp",    "", DETTOOL_MODE_TOCORRECTEXP, tocorrectexpArgs);
     1116    PXOPT_ADD_MODE("-tocorrectimfile", "", DETTOOL_MODE_TOCORRECTIMFILE, tocorrectimfileArgs);
     1117    PXOPT_ADD_MODE("-addcorrectimfile", "", DETTOOL_MODE_ADDCORRECTIMFILE, addcorrectimfileArgs);
     1118    PXOPT_ADD_MODE("-raw",             "", DETTOOL_MODE_RAW,           rawArgs);
     1119    PXOPT_ADD_MODE("-runs",            "", DETTOOL_MODE_RUNS,          runsArgs);
     1120    PXOPT_ADD_MODE("-childlessrun",    "", DETTOOL_MODE_CHILDLESSRUN,  childlessrunArgs);
     1121    PXOPT_ADD_MODE("-input",           "", DETTOOL_MODE_INPUT,         inputArgs);
     1122    PXOPT_ADD_MODE("-toprocessedimfile", "", DETTOOL_MODE_TOPROCESSEDIMFILE, toprocessedimfileArgs);
     1123    PXOPT_ADD_MODE("-addprocessedimfile", "", DETTOOL_MODE_ADDPROCESSEDIMFILE,  addprocessedimfileArgs);
     1124    PXOPT_ADD_MODE("-processedimfile", "", DETTOOL_MODE_PROCESSEDIMFILE, processedimfileArgs);
     1125    PXOPT_ADD_MODE("-revertprocessedimfile", "", DETTOOL_MODE_REVERTPROCESSEDIMFILE, revertprocessedimfileArgs);
     1126    PXOPT_ADD_MODE("-toprocessedexp",  "", DETTOOL_MODE_TOPROCESSEDEXP,  toprocessedexpArgs);
     1127    PXOPT_ADD_MODE("-addprocessedexp", "", DETTOOL_MODE_ADDPROCESSEDEXP, addprocessedexpArgs);
     1128    PXOPT_ADD_MODE("-revertprocessedexp", "", DETTOOL_MODE_REVERTPROCESSEDEXP, revertprocessedexpArgs);
     1129    PXOPT_ADD_MODE("-processedexp",    "", DETTOOL_MODE_PROCESSEDEXP, processedexpArgs);
     1130    PXOPT_ADD_MODE("-tostacked",       "", DETTOOL_MODE_TOSTACKED,     tostackedArgs);
     1131    PXOPT_ADD_MODE("-addstacked",      "", DETTOOL_MODE_ADDSTACKED,    addstackedArgs);
     1132    PXOPT_ADD_MODE("-stacked",         "", DETTOOL_MODE_STACKED,       stackedArgs);
     1133    PXOPT_ADD_MODE("-revertstacked",   "", DETTOOL_MODE_REVERTSTACKED,  revertstackedArgs);
     1134    PXOPT_ADD_MODE("-tonormalize",     "", DETTOOL_MODE_TONORMALIZE,   tonormalizeArgs);
     1135    PXOPT_ADD_MODE("-addnormalizedstat",     "", DETTOOL_MODE_ADDNORMALIZEDSTAT,   addnormstatArgs);
     1136    PXOPT_ADD_MODE("-normalizedstat",  "", DETTOOL_MODE_NORMALIZEDSTAT,   normalizedstatArgs);
     1137    PXOPT_ADD_MODE("-revertnormalizedstat",  "", DETTOOL_MODE_REVERTNORMALIZEDSTAT,   revertnormalizedstatArgs);
     1138
     1139    PXOPT_ADD_MODE("-tonormalizedstat",      "", DETTOOL_MODE_TONORMALIZEDSTAT,    tonormstatArgs);
     1140    PXOPT_ADD_MODE("-addnormalizedimfile", "", DETTOOL_MODE_ADDNORMALIZEDIMFILE,addnormalizedimfileArgs);
     1141    PXOPT_ADD_MODE("-normalizedimfile","", DETTOOL_MODE_NORMALIZEDIMFILE, normalizedimfileArgs);
     1142    PXOPT_ADD_MODE("-revertnormalizedimfile","", DETTOOL_MODE_REVERTNORMALIZEDIMFILE, revertnormalizedimfileArgs);
     1143    PXOPT_ADD_MODE("-tonormalizedexp", "", DETTOOL_MODE_TONORMALIZEDEXP, tonormalizedexpArgs);
     1144    PXOPT_ADD_MODE("-addnormalizedexp", "", DETTOOL_MODE_ADDNORMALIZEDEXP, addnormalizedexpArgs);
     1145    PXOPT_ADD_MODE("-normalizedexp",   "", DETTOOL_MODE_NORMALIZEDEXP, normalizedexpArgs);
     1146    PXOPT_ADD_MODE("-revertnormalizedexp","", DETTOOL_MODE_REVERTNORMALIZEDEXP, revertnormalizedexpArgs);
     1147    PXOPT_ADD_MODE("-toresidimfile",   "", DETTOOL_MODE_TORESIDIMFILE, toresidimfileArgs);
     1148    PXOPT_ADD_MODE("-addresidimfile",  "", DETTOOL_MODE_ADDRESIDIMFILE, addresidimfileArgs);
     1149    PXOPT_ADD_MODE("-residimfile",     "", DETTOOL_MODE_RESIDIMFILE, residimfileArgs);
     1150    PXOPT_ADD_MODE("-revertresidimfile", "", DETTOOL_MODE_REVERTRESIDIMFILE, revertresidimfileArgs);
     1151    PXOPT_ADD_MODE("-toresidexp",      "", DETTOOL_MODE_TORESIDEXP,    toresidexpArgs);
     1152    PXOPT_ADD_MODE("-addresidexp",     "", DETTOOL_MODE_ADDRESIDEXP,  addresidexpArgs);
     1153    PXOPT_ADD_MODE("-residexp",        "", DETTOOL_MODE_RESIDEXP,     residexpArgs);
     1154    PXOPT_ADD_MODE("-revertresidexp",  "", DETTOOL_MODE_REVERTRESIDEXP, revertresidexpArgs);
     1155    PXOPT_ADD_MODE("-todetrunsummary",  "", DETTOOL_MODE_TODETRUNSUMMARY,  todetrunsummaryArgs);
     1156    PXOPT_ADD_MODE("-updateresidexp", "", DETTOOL_MODE_UPDATERESIDEXP,updateresidexpArgs);
     1157    PXOPT_ADD_MODE("-adddetrunsummary", "", DETTOOL_MODE_ADDDETRUNSUMMARY,adddetrunsummaryArgs);
     1158    PXOPT_ADD_MODE("-detrunsummary", "", DETTOOL_MODE_DETRUNSUMMARY,detrunsummaryArgs);
     1159    PXOPT_ADD_MODE("-revertdetrunsummary", "", DETTOOL_MODE_REVERTDETRUNSUMMARY, revertdetrunsummaryArgs);
     1160    PXOPT_ADD_MODE("-updatedetrun", "", DETTOOL_MODE_UPDATEDETRUN, updatedetrunArgs);
     1161    PXOPT_ADD_MODE("-rerun",           "", DETTOOL_MODE_RERUN,         rerunArgs);
     1162    PXOPT_ADD_MODE("-register_detrend", "", DETTOOL_MODE_REGISTER_DETREND, register_detrendArgs);
     1163    PXOPT_ADD_MODE("-register_detrend_imfile", "", DETTOOL_MODE_REGISTER_DETREND_IMFILE, register_detrend_imfileArgs);
    11661164
    11671165    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {

  • trunk/ippTools/src/difftool.c

    r15415 r16170  
    9797
    9898    // required options
    99     bool status = false;
    100     psString workdir = psMetadataLookupStr(&status, config->args, "-workdir");
    101     if (!status) {
    102         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -workdir");
    103         return false;
    104     }
    105     if (!workdir) {
    106         psError(PS_ERR_UNKNOWN, true, "-workdir is required");
    107         return false;
    108     }
    109 
    110     psString skycell_id = psMetadataLookupStr(&status, config->args, "-skycell_id");
    111     if (!status) {
    112         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -skycell_id");
    113         return false;
    114     }
    115     if (!skycell_id) {
    116         psError(PS_ERR_UNKNOWN, true, "-skycell_id is required");
    117         return false;
    118     }
    119 
    120     psString tess_id = psMetadataLookupStr(&status, config->args, "-tess_id");
    121     if (!status) {
    122         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -tess_id");
    123         return false;
    124     }
    125     if (!tess_id) {
    126         psError(PS_ERR_UNKNOWN, true, "-tess_id is required");
    127         return false;
    128     }
    129 
    130     psTime *registered = NULL;
    131     {
    132         psString registeredStr = psMetadataLookupStr(&status, config->args, "-registered");
    133         if (!status) {
    134             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -registered");
    135             return false;
    136         }
    137         // pass through NULL as this is an optional field
    138         if (registeredStr) {
    139             registered = psTimeFromISO(registeredStr, PS_TIME_UTC);
    140         } else {
    141             registered = NULL;
    142         }
    143     }
     99    PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false);
     100    PXOPT_LOOKUP_STR(skycell_id, config->args, "-skycell_id", true, false);
     101    PXOPT_LOOKUP_STR(tess_id, config->args, "-tess_id", true, false);
     102
     103    // default
     104    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     105    PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
    144106
    145107    diffRunRow *run = diffRunRowAlloc(
    … …  
    152114            tess_id
    153115    );
    154     psFree(registered);
    155116    if (!run) {
    156117        psError(PS_ERR_UNKNOWN, false, "failed to alloc diffRun object");
    … …  
    166127    run->diff_id = psDBLastInsertID(config->dbh);
    167128
    168     bool simple = false;
    169     {
    170         bool status = false;
    171         simple = psMetadataLookupBool(&status, config->args, "-simple");
    172         if (!status) {
    173             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    174             psFree(run);
    175             return false;
    176         }
    177     }
    178 
    179129    if (!diffRunPrintObject(stdout, run, !simple)) {
    180130            psError(PS_ERR_UNKNOWN, false, "failed to print object");
    … …  
    193143    PS_ASSERT_PTR_NON_NULL(config, false);
    194144
    195     bool status = false;
    196     psString diff_id = psMetadataLookupStr(&status, config->args, "-diff_id");
    197     if (!status) {
    198         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -diff_id");
    199         return false;
    200     }
    201     if (!diff_id) {
    202         psError(PS_ERR_UNKNOWN, true, "-diff_id is required");
    203         return false;
    204     }
    205 
    206     psString state = psMetadataLookupStr(&status, config->args, "-state");
    207     if (!status) {
    208         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -state");
    209         return false;
    210     }
    211     if (!state) {
    212         psError(PS_ERR_UNKNOWN, true, "-state is required");
    213         return false;
    214     }
     145    // required options
     146    PXOPT_LOOKUP_STR(diff_id, config->args, "-diff_id", true, false);
     147    PXOPT_LOOKUP_STR(state, config->args, "-state", true, false);
    215148
    216149    if (state) {
    … …  
    227160    PS_ASSERT_PTR_NON_NULL(config, false);
    228161
    229     bool status = false;
    230     psString diff_id = psMetadataLookupStr(&status, config->args, "-diff_id");
    231     if (!status) {
    232         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -diff_id");
    233         return false;
    234     }
    235     if (!diff_id) {
    236         psError(PS_ERR_UNKNOWN, true, "-diff_id is required");
    237         return false;
    238     }
    239 
    240     psString stack_id = psMetadataLookupStr(&status, config->args, "-stack_id");
    241     if (!status) {
    242         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -stack_id");
    243         return false;
    244     }
    245 
    246     psString warp_id = psMetadataLookupStr(&status, config->args, "-warp_id");
    247     if (!status) {
    248         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -warp_id");
    249         return false;
    250     }
    251 
    252     psString kind = psMetadataLookupStr(&status, config->args, "-kind");
    253     if (!status) {
    254         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -kind");
    255         return false;
    256     }
     162    // required options
     163    PXOPT_LOOKUP_STR(diff_id, config->args, "-diff_id", true, false);
     164
     165    // optional
     166    PXOPT_LOOKUP_STR(stack_id, config->args, "-stack_id", false, false);
     167    PXOPT_LOOKUP_STR(warp_id, config->args, "-warp_id", false, false);
     168    PXOPT_LOOKUP_STR(kind, config->args, "-kind", false, false);
    257169
    258170    // defaults to false
    259     bool template = psMetadataLookupBool(&status, config->args, "-template");
    260     if (!status) {
    261         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -template");
    262         return false;
    263     }
     171    PXOPT_LOOKUP_BOOL(template, config->args, "-template", false);
    264172
    265173    // must provide either stack_id or warp_id but not BOTH
    … …  
    345253    }
    346254
     255    bool status;
    347256    psS32 count = psMetadataLookupS32(&status, output->data[0], "count(diff_id)");
    348257
    … …  
    371280    PS_ASSERT_PTR_NON_NULL(config, false);
    372281
    373     bool status = false;
    374     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    375     if (!status) {
    376         psError(PXTOOLS_ERR_PROG, false, "failed to lookup value for -limit");
    377         return false;
    378     }
     282    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     283    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    379284
    380285    // find all rawImfiles matching the default query
    … …  
    425330    }
    426331
    427     bool simple = false;
    428     {
    429         bool status = false;
    430         simple = psMetadataLookupBool(&status, config->args, "-simple");
    431         if (!status) {
    432             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    433             return false;
    434         }
    435     }
    436 
    437332    if (psArrayLength(output)) {
    438333        if (!convertIdToStr(output)) {
    … …  
    460355    PS_ASSERT_PTR_NON_NULL(config, false);
    461356
    462     bool status = false;
    463     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    464     if (!status) {
    465         psError(PXTOOLS_ERR_PROG, false, "failed to lookup value for -limit");
    466         return false;
    467     }
     357    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     358    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    468359
    469360    psString query = pxDataGet("difftool_todiffskyfile.sql");
    … …  
    513404    }
    514405
    515     bool simple = false;
    516     {
    517         bool status = false;
    518         simple = psMetadataLookupBool(&status, config->args, "-simple");
    519         if (!status) {
    520             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    521             return false;
    522         }
    523     }
    524 
    525406    if (psArrayLength(output)) {
    526407        if (!convertIdToStr(output)) {
    … …  
    548429    PS_ASSERT_PTR_NON_NULL(config, false);
    549430
    550     bool status = false;
    551     psString diff_id = psMetadataLookupStr(&status, config->args, "-diff_id");
    552     if (!status) {
    553         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -diff_id");
    554         return false;
    555     }
    556     if (!diff_id) {
    557         psError(PS_ERR_UNKNOWN, true, "-diff_id is required");
    558         return false;
    559     }
    560 
    561     psS16 code = psMetadataLookupS16(&status, config->args, "-code");
    562     if (!status) {
    563         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -code");
    564         return false;
    565     }
    566 
    567     psString uri = psMetadataLookupStr(&status, config->args, "-uri");
    568     if (!status) {
    569         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -uri");
    570         return false;
    571     }
     431    // required
     432    PXOPT_LOOKUP_STR(diff_id, config->args, "-diff_id", true, false);
     433
     434    // default to 0
     435    PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
     436
     437    PXOPT_LOOKUP_STR(uri, config->args, "-uri", true, false);
    572438    if (code == 0 && !uri) {
    573439        psError(PS_ERR_UNKNOWN, true, "-uri is required");
    … …  
    575441    }
    576442
    577     psString path_base = psMetadataLookupStr(&status, config->args, "-path_base");
    578     if (!status) {
    579         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -path_base");
    580         return false;
    581     }
     443    PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", true, false);
    582444    if (code == 0 && !path_base) {
    583445        psError(PS_ERR_UNKNOWN, true, "-path_base is required");
    … …  
    586448
    587449    // optional
    588     psF64 bg = psMetadataLookupF64(&status, config->args, "-bg");
    589     if (!status) {
    590         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg");
    591         return false;
    592     }
    593 
    594     psF64 bg_stdev = psMetadataLookupF64(&status, config->args, "-bg_stdev");
    595     if (!status) {
    596         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg_stdev");
    597         return false;
    598     }
    599 
    600     psF64 good_frac = psMetadataLookupF64(&status, config->args, "-good_frac");
    601     if (!status) {
    602         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -good_frac");
    603         return false;
    604     }
     450    PXOPT_LOOKUP_F64(bg, config->args, "-bg", false, false);
     451    PXOPT_LOOKUP_F64(bg_stdev, config->args, "-bg_stdev", false, false);
     452    PXOPT_LOOKUP_F64(good_frac, config->args, "-good_frac", false, false);
    605453
    606454    if (!psDBTransaction(config->dbh)) {
    … …  
    647495    PS_ASSERT_PTR_NON_NULL(config, false);
    648496
    649     bool status = false;
    650     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    651     if (!status) {
    652         psError(PXTOOLS_ERR_PROG, false, "failed to lookup value for -limit");
    653         return false;
    654     }
     497    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     498    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    655499
    656500    psString query = pxDataGet("difftool_skyfile.sql");
    … …  
    700544    }
    701545
    702     bool simple = false;
    703     {
    704         bool status = false;
    705         simple = psMetadataLookupBool(&status, config->args, "-simple");
    706         if (!status) {
    707             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    708             return false;
    709         }
    710     }
    711 
    712546    if (psArrayLength(output)) {
    713547        if (!convertIdToStr(output)) {
    … …  
    791625
    792626
    793 
    794 
    795 
    796627static bool definepoprunMode(pxConfig *config)
    797628{
    … …  
    799630
    800631    // required options
    801     bool status = false;
    802     psString workdir = psMetadataLookupStr(&status, config->args, "-workdir");
    803     if (!status) {
    804         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -workdir");
    805         return false;
    806     }
    807     if (!workdir) {
    808         psError(PS_ERR_UNKNOWN, true, "-workdir is required");
    809         return false;
    810     }
    811 
    812     psString skycell_id = psMetadataLookupStr(&status, config->args, "-skycell_id");
    813     if (!status) {
    814         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -skycell_id");
    815         return false;
    816     }
    817     if (!skycell_id) {
    818         psError(PS_ERR_UNKNOWN, true, "-skycell_id is required");
    819         return false;
    820     }
    821 
    822     psString tess_id = psMetadataLookupStr(&status, config->args, "-tess_id");
    823     if (!status) {
    824         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -tess_id");
    825         return false;
    826     }
    827     if (!tess_id) {
    828         psError(PS_ERR_UNKNOWN, true, "-tess_id is required");
    829         return false;
    830     }
    831 
    832     psString template_stack_id = psMetadataLookupStr(&status, config->args, "-template_stack_id");
    833     if (!status) {
    834         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -template_stack_id");
    835         return false;
    836     }
    837     psString template_warp_id = psMetadataLookupStr(&status, config->args, "-template_warp_id");
    838     if (!status) {
    839         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -template_warp_id");
    840         return false;
    841     }
     632    PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false);
     633    PXOPT_LOOKUP_STR(skycell_id, config->args, "-skycell_id", true, false);
     634    PXOPT_LOOKUP_STR(tess_id, config->args, "-tess_id", true, false);
     635
     636    // optional
     637    PXOPT_LOOKUP_STR(template_stack_id, config->args, "-template_stack_id", false, false);
     638    PXOPT_LOOKUP_STR(template_warp_id, config->args, "-template_warp_id", false, false);
     639
    842640    if (template_stack_id && template_warp_id) {
    843641        psError(PS_ERR_BAD_PARAMETER_VALUE, true, "Only one template can be defined.");
    … …  
    850648    }
    851649
    852     psString input_stack_id = psMetadataLookupStr(&status, config->args, "-input_stack_id");
    853     if (!status) {
    854         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -input_stack_id");
    855         return false;
    856     }
    857     psString input_warp_id = psMetadataLookupStr(&status, config->args, "-input_warp_id");
    858     if (!status) {
    859         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -input_warp_id");
    860         return false;
    861     }
     650    PXOPT_LOOKUP_STR(input_stack_id, config->args, "-input_stack_id", false, false);
     651    PXOPT_LOOKUP_STR(input_warp_id, config->args, "-input_warp_id", false, false);
    862652    if (input_stack_id && input_warp_id) {
    863653        psError(PS_ERR_BAD_PARAMETER_VALUE, true, "Only one input can be defined.");
    … …  
    870660    }
    871661
    872     psString kind = NULL;
    873 
    874     psTime *registered = NULL;
    875     {
    876         psString registeredStr = psMetadataLookupStr(&status, config->args, "-registered");
    877         if (!status) {
    878             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -registered");
    879             return false;
    880         }
    881         // pass through NULL as this is an optional field
    882         if (registeredStr) {
    883             registered = psTimeFromISO(registeredStr, PS_TIME_UTC);
    884         } else {
    885             registered = NULL;
    886         }
    887     }
    888 
    889     bool simple = false;
    890     {
    891         bool status = false;
    892         simple = psMetadataLookupBool(&status, config->args, "-simple");
    893         if (!status) {
    894             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    895             return false;
    896         }
    897     }
     662    // default
     663    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     664    PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
    898665
    899666    diffRunRow *run = diffRunRowAlloc(
    … …  
    906673            tess_id
    907674    );
    908     psFree(registered);
    909675
    910676    if (!run) {
    … …  
    936702            skycell_id,
    937703            tess_id,
    938             kind
     704            NULL    // kind
    939705        )) {
    940706        if (!psDBRollback(config->dbh)) {
    … …  
    953719            skycell_id,
    954720            tess_id,
    955             kind
     721            NULL    // kind
    956722        )) {
    957723        if (!psDBRollback(config->dbh)) {

  • trunk/ippTools/src/difftoolConfig.c

    r15415 r16170  
    4343    }
    4444
    45     psTime *time = psTimeGetNow(PS_TIME_TAI);
    46     psString now = psTimeToISO(time);
    47     psFree(time);
     45    psTime *now = psTimeGetNow(PS_TIME_TAI);
    4846
    4947    // -definerun
    … …  
    5149    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-workdir", 0,
    5250            "define workdir (required)", NULL);
    53     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-registered",  0,
     51    psMetadataAddTime(definerunArgs, PS_LIST_TAIL, "-registered",  0,
    5452            "time detrend run was registered", now);
    5553    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-skycell_id",  0,
    … …  
    155153    psMetadataAddStr(definepoprunArgs, PS_LIST_TAIL, "-workdir", 0,
    156154            "define workdir (required)", NULL);
    157     psMetadataAddStr(definepoprunArgs, PS_LIST_TAIL, "-registered",  0,
     155    psMetadataAddTime(definepoprunArgs, PS_LIST_TAIL, "-registered",  0,
    158156            "time detrend run was registered", now);
    159157    psMetadataAddStr(definepoprunArgs, PS_LIST_TAIL, "-skycell_id",  0,
    … …  
    177175    psMetadata *modes = psMetadataAlloc();
    178176
    179     PXTOOL_ADD_MODE("-definerun",        "", DIFFTOOL_MODE_DEFINERUN,         definerunArgs);
    180     PXTOOL_ADD_MODE("-updaterun",        "", DIFFTOOL_MODE_UPDATERUN,         updaterunArgs);
    181     PXTOOL_ADD_MODE("-addinputskyfile",  "", DIFFTOOL_MODE_ADDINPUTSKYFILE,   addinputskyfileArgs);
    182     PXTOOL_ADD_MODE("-inputskyfile",     "", DIFFTOOL_MODE_INPUTSKYFILE,      inputskyfileArgs);
    183     PXTOOL_ADD_MODE("-todiffskyfile",    "", DIFFTOOL_MODE_TODIFFSKYFILE,     todiffskyfileArgs);
    184     PXTOOL_ADD_MODE("-adddiffskyfile",   "", DIFFTOOL_MODE_ADDDIFFSKYFILE,    adddiffskyfileArgs);
    185     PXTOOL_ADD_MODE("-diffskyfile",      "", DIFFTOOL_MODE_DIFFSKYFILE,       diffskyfileArgs);
    186     PXTOOL_ADD_MODE("-revertdiffskyfile","", DIFFTOOL_MODE_REVERTDIFFSKYFILE, revertdiffskyfileArgs);
    187     PXTOOL_ADD_MODE("-definepoprun",     "", DIFFTOOL_MODE_DEFINEPOPRUN,      definepoprunArgs);
     177    PXOPT_ADD_MODE("-definerun",        "", DIFFTOOL_MODE_DEFINERUN,         definerunArgs);
     178    PXOPT_ADD_MODE("-updaterun",        "", DIFFTOOL_MODE_UPDATERUN,         updaterunArgs);
     179    PXOPT_ADD_MODE("-addinputskyfile",  "", DIFFTOOL_MODE_ADDINPUTSKYFILE,   addinputskyfileArgs);
     180    PXOPT_ADD_MODE("-inputskyfile",     "", DIFFTOOL_MODE_INPUTSKYFILE,      inputskyfileArgs);
     181    PXOPT_ADD_MODE("-todiffskyfile",    "", DIFFTOOL_MODE_TODIFFSKYFILE,     todiffskyfileArgs);
     182    PXOPT_ADD_MODE("-adddiffskyfile",   "", DIFFTOOL_MODE_ADDDIFFSKYFILE,    adddiffskyfileArgs);
     183    PXOPT_ADD_MODE("-diffskyfile",      "", DIFFTOOL_MODE_DIFFSKYFILE,       diffskyfileArgs);
     184    PXOPT_ADD_MODE("-revertdiffskyfile","", DIFFTOOL_MODE_REVERTDIFFSKYFILE, revertdiffskyfileArgs);
     185    PXOPT_ADD_MODE("-definepoprun",     "", DIFFTOOL_MODE_DEFINEPOPRUN,      definepoprunArgs);
    188186
    189187    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {

  • trunk/ippTools/src/flatcorr.c

    r15765 r16170  
    8484
    8585
    86 #define ADDRENAMEPARAMSTR(from, to, oldname, newname, comment) \
    87 { \
    88     bool status = false; \
    89     psString str = psMetadataLookupStr(&status, from, "-" oldname); \
    90     if (!status) { \
    91         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -" oldname); \
    92         return false; \
    93     } \
    94     if (str) { \
    95         if (!psMetadataAddStr(to, PS_LIST_TAIL, newname, PS_META_DUPLICATE_OK, comment, str)) { \
    96             psError(PS_ERR_UNKNOWN, false, "failed to add item " newname); \
    97             psFree(to); \
    98             return false; \
    99         } \
    100     } \
    101 }
    102 
    103 #define ADDPARAMSTR(from, to, name) \
    104   ADDRENAMEPARAMSTR(from, to, name, name, "==")
    105 
    106 #define ADDRENAMEPARAMF(from, to, type, oldname, newname, comment) \
    107 { \
    108     bool status = false; \
    109     ps##type var = psMetadataLookup##type(&status, from, "-" oldname); \
    110     if (!status) { \
    111         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -" oldname); \
    112         return false; \
    113     } \
    114     if (!isnan(var)) { \
    115         if (!psMetadataAdd##type(to, PS_LIST_TAIL, newname, PS_META_DUPLICATE_OK, comment, var)) { \
    116             psError(PS_ERR_UNKNOWN, false, "failed to add item " newname); \
    117             psFree(to); \
    118             return false; \
    119         } \
    120     } \
    121 }
    122 
    123 #define ADDPARAMF(from, to, type, name) \
    124   ADDRENAMEPARAMF(from, to, type, name, name, "==")
    125 
    12686static bool newrunMode(pxConfig *config)
    12787{
    12888    PS_ASSERT_PTR_NON_NULL(config, false);
     89
     90    PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", false, false);
    12991
    13092    psMetadata *where = psMetadataAlloc();
    13193    // convert exp_id into a psS64
    132 {
    133     bool status = false;
    134     psString var = psMetadataLookupStr(&status, config->args, "-exp_id");
    135     if (!status) {
    136         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_id");
    137         return false;
    138     }
    139     if (var) {
    140         if (!psMetadataAddS64(where, PS_LIST_TAIL, "exp_id", 0, "==", (psS64)atoll(var))) {
     94    if (exp_id) {
     95        if (!psMetadataAddS64(where, PS_LIST_TAIL, "exp_id", 0, "==", (psS64)atoll(exp_id))) {
    14196            psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    14297            psFree(where);
    … …  
    14499        }
    145100    }
    146 }
    147     ADDPARAMSTR(config->args, where, "exp_name");
    148     ADDRENAMEPARAMSTR(config->args, where, "inst", "camera", "==");
    149     ADDPARAMSTR(config->args, where, "telescope");
    150     ADDPARAMSTR(config->args, where, "dateobs_begin");
    151     ADDPARAMSTR(config->args, where, "dateobs_end");
    152     ADDPARAMSTR(config->args, where, "exp_tag");
    153     ADDPARAMSTR(config->args, where, "exp_type");
    154     ADDPARAMSTR(config->args, where, "filelevel");
    155     ADDPARAMSTR(config->args, where, "reduction");
    156     ADDPARAMSTR(config->args, where, "filter");
    157     ADDRENAMEPARAMF(config->args, where, F64, "airmass_min", "airmass", ">=");
    158     ADDRENAMEPARAMF(config->args, where, F64, "airmass_max", "airmass", "<");
    159     ADDRENAMEPARAMF(config->args, where, F64, "ra_min", "ra", ">=");
    160     ADDRENAMEPARAMF(config->args, where, F64, "ra_max", "ra", "<");
    161     ADDRENAMEPARAMF(config->args, where, F64, "decl_min", "decl", ">=");
    162     ADDRENAMEPARAMF(config->args, where, F64, "decl_max", "decl", "<");
    163     ADDRENAMEPARAMF(config->args, where, F32, "exp_time_min", "exp_time", ">=");
    164     ADDRENAMEPARAMF(config->args, where, F32, "exp_time_max", "exp_time", "<");
    165     ADDRENAMEPARAMF(config->args, where, F32, "sat_pixel_frac_min", "sat_pixel_frac", ">=");
    166     ADDRENAMEPARAMF(config->args, where, F32, "sat_pixel_frac_max", "sat_pixel_frac", "<");
    167     ADDRENAMEPARAMF(config->args, where, F64, "bg_min", "bt", ">=");
    168     ADDRENAMEPARAMF(config->args, where, F64, "bg_max", "bt", "<");
    169     ADDRENAMEPARAMF(config->args, where, F64, "bg_stdev_min", "bg_stdev", ">=");
    170     ADDRENAMEPARAMF(config->args, where, F64, "bg_stdev_max", "bg_stdev", "<");
    171     ADDRENAMEPARAMF(config->args, where, F64, "bg_mean_stdev_min", "bg_mean_stdev", ">=");
    172     ADDRENAMEPARAMF(config->args, where, F64, "bg_mean_stdev_max", "bg_mean_stdev", "<");
    173     ADDRENAMEPARAMF(config->args, where, F64, "alt_min", "alt", ">=");
    174     ADDRENAMEPARAMF(config->args, where, F64, "alt_max", "alt", "<");
    175     ADDRENAMEPARAMF(config->args, where, F64, "az_min", "az", ">=");
    176     ADDRENAMEPARAMF(config->args, where, F64, "az_max", "az", "<");
    177     ADDRENAMEPARAMF(config->args, where, F32, "ccd_temp_min", "ccd_temp", ">=");
    178     ADDRENAMEPARAMF(config->args, where, F32, "ccd_temp_max", "ccd_temp", "<");
    179     ADDRENAMEPARAMF(config->args, where, F64, "posang_min", "posang", ">=");
    180     ADDRENAMEPARAMF(config->args, where, F64, "posang_max", "posang", "<");
    181     ADDPARAMSTR(config->args, where, "object");
    182     ADDRENAMEPARAMF(config->args, where, F32, "solang_min", "solang", ">=");
    183     ADDRENAMEPARAMF(config->args, where, F32, "solang_max", "solang", "<");
     101
     102    PXOPT_COPY_STR(config->args, where, "-exp_name", "exp_name", "==");
     103    PXOPT_COPY_STR(config->args, where, "-inst", "camera", "==");
     104    PXOPT_COPY_STR(config->args, where, "-telescope", "telescope", "==");
     105    PXOPT_COPY_TIME(config->args, where, "-dateobs_begin", "dateobs", ">=");
     106    PXOPT_COPY_TIME(config->args, where, "-dateobs_end", "dateobs", "<=");
     107    PXOPT_COPY_STR(config->args, where, "-exp_tag", "exp_tag", "==");
     108    PXOPT_COPY_STR(config->args, where, "-exp_type", "exp_type", "==");
     109    PXOPT_COPY_STR(config->args, where, "-filelevel", "filelvel", "==");
     110    PXOPT_COPY_STR(config->args, where, "-reduction", "reduction", "==");
     111    PXOPT_COPY_STR(config->args, where, "-filter", "filter", "==");
     112    PXOPT_COPY_F64(config->args, where, "-airmass_min", "airmass", ">=");
     113    PXOPT_COPY_F64(config->args, where, "-airmass_max", "airmass", "<");
     114    PXOPT_COPY_F64(config->args, where, "-ra_min", "ra", ">=");
     115    PXOPT_COPY_F64(config->args, where, "-ra_max", "ra", "<");
     116    PXOPT_COPY_F64(config->args, where, "-decl_min", "decl", ">=");
     117    PXOPT_COPY_F64(config->args, where, "-decl_max", "decl", "<");
     118    PXOPT_COPY_F32(config->args, where, "-exp_time_min", "exp_time", ">=");
     119    PXOPT_COPY_F32(config->args, where, "-exp_time_max", "exp_time", "<");
     120    PXOPT_COPY_F32(config->args, where, "-sat_pixel_frac_min", "sat_pixel_frac", ">=");
     121    PXOPT_COPY_F32(config->args, where, "-sat_pixel_frac_max", "sat_pixel_frac", "<");
     122    PXOPT_COPY_F64(config->args, where, "-bg_min", "bt", ">=");
     123    PXOPT_COPY_F64(config->args, where, "-bg_max", "bt", "<");
     124    PXOPT_COPY_F64(config->args, where, "-bg_stdev_min", "bg_stdev", ">=");
     125    PXOPT_COPY_F64(config->args, where, "-bg_stdev_max", "bg_stdev", "<");
     126    PXOPT_COPY_F64(config->args, where, "-bg_mean_stdev_min", "bg_mean_stdev", ">=");
     127    PXOPT_COPY_F64(config->args, where, "-bg_mean_stdev_max", "bg_mean_stdev", "<");
     128    PXOPT_COPY_F64(config->args, where, "-alt_min", "alt", ">=");
     129    PXOPT_COPY_F64(config->args, where, "-alt_max", "alt", "<");
     130    PXOPT_COPY_F64(config->args, where, "-az_min", "az", ">=");
     131    PXOPT_COPY_F64(config->args, where, "-az_max", "az", "<");
     132    PXOPT_COPY_F32(config->args, where, "-ccd_temp_min", "ccd_temp", ">=");
     133    PXOPT_COPY_F32(config->args, where, "-ccd_temp_max", "ccd_temp", "<");
     134    PXOPT_COPY_F64(config->args, where, "-posang_min", "posang", ">=");
     135    PXOPT_COPY_F64(config->args, where, "-posang_max", "posang", "<");
     136    PXOPT_COPY_STR(config->args, where, "-object", "object", "==");
     137    PXOPT_COPY_F32(config->args, where, "-solang_min", "solang", ">=");
     138    PXOPT_COPY_F32(config->args, where, "-solang_max", "solang", "<");
    184139
    185140    if (where->list->n < 1) {
    … …  
    188143    }
    189144
    190     bool status = false;
    191     psString workdir = psMetadataLookupStr(&status, config->args, "-set_workdir");
    192     if (!status) {
    193         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_workdir");
    194         return false;
    195     }
    196 
    197     psString label = psMetadataLookupStr(&status, config->args, "-set_label");
    198     if (!status) {
    199         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_label");
    200         return false;
    201     }
    202 
    203     psString reduction = psMetadataLookupStr(&status, config->args, "-set_reduction");
    204     if (!status) {
    205         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_reduction");
    206         return false;
    207     }
    208 
    209     psString expgroup = psMetadataLookupStr(&status, config->args, "-set_expgroup");
    210     if (!status) {
    211         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_expgroup");
    212         return false;
    213     }
    214 
    215     psString dvodb = psMetadataLookupStr(&status, config->args, "-set_dvodb");
    216     if (!status) {
    217         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_dvodb");
    218         return false;
    219     }
     145    PXOPT_LOOKUP_STR(workdir, config->args, "-set_workdir", false, false);
     146    PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
     147    PXOPT_LOOKUP_STR(reduction, config->args, "-set_reduction", false, false);
     148    PXOPT_LOOKUP_STR(expgroup, config->args, "-set_expgroup", false, false);
     149    PXOPT_LOOKUP_STR(dvodb, config->args, "-set_dvodb", false, false);
     150    PXOPT_LOOKUP_STR(tess_id, config->args, "-set_tess_id", false, false);
     151    PXOPT_LOOKUP_STR(end_stage, config->args, "-set_end_stage", false, false);
    220152
    221153    // find the exp_id of all the exposures that we want to queue up.
    … …  
    282214        psMetadata *md = output->data[i];
    283215
     216        bool status;
    284217        psS64 exp_id = psMetadataLookupS64(&status, md, "exp_id");
    285218        if (!status) {
    … …  
    293226
    294227        // queue the exp
    295         psS64 chip_id = pxchipQueueByExpTag(config, exp_id, workdir, label, reduction, expgroup, dvodb);
     228        psS64 chip_id = pxchipQueueByExpTag(config, exp_id, workdir, label, reduction, expgroup, dvodb, tess_id, end_stage);
    296229        if (!chip_id) {
    297230            if (!psDBRollback(config->dbh)) {
    … …  
    339272{
    340273    PS_ASSERT_PTR_NON_NULL(config, false);
     274
     275    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    341276
    342277    // create a temp table to hold completely processed chipRuns
    … …  
    408343    }
    409344
    410     bool simple = false;
    411     {
    412         bool status = false;
    413         simple = psMetadataLookupBool(&status, config->args, "-simple");
    414         if (!status) {
    415             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    416             return false;
    417         }
    418     }
    419 
    420345    if (psArrayLength(output)) {
    421346        // negative simple so the default is true
    … …  
    437362    PS_ASSERT_PTR_NON_NULL(config, false);
    438363
    439 
    440     bool status = false;
    441     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    442     if (!status) {
    443         psError(PXTOOLS_ERR_PROG, false, "failed to lookup value for -limit");
    444         return false;
    445     }
     364    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     365    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    446366
    447367    // find all rawImfiles matching the default query
    … …  
    492412    }
    493413
    494     bool simple = false;
    495     {
    496         bool status = false;
    497         simple = psMetadataLookupBool(&status, config->args, "-simple");
    498         if (!status) {            psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    499             return false;
    500         }
    501     }
    502 
    503414    if (psArrayLength(output)) {
    504415        if (!convertIdToStr(output)) {
    … …  
    526437    PS_ASSERT_PTR_NON_NULL(config, false);
    527438
    528     bool status = false;
    529     psString corr_id = psMetadataLookupStr(&status, config->args, "-corr_id");
    530     if (!status) {
    531         psError(PXTOOLS_ERR_PROG, false, "failed to lookup value for -corr_id");
    532         return false;
    533     }
    534 
    535     psString stats = psMetadataLookupStr(&status, config->args, "-stats");
    536     if (!status) {
    537         psError(PXTOOLS_ERR_PROG, false, "failed to lookup value for -stats");
    538         return false;
    539     }
     439    PXOPT_LOOKUP_STR(corr_id, config->args, "-corr_id", true, false);
     440    PXOPT_LOOKUP_STR(stats, config->args, "-stats", true, false);
    540441
    541442    if (!psDBTransaction(config->dbh)) {

  • trunk/ippTools/src/flatcorrConfig.c

    r15765 r16170  
    4343    }
    4444
    45     psTime *time = psTimeGetNow(PS_TIME_TAI);
    46     psString now = psTimeToISO(time);
    47     psFree(time);
     45    psTime *now = psTimeGetNow(PS_TIME_TAI);
    4846
    4947    // -newrun
    … …  
    5856    psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-telescope",  0,
    5957            "search for telescope", NULL);
    60     psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-dateobs_begin", 0,   
     58    psMetadataAddTime(newrunArgs, PS_LIST_TAIL, "-dateobs_begin", 0,   
    6159            "search for exposures by time (>=)", NULL);
    62     psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-dateobs_end", 0,
     60    psMetadataAddTime(newrunArgs, PS_LIST_TAIL, "-dateobs_end", 0,
    6361            "search for exposures by time (<)", NULL);
    6462    psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-exp_tag",  0,
    … …  
    165163    psMetadata *modes = psMetadataAlloc();
    166164
    167     PXTOOL_ADD_MODE("-newrun",  "start a new flat correction run",
     165    PXOPT_ADD_MODE("-newrun",  "start a new flat correction run",
    168166        FLATCORR_MODE_NEWRUN,       newrunArgs);
    169     PXTOOL_ADD_MODE("-pending", "show flat correction runs needing to be processed",
     167    PXOPT_ADD_MODE("-pending", "show flat correction runs needing to be processed",
    170168        FLATCORR_MODE_PENDING,      pendingArgs);
    171     PXTOOL_ADD_MODE("-flatcorrimfile", "list all the exposures in flat correction runs",
     169    PXOPT_ADD_MODE("-flatcorrimfile", "list all the exposures in flat correction runs",
    172170        FLATCORR_MODE_FLATCORRIMFILE, flatcorrimfileArgs);
    173     PXTOOL_ADD_MODE("-done",  "change a flat calibration run's state",
     171    PXOPT_ADD_MODE("-done",  "change a flat calibration run's state",
    174172        FLATCORR_MODE_DONE,         doneArgs);
    175173

  • trunk/ippTools/src/magictool.c

    r15504 r16170  
    262262    PS_ASSERT_PTR_NON_NULL(config, false);
    263263
    264     // required options
    265     bool status = false;
    266     psString workdir = psMetadataLookupStr(&status, config->args, "-workdir");
    267     if (!status) {
    268         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -workdir");
    269         return false;
    270     }
    271     if (!workdir) {
    272         psError(PS_ERR_UNKNOWN, true, "-workdir is required");
    273         return false;
    274     }
    275 
    276     psString label = psMetadataLookupStr(&status, config->args, "-label");
    277     if (!status) {
    278         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -label");
    279         return false;
    280     }
    281 
    282     psString dvodb = psMetadataLookupStr(&status, config->args, "-dvodb");
    283     if (!status) {
    284         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -dvodb");
    285         return false;
    286     }
    287 
    288     psTime *registered = NULL;
    289     {
    290         psString registeredStr = psMetadataLookupStr(&status, config->args, "-registered");
    291         if (!status) {
    292             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -registered");
    293             return false;
    294         }
    295         // pass through NULL as this is an optional field
    296         if (registeredStr) {
    297             registered = psTimeFromISO(registeredStr, PS_TIME_UTC);
    298         } else {
    299             registered = NULL;
    300         }
    301     }
    302 
    303    magicRunRow *run = magicRunRowAlloc(
     264    // required
     265    PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false);
     266
     267    // optional
     268    PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
     269    PXOPT_LOOKUP_STR(dvodb, config->args, "-dvodb", false, false);
     270    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     271    PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
     272
     273    magicRunRow *run = magicRunRowAlloc(
    304274            0,          // ID
    305275            "reg",      // state
    … …  
    325295    run->magic_id = magic_id;
    326296
    327     bool simple = false;
    328     {
    329         bool status = false;
    330         simple = psMetadataLookupBool(&status, config->args, "-simple");
    331         if (!status) {
    332             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    333             psFree(run);
    334             return false;
    335         }
    336     }
    337 
    338297    if (!magicRunPrintObject(stdout, run, !simple)) {
    339298            psError(PS_ERR_UNKNOWN, false, "failed to print object");
    … …  
    352311    PS_ASSERT_PTR_NON_NULL(config, false);
    353312
    354     bool status = false;
    355     psString magic_id = psMetadataLookupStr(&status, config->args, "-magic_id");
    356     if (!status) {
    357         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -magic_id");
    358         return false;
    359     }
    360     if (!magic_id) {
    361         psError(PS_ERR_UNKNOWN, true, "-magic_id is required");
    362         return false;
    363     }
    364 
    365     psString state = psMetadataLookupStr(&status, config->args, "-state");
    366     if (!status) {
    367         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -state");
    368         return false;
    369     }
    370     if (!state) {
    371         psError(PS_ERR_UNKNOWN, true, "-state is required");
    372         return false;
    373     }
     313    // required
     314    PXOPT_LOOKUP_STR(magic_id, config->args, "-magic_id", true, false);
     315    PXOPT_LOOKUP_STR(state, config->args, "-state", true, false);
    374316
    375317    if (state) {
    … …  
    386328    PS_ASSERT_PTR_NON_NULL(config, false);
    387329
    388     bool status = false;
    389     psString magic_id = psMetadataLookupStr(&status, config->args, "-magic_id");
    390     if (!status) {
    391         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -magic_id");
    392         return false;
    393     }
    394     if (!magic_id) {
    395         psError(PS_ERR_UNKNOWN, true, "-magic_id is required");
    396         return false;
    397     }
    398 
    399     psString diff_id = psMetadataLookupStr(&status, config->args, "-diff_id");
    400     if (!status) {
    401         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -diff_id");
    402         return false;
    403     }
    404     if (!diff_id) {
    405         psError(PS_ERR_UNKNOWN, true, "-diff_id is required");
    406         return false;
    407     }
    408 
    409     psString node = psMetadataLookupStr(&status, config->args, "-node");
    410     if (!status) {
    411         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -node");
    412         return false;
    413     }
    414     if (!node) {
    415         psError(PS_ERR_UNKNOWN, true, "-node is required");
    416         return false;
    417     }
     330    // required
     331    PXOPT_LOOKUP_STR(magic_id, config->args, "-magic_id", true, false);
     332    PXOPT_LOOKUP_STR(diff_id, config->args, "-diff_id", true, false);
     333    PXOPT_LOOKUP_STR(node, config->args, "-node", true, false);
    418334
    419335    magicInputSkyfileInsert(
    … …  
    432348    PS_ASSERT_PTR_NON_NULL(config, false);
    433349
    434     bool status = false;
    435     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    436     if (!status) {
    437         psError(PXTOOLS_ERR_PROG, false, "failed to lookup value for -limit");
    438         return false;
    439     }
     350    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     351    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    440352
    441353    // find all rawImfiles matching the default query
    … …  
    486398    }
    487399
    488     bool simple = false;
    489     {
    490         bool status = false;
    491         simple = psMetadataLookupBool(&status, config->args, "-simple");
    492         if (!status) {
    493             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    494             return false;
    495         }
    496     }
    497 
    498400    if (psArrayLength(output)) {
    499401        if (!convertIdToStr(output)) {
    … …  
    521423    PS_ASSERT_PTR_NON_NULL(config, false);
    522424
    523     bool status = false;
    524     psString magic_id = psMetadataLookupStr(&status, config->args, "-magic_id");
    525     if (!status) {
    526         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -magic_id");
    527         return false;
    528     }
    529     if (!magic_id) {
    530         psError(PS_ERR_UNKNOWN, true, "-magic_id is required");
    531         return false;
    532     }
    533 
    534     psString dep_file = psMetadataLookupStr(&status, config->args, "-dep_file");
    535     if (!status) {
    536         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -dep_file");
    537         return false;
    538     }
    539     if (!dep_file) {
    540         psError(PS_ERR_UNKNOWN, true, "-dep_file is required");
    541         return false;
    542     }
     425    // required
     426    PXOPT_LOOKUP_STR(magic_id, config->args, "-magic_id", true, false);
     427    PXOPT_LOOKUP_STR(dep_file, config->args, "-dep_file", true, false);
    543428
    544429    if (!parseAndInsertNodeDeps(config, (psS64)atoll(magic_id), dep_file)) {
     430        psError(PS_ERR_UNKNOWN, false, "failed to parse file");
     431        return false;
    545432    }
    546433
    … …  
    619506    PS_ASSERT_PTR_NON_NULL(config, false);
    620507
    621     bool status = false;
    622     psString magic_id = psMetadataLookupStr(&status, config->args, "-magic_id");
    623     if (!status) {
    624         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -magic_id");
    625         return false;
    626     }
     508    PXOPT_LOOKUP_STR(magic_id, config->args, "-magic_id", false, false);
     509    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    627510
    628511    // look for "inputs" that need to processed
    … …  
    632515        return false;
    633516    }
    634 
    635517
    636518    if (magic_id) {
    … …  
    718600    // convert the array of metadata into a pxTree structure
    719601    for (long i = 0; i < psArrayLength(magicTree); i++) {
     602        bool status;
    720603        psString node = psMetadataLookupStr(&status, magicTree->data[i], "node");
    721604        if (!status) {
    … …  
    743626    psFree(root);
    744627
    745     bool simple = false;
    746     {
    747         bool status = false;
    748         simple = psMetadataLookupBool(&status, config->args, "-simple");
    749         if (!status) {
    750             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    751             return false;
    752         }
    753     }
    754 
    755628    if (psArrayLength(output)) {
    756629        if (!convertIdToStr(output)) {
    … …  
    778651    PS_ASSERT_PTR_NON_NULL(config, false);
    779652
    780     bool status = false;
    781     psString magic_id = psMetadataLookupStr(&status, config->args, "-magic_id");
    782     if (!status) {
    783         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -magic_id");
    784         return false;
    785     }
    786     if (!magic_id) {
    787         psError(PS_ERR_UNKNOWN, true, "-magic_id is required");
    788         return false;
    789     }
    790 
    791     psString node = psMetadataLookupStr(&status, config->args, "-node");
    792     if (!status) {
    793         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -node");
    794         return false;
    795     }
    796     if (!node) {
    797         psError(PS_ERR_UNKNOWN, true, "-node is required");
    798         return false;
    799     }
    800 
    801     psString uri = psMetadataLookupStr(&status, config->args, "-uri");
    802     if (!status) {
    803         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -uri");
    804         return false;
    805     }
    806     if (!uri) {
    807         psError(PS_ERR_UNKNOWN, true, "-uri is required");
    808         return false;
    809     }
     653    // required
     654    PXOPT_LOOKUP_STR(magic_id, config->args, "-magic_id", true, false);
     655    PXOPT_LOOKUP_STR(node, config->args, "-node", true, false);
     656    PXOPT_LOOKUP_STR(uri, config->args, "-uri", true, false);
    810657
    811658    if (!magicNodeResultInsert(config->dbh,
    … …  
    826673    PS_ASSERT_PTR_NON_NULL(config, false);
    827674
    828     bool status = false;
    829     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    830     if (!status) {
    831         psError(PXTOOLS_ERR_PROG, false, "failed to lookup value for -limit");
    832         return false;
    833     }
     675    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     676    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    834677
    835678    // look for "inputs" that need to processed
    … …  
    874717    }
    875718
    876     bool simple = false;
    877     {
    878         bool status = false;
    879         simple = psMetadataLookupBool(&status, config->args, "-simple");
    880         if (!status) {
    881             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    882             return false;
    883         }
    884     }
    885 
    886719    if (psArrayLength(output)) {
    887720        if (!convertIdToStr(output)) {
    … …  
    909742    PS_ASSERT_PTR_NON_NULL(config, false);
    910743
    911     bool status = false;
    912     psString magic_id = psMetadataLookupStr(&status, config->args, "-magic_id");
    913     if (!status) {
    914         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -magic_id");
    915         return false;
    916     }
    917     if (!magic_id) {
    918         psError(PS_ERR_UNKNOWN, true, "-magic_id is required");
    919         return false;
    920     }
    921 
    922     psString uri = psMetadataLookupStr(&status, config->args, "-uri");
    923     if (!status) {
    924         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -uri");
    925         return false;
    926     }
    927     if (!uri) {
    928         psError(PS_ERR_UNKNOWN, true, "-uri is required");
    929         return false;
    930     }
     744    // required
     745    PXOPT_LOOKUP_STR(magic_id, config->args, "-magic_id", true, false);
     746    PXOPT_LOOKUP_STR(uri, config->args, "-uri", true, false);
    931747
    932748    if (!magicMaskInsert(config->dbh,
    … …  
    946762    PS_ASSERT_PTR_NON_NULL(config, false);
    947763
    948     bool status = false;
    949     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    950     if (!status) {
    951         psError(PXTOOLS_ERR_PROG, false, "failed to lookup value for -limit");
    952         return false;
    953     }
     764    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     765    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    954766
    955767    psString query = pxDataGet("magictool_toskyfilemask.sql");
    … …  
    993805    }
    994806
    995     bool simple = false;
    996     {
    997         bool status = false;
    998         simple = psMetadataLookupBool(&status, config->args, "-simple");
    999         if (!status) {
    1000             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    1001             return false;
    1002         }
    1003     }
    1004 
    1005807    if (psArrayLength(output)) {
    1006808        if (!convertIdToStr(output)) {
    … …  
    1028830    PS_ASSERT_PTR_NON_NULL(config, false);
    1029831
    1030     bool status = false;
    1031     psString magic_id = psMetadataLookupStr(&status, config->args, "-magic_id");
    1032     if (!status) {
    1033         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -magic_id");
    1034         return false;
    1035     }
    1036     if (!magic_id) {
    1037         psError(PS_ERR_UNKNOWN, true, "-magic_id is required");
    1038         return false;
    1039     }
    1040 
    1041     psString diff_id = psMetadataLookupStr(&status, config->args, "-diff_id");
    1042     if (!status) {
    1043         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -diff_id");
    1044         return false;
    1045     }
    1046     if (!diff_id) {
    1047         psError(PS_ERR_UNKNOWN, true, "-diff_id is required");
    1048         return false;
    1049     }
    1050 
    1051     psString uri = psMetadataLookupStr(&status, config->args, "-uri");
    1052     if (!status) {
    1053         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -uri");
    1054         return false;
    1055     }
    1056     if (!uri) {
    1057         psError(PS_ERR_UNKNOWN, true, "-uri is required");
    1058         return false;
    1059     }
     832    // required
     833    PXOPT_LOOKUP_STR(magic_id, config->args, "-magic_id", true, false);
     834    PXOPT_LOOKUP_STR(diff_id, config->args, "diff_id", true, false);
     835    PXOPT_LOOKUP_STR(uri, config->args, "uri", true, false);
    1060836
    1061837    if (!magicSkyfileMaskInsert(config->dbh,
    … …  
    1070846    return true;
    1071847}
    1072 
    1073 #if 0
    1074 
    1075 static psS64 definerunMode(pxConfig *config)
    1076 {
    1077     PS_ASSERT_PTR_NON_NULL(config, false);
    1078 
    1079     // required options
    1080     bool status = false;
    1081     psString mode = psMetadataLookupStr(&status, config->args, "-mode");
    1082     if (!status) {
    1083         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -survey_mode");
    1084         return false;
    1085     }
    1086     if (!mode) {
    1087         psError(PS_ERR_UNKNOWN, true, "-mode is required");
    1088         return false;
    1089     }
    1090     // check mode
    1091     if (mode && !isValidMode(config, mode)) {
    1092         psError(PS_ERR_UNKNOWN, false, "invalud mode");
    1093         return false;
    1094     }
    1095 
    1096     psString workdir = psMetadataLookupStr(&status, config->args, "-workdir");
    1097     if (!status) {
    1098         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -workdir");
    1099         return false;
    1100     }
    1101     if (!workdir) {
    1102         psError(PS_ERR_UNKNOWN, true, "-workdir is required");
    1103         return false;
    1104     }
    1105 
    1106     psTime *registered = NULL;
    1107     {
    1108         psString registeredStr = psMetadataLookupStr(&status, config->args, "-registered");
    1109         if (!status) {
    1110             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -registered");
    1111             return false;
    1112         }
    1113         // pass through NULL as this is an optional field
    1114         if (registeredStr) {
    1115             registered = psTimeFromISO(registeredStr, PS_TIME_UTC);
    1116         } else {
    1117             registered = NULL;
    1118         }
    1119     }
    1120 
    1121     warpRunRow *warpRun = warpRunRowAlloc(
    1122             0,          // ID
    1123             mode,
    1124             "reg",      // state
    1125             workdir,
    1126             NULL,       // dvodb
    1127             registered
    1128     );
    1129     psFree(registered);
    1130     if (!warpRun) {
    1131         psError(PS_ERR_UNKNOWN, false, "failed to alloc warpRun object");
    1132         return true;
    1133     }
    1134     if (!warpRunInsertObject(config->dbh, warpRun)) {
    1135         psError(PS_ERR_UNKNOWN, false, "database error");
    1136         psFree(warpRun);
    1137         return true;
    1138     }
    1139 
    1140     // get the assigned warp_id
    1141     psS64 warp_id = psDBLastInsertID(config->dbh);
    1142     warpRun->warp_id = warp_id;
    1143 
    1144     bool simple = false;
    1145     {
    1146         bool status = false;
    1147         simple = psMetadataLookupBool(&status, config->args, "-simple");
    1148         if (!status) {
    1149             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    1150             psFree(warpRun);
    1151             return false;
    1152         }
    1153     }
    1154 
    1155     if (!warpRunPrintObject(stdout, warpRun, !simple)) {
    1156             psError(PS_ERR_UNKNOWN, false, "failed to print object");
    1157             psFree(warpRun);
    1158             return false;
    1159     }
    1160 
    1161     psFree(warpRun);
    1162 
    1163     return warp_id;
    1164 }
    1165 
    1166 static bool runoneMode(pxConfig *config)
    1167 {
    1168     PS_ASSERT_PTR_NON_NULL(config, false);
    1169 
    1170     if (!psDBTransaction(config->dbh)) {
    1171         psError(PS_ERR_UNKNOWN, false, "database error");
    1172         return false;
    1173     }
    1174 
    1175     psS64 warp_id = definerunMode(config);
    1176     if (!warp_id) {
    1177         // rollback
    1178         if (!psDBRollback(config->dbh)) {
    1179             psError(PS_ERR_UNKNOWN, false, "database error");
    1180         }
    1181         psError(PS_ERR_UNKNOWN, false, "failed to define warpRun");
    1182         return false;
    1183     }
    1184 
    1185     psString warp_id_str = psDBIntToString(warp_id);
    1186     if (!psMetadataAddStr(config->args, PS_LIST_TAIL, "-warp_id", 0, NULL, warp_id_str)) {
    1187         // rollback
    1188         if (!psDBRollback(config->dbh)) {
    1189             psError(PS_ERR_UNKNOWN, false, "database error");
    1190         }
    1191         psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    1192         psFree(warp_id_str);
    1193         return false;
    1194     }
    1195     psFree(warp_id_str);
    1196 
    1197     if (!addinputexpMode(config)) {
    1198         // rollback
    1199         if (!psDBRollback(config->dbh)) {
    1200             psError(PS_ERR_UNKNOWN, false, "database error");
    1201         }
    1202         psError(PS_ERR_UNKNOWN, false, "failed to add cam_id to warpRun");
    1203         return false;
    1204     }
    1205     if (!setwarpRunState(config, warp_id, "run")) {
    1206         // rollback
    1207         if (!psDBRollback(config->dbh)) {
    1208             psError(PS_ERR_UNKNOWN, false, "database error");
    1209         }
    1210         psError(PS_ERR_UNKNOWN, false, "failed to set warpRun.state to run");
    1211         return false;
    1212     }
    1213 
    1214     // point of no return
    1215     if (!psDBCommit(config->dbh)) {
    1216         psError(PS_ERR_UNKNOWN, false, "database error");
    1217         return false;
    1218     }
    1219 
    1220     return true;
    1221 }
    1222 
    1223 static bool updaterunMode(pxConfig *config)
    1224 {
    1225     PS_ASSERT_PTR_NON_NULL(config, false);
    1226 
    1227     bool status = false;
    1228     psString warp_id = psMetadataLookupStr(&status, config->args, "-warp_id");
    1229     if (!status) {
    1230         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -warpt_id");
    1231         return false;
    1232     }
    1233     if (!warp_id) {
    1234         psError(PS_ERR_UNKNOWN, true, "-warp_id is required");
    1235         return false;
    1236     }
    1237 
    1238     psString state = psMetadataLookupStr(&status, config->args, "-state");
    1239     if (!status) {
    1240         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -state");
    1241         return false;
    1242     }
    1243     if (!state) {
    1244         psError(PS_ERR_UNKNOWN, true, "-state is required");
    1245         return false;
    1246     }
    1247 
    1248     if (state) {
    1249         // set detRun.state to state
    1250         return setwarpRunState(config, (psS64)atoll(warp_id), state);
    1251     }
    1252 
    1253     return true;
    1254 }
    1255 
    1256 
    1257 static bool addinputexpMode(pxConfig *config)
    1258 {
    1259     PS_ASSERT_PTR_NON_NULL(config, false);
    1260 
    1261     bool status = false;
    1262     psString warp_id = psMetadataLookupStr(&status, config->args, "-warp_id");
    1263     if (!status) {
    1264         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -warp_id");
    1265         return false;
    1266     }
    1267     if (!warp_id) {
    1268         psError(PS_ERR_UNKNOWN, true, "-warp_id is required");
    1269         return false;
    1270     }
    1271 
    1272     psString cam_id = psMetadataLookupStr(&status, config->args, "-cam_id");
    1273     if (!status) {
    1274         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -cam_id");
    1275         return false;
    1276     }
    1277     if (!cam_id) {
    1278         psError(PS_ERR_UNKNOWN, true, "-cam_id is required");
    1279         return false;
    1280     }
    1281 
    1282     // defaults to false
    1283     bool magiced = psMetadataLookupBool(&status, config->args, "-magiced");
    1284     if (!status) {
    1285         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -magiced");
    1286         return false;
    1287     }
    1288 
    1289     // XXX need to validate the warp_id here
    1290     // XXX instead of validiting it here we should just use forgein key
    1291     // constrants
    1292     if (!warpInputExpInsert(config->dbh,
    1293             (psS64)atoll(warp_id),
    1294             (psS64)atoll(cam_id),
    1295             magiced
    1296         )) {
    1297         psError(PS_ERR_UNKNOWN, false, "database error");
    1298         return false;
    1299     }
    1300 
    1301     return true;
    1302 }
    1303 
    1304 
    1305 static bool expMode(pxConfig *config)
    1306 {
    1307     PS_ASSERT_PTR_NON_NULL(config, false);
    1308 
    1309     bool status = false;
    1310     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    1311     if (!status) {
    1312         psError(PXTOOLS_ERR_PROG, false, "failed to lookup value for -limit");
    1313         return false;
    1314     }
    1315 
    1316     // find all rawImfiles matching the default query
    1317     psString query = pxDataGet("warptool_exp.sql");
    1318     if (!query) {
    1319         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    1320         return false;
    1321     }
    1322 
    1323     if (config->where) {
    1324         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "warpInputExp");
    1325         psStringAppend(&query, " AND %s", whereClause);
    1326         psFree(whereClause);
    1327     }
    1328 
    1329     // treat limit == 0 as "no limit"
    1330     if (limit) {
    1331         psString limitString = psDBGenerateLimitSQL(limit);
    1332         psStringAppend(&query, " %s", limitString);
    1333         psFree(limitString);
    1334     }
    1335 
    1336     if (!p_psDBRunQuery(config->dbh, query)) {
    1337         psError(PS_ERR_UNKNOWN, false, "database error");
    1338         psFree(query);
    1339         return false;
    1340     }
    1341     psFree(query);
    1342 
    1343     psArray *output = p_psDBFetchResult(config->dbh);
    1344     if (!output) {
    1345         psErrorCode err = psErrorCodeLast();
    1346         switch (err) {
    1347             case PS_ERR_DB_CLIENT:
    1348                 psError(PXTOOLS_ERR_SYS, false, "database error");
    1349             case PS_ERR_DB_SERVER:
    1350                 psError(PXTOOLS_ERR_PROG, false, "database error");
    1351             default:
    1352                 psError(PXTOOLS_ERR_PROG, false, "unknown error");
    1353         }
    1354 
    1355         return false;
    1356     }
    1357     if (!psArrayLength(output)) {
    1358         psTrace("warptool", PS_LOG_INFO, "no rows found");
    1359         psFree(output);
    1360         return true;
    1361     }
    1362 
    1363     bool simple = false;
    1364     {
    1365         bool status = false;
    1366         simple = psMetadataLookupBool(&status, config->args, "-simple");
    1367         if (!status) {
    1368             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    1369             return false;
    1370         }
    1371     }
    1372 
    1373     if (psArrayLength(output)) {
    1374         if (!convertIdToStr(output)) {
    1375             psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    1376             psFree(output);
    1377             return false;
    1378         }
    1379 
    1380         // negative simple so the default is true
    1381         if (!ippdbPrintMetadatas(stdout, output, "warpInputExp", !simple)) {
    1382             psError(PS_ERR_UNKNOWN, false, "failed to print array");
    1383             psFree(output);
    1384             return false;
    1385         }
    1386     }
    1387 
    1388     psFree(output);
    1389 
    1390     return true;
    1391 }
    1392 
    1393 
    1394 static bool imfileMode(pxConfig *config)
    1395 {
    1396     PS_ASSERT_PTR_NON_NULL(config, false);
    1397 
    1398     bool status = false;
    1399     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    1400     if (!status) {
    1401         psError(PXTOOLS_ERR_PROG, false, "failed to lookup value for -limit");
    1402         return false;
    1403     }
    1404 
    1405     // find all rawImfiles matching the default query
    1406     psString query = pxDataGet("warptool_imfile.sql");
    1407     if (!query) {
    1408         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    1409         return false;
    1410     }
    1411 
    1412     if (config->where) {
    1413         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "warpInputExp");
    1414         psStringAppend(&query, " AND %s", whereClause);
    1415         psFree(whereClause);
    1416     }
    1417 
    1418     // treat limit == 0 as "no limit"
    1419     if (limit) {
    1420         psString limitString = psDBGenerateLimitSQL(limit);
    1421         psStringAppend(&query, " %s", limitString);
    1422         psFree(limitString);
    1423     }
    1424 
    1425     if (!p_psDBRunQuery(config->dbh, query)) {
    1426         psError(PS_ERR_UNKNOWN, false, "database error");
    1427         psFree(query);
    1428         return false;
    1429     }
    1430     psFree(query);
    1431 
    1432     psArray *output = p_psDBFetchResult(config->dbh);
    1433     if (!output) {
    1434         psErrorCode err = psErrorCodeLast();
    1435         switch (err) {
    1436             case PS_ERR_DB_CLIENT:
    1437                 psError(PXTOOLS_ERR_SYS, false, "database error");
    1438             case PS_ERR_DB_SERVER:
    1439                 psError(PXTOOLS_ERR_PROG, false, "database error");
    1440             default:
    1441                 psError(PXTOOLS_ERR_PROG, false, "unknown error");
    1442         }
    1443 
    1444         return false;
    1445     }
    1446     if (!psArrayLength(output)) {
    1447         psTrace("warptool", PS_LOG_INFO, "no rows found");
    1448         psFree(output);
    1449         return true;
    1450     }
    1451 
    1452     bool simple = false;
    1453     {
    1454         bool status = false;
    1455         simple = psMetadataLookupBool(&status, config->args, "-simple");
    1456         if (!status) {
    1457             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    1458             return false;
    1459         }
    1460     }
    1461 
    1462     if (psArrayLength(output)) {
    1463         if (!convertIdToStr(output)) {
    1464             psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    1465             psFree(output);
    1466             return false;
    1467         }
    1468 
    1469         // negative simple so the default is true
    1470         if (!ippdbPrintMetadatas(stdout, output, "warpInputImfile", !simple)) {
    1471             psError(PS_ERR_UNKNOWN, false, "failed to print array");
    1472             psFree(output);
    1473             return false;
    1474         }
    1475     }
    1476 
    1477     psFree(output);
    1478 
    1479     return true;
    1480 }
    1481 
    1482 
    1483 static bool tooverlapMode(pxConfig *config)
    1484 {
    1485     PS_ASSERT_PTR_NON_NULL(config, false);
    1486 
    1487     bool status = false;
    1488     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    1489     if (!status) {
    1490         psError(PXTOOLS_ERR_PROG, false, "failed to lookup value for -limit");
    1491         return false;
    1492     }
    1493 
    1494     // find all rawImfiles matching the default query
    1495     psString query = pxDataGet("warptool_tooverlap.sql");
    1496     if (!query) {
    1497         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    1498         return false;
    1499     }
    1500 
    1501     if (config->where) {
    1502         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "warpInputExp");
    1503         psStringAppend(&query, " AND %s", whereClause);
    1504         psFree(whereClause);
    1505     }
    1506 
    1507     // treat limit == 0 as "no limit"
    1508     if (limit) {
    1509         psString limitString = psDBGenerateLimitSQL(limit);
    1510         psStringAppend(&query, " %s", limitString);
    1511         psFree(limitString);
    1512     }
    1513 
    1514     if (!p_psDBRunQuery(config->dbh, query)) {
    1515         psError(PS_ERR_UNKNOWN, false, "database error");
    1516         psFree(query);
    1517         return false;
    1518     }
    1519     psFree(query);
    1520 
    1521     psArray *output = p_psDBFetchResult(config->dbh);
    1522     if (!output) {
    1523         psErrorCode err = psErrorCodeLast();
    1524         switch (err) {
    1525             case PS_ERR_DB_CLIENT:
    1526                 psError(PXTOOLS_ERR_SYS, false, "database error");
    1527             case PS_ERR_DB_SERVER:
    1528                 psError(PXTOOLS_ERR_PROG, false, "database error");
    1529             default:
    1530                 psError(PXTOOLS_ERR_PROG, false, "unknown error");
    1531         }
    1532 
    1533         return false;
    1534     }
    1535     if (!psArrayLength(output)) {
    1536         psTrace("warptool", PS_LOG_INFO, "no rows found");
    1537         psFree(output);
    1538         return true;
    1539     }
    1540 
    1541     bool simple = false;
    1542     {
    1543         bool status = false;
    1544         simple = psMetadataLookupBool(&status, config->args, "-simple");
    1545         if (!status) {
    1546             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    1547             return false;
    1548         }
    1549     }
    1550 
    1551     if (psArrayLength(output)) {
    1552         if (!convertIdToStr(output)) {
    1553             psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    1554             psFree(output);
    1555             return false;
    1556         }
    1557 
    1558         // negative simple so the default is true
    1559         if (!ippdbPrintMetadatas(stdout, output, "warpInputExp", !simple)) {
    1560             psError(PS_ERR_UNKNOWN, false, "failed to print array");
    1561             psFree(output);
    1562             return false;
    1563         }
    1564     }
    1565 
    1566     psFree(output);
    1567 
    1568     return true;
    1569 }
    1570 
    1571 
    1572 static bool addoverlapMode(pxConfig *config)
    1573 {
    1574     PS_ASSERT_PTR_NON_NULL(config, false);
    1575 
    1576     bool status = false;
    1577     psString mapfile = psMetadataLookupStr(&status, config->args, "-mapfile");
    1578     if (!status) {
    1579         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -mapfile");
    1580         return false;
    1581     }
    1582     if (!mapfile) {
    1583         psError(PS_ERR_UNKNOWN, true, "-mapfile is required");
    1584         return false;
    1585     }
    1586 
    1587     if (!psDBTransaction(config->dbh)) {
    1588         psError(PS_ERR_UNKNOWN, false, "database error");
    1589         return false;
    1590     }
    1591 
    1592     if (!parseAndInsertSkyCellMap(config, mapfile)) {
    1593         psError(PS_ERR_UNKNOWN, false, "failed to inject mapfile: %s into the database", mapfile);
    1594         // rollback
    1595         if (!psDBRollback(config->dbh)) {
    1596             psError(PS_ERR_UNKNOWN, false, "database error");
    1597         }
    1598         return false;
    1599     }
    1600 
    1601     // point of no return
    1602     if (!psDBCommit(config->dbh)) {
    1603         psError(PS_ERR_UNKNOWN, false, "database error");
    1604         return false;
    1605     }
    1606 
    1607     return true;
    1608 }
    1609 
    1610 
    1611 static bool parseAndInsertSkyCellMap(pxConfig *config, const char *mapfile)
    1612 {
    1613     unsigned int nFail = 0;
    1614     psMetadata *skycells = psMetadataConfigRead(NULL, &nFail, mapfile, false);
    1615     if (!skycells) {
    1616         psError(PS_ERR_UNKNOWN, false, "failed to parse mapfile: %s", mapfile);
    1617         return false;
    1618     }
    1619     if (nFail) {
    1620         psError(PS_ERR_UNKNOWN, false, "there were %d errors parsing mapfile: %s", nFail, mapfile);
    1621         psFree(skycells);
    1622         return false;
    1623     }
    1624 
    1625     psMetadataItem *item = NULL;
    1626     psMetadataIterator *iter = psMetadataIteratorAlloc(skycells, 0, NULL);
    1627     while ((item = psMetadataGetAndIncrement(iter))) {
    1628         if (item->type != PS_DATA_METADATA) {
    1629             psError(PS_ERR_UNKNOWN, false, "mapfile: %s is in the wrong format", mapfile);
    1630             psFree(iter);
    1631             psFree(skycells);
    1632             return false;
    1633         }
    1634 
    1635         psMetadata *sc = item->data.md;
    1636         // this conversion isn't strictly nessicary but it's an easy way of
    1637         // validating the format
    1638         warpSkyCellMapRow *row = warpSkyCellMapObjectFromMetadata(sc);
    1639         if (!row) {
    1640             psError(PS_ERR_UNKNOWN, false, "failed to convert mapfile: %s metdata entry into a warpSkyCellMap object", mapfile);
    1641             psFree(iter);
    1642             psFree(skycells);
    1643             return false;
    1644         }
    1645 
    1646         if (!warpSkyCellMapInsertObject(config->dbh, row)) {
    1647             psErrorCode err = psErrorCodeLast();
    1648             switch (err) {
    1649                 case PS_ERR_DB_CLIENT:
    1650                     psError(PXTOOLS_ERR_SYS, false, "database error");
    1651                 case PS_ERR_DB_SERVER:
    1652                     psError(PXTOOLS_ERR_PROG, false, "database error");
    1653                 default:
    1654                     psError(PXTOOLS_ERR_PROG, false, "unknown error");
    1655             }
    1656             psFree(row);
    1657             psFree(iter);
    1658             psFree(skycells);
    1659             return false;
    1660         }
    1661 
    1662         psFree(row);
    1663     }
    1664     psFree(iter);
    1665     psFree(skycells);
    1666 
    1667     return true;
    1668 }
    1669 
    1670 
    1671 static bool scmapMode(pxConfig *config)
    1672 {
    1673     PS_ASSERT_PTR_NON_NULL(config, false);
    1674 
    1675     bool status = false;
    1676     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    1677     if (!status) {
    1678         psError(PXTOOLS_ERR_PROG, false, "failed to lookup value for -limit");
    1679         return false;
    1680     }
    1681 
    1682     // find all rawImfiles matching the default query
    1683     psString query = pxDataGet("warptool_scmap.sql");
    1684     if (!query) {
    1685         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    1686         return false;
    1687     }
    1688 
    1689     if (config->where) {
    1690         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "warpSkyCellMap");
    1691         psStringAppend(&query, " AND %s", whereClause);
    1692         psFree(whereClause);
    1693     }
    1694 
    1695     // treat limit == 0 as "no limit"
    1696     if (limit) {
    1697         psString limitString = psDBGenerateLimitSQL(limit);
    1698         psStringAppend(&query, " %s", limitString);
    1699         psFree(limitString);
    1700     }
    1701 
    1702     if (!p_psDBRunQuery(config->dbh, query)) {
    1703         psError(PS_ERR_UNKNOWN, false, "database error");
    1704         psFree(query);
    1705         return false;
    1706     }
    1707     psFree(query);
    1708 
    1709     psArray *output = p_psDBFetchResult(config->dbh);
    1710     if (!output) {
    1711         psErrorCode err = psErrorCodeLast();
    1712         switch (err) {
    1713             case PS_ERR_DB_CLIENT:
    1714                 psError(PXTOOLS_ERR_SYS, false, "database error");
    1715             case PS_ERR_DB_SERVER:
    1716                 psError(PXTOOLS_ERR_PROG, false, "database error");
    1717             default:
    1718                 psError(PXTOOLS_ERR_PROG, false, "unknown error");
    1719         }
    1720 
    1721         return false;
    1722     }
    1723     if (!psArrayLength(output)) {
    1724         psTrace("warptool", PS_LOG_INFO, "no rows found");
    1725         psFree(output);
    1726         return true;
    1727     }
    1728 
    1729     bool simple = false;
    1730     {
    1731         bool status = false;
    1732         simple = psMetadataLookupBool(&status, config->args, "-simple");
    1733         if (!status) {
    1734             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    1735             return false;
    1736         }
    1737     }
    1738 
    1739     if (psArrayLength(output)) {
    1740         if (!convertIdToStr(output)) {
    1741             psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    1742             psFree(output);
    1743             return false;
    1744         }
    1745 
    1746         // negative simple so the default is true
    1747         if (!ippdbPrintMetadatas(stdout, output, "warpSkyCellMap", !simple)) {
    1748             psError(PS_ERR_UNKNOWN, false, "failed to print array");
    1749             psFree(output);
    1750             return false;
    1751         }
    1752     }
    1753 
    1754     psFree(output);
    1755 
    1756     return true;
    1757 }
    1758 
    1759 
    1760 static bool towarpedMode(pxConfig *config)
    1761 {
    1762     PS_ASSERT_PTR_NON_NULL(config, false);
    1763 
    1764     bool status = false;
    1765     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    1766     if (!status) {
    1767         psError(PXTOOLS_ERR_PROG, false, "failed to lookup value for -limit");
    1768         return false;
    1769     }
    1770 
    1771     // find all rawImfiles matching the default query
    1772     psString query = pxDataGet("warptool_towarped.sql");
    1773     if (!query) {
    1774         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    1775         return false;
    1776     }
    1777 
    1778     if (config->where) {
    1779         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "warpSkyCellMap");
    1780         psStringAppend(&query, " AND %s", whereClause);
    1781         psFree(whereClause);
    1782     }
    1783 
    1784     // treat limit == 0 as "no limit"
    1785     if (limit) {
    1786         psString limitString = psDBGenerateLimitSQL(limit);
    1787         psStringAppend(&query, " %s", limitString);
    1788         psFree(limitString);
    1789     }
    1790 
    1791     if (!p_psDBRunQuery(config->dbh, query)) {
    1792         psError(PS_ERR_UNKNOWN, false, "database error");
    1793         psFree(query);
    1794         return false;
    1795     }
    1796     psFree(query);
    1797 
    1798     psArray *output = p_psDBFetchResult(config->dbh);
    1799     if (!output) {
    1800         psErrorCode err = psErrorCodeLast();
    1801         switch (err) {
    1802             case PS_ERR_DB_CLIENT:
    1803                 psError(PXTOOLS_ERR_SYS, false, "database error");
    1804             case PS_ERR_DB_SERVER:
    1805                 psError(PXTOOLS_ERR_PROG, false, "database error");
    1806             default:
    1807                 psError(PXTOOLS_ERR_PROG, false, "unknown error");
    1808         }
    1809 
    1810         return false;
    1811     }
    1812     if (!psArrayLength(output)) {
    1813         psTrace("warptool", PS_LOG_INFO, "no rows found");
    1814         psFree(output);
    1815         return true;
    1816     }
    1817 
    1818     bool simple = false;
    1819     {
    1820         bool status = false;
    1821         simple = psMetadataLookupBool(&status, config->args, "-simple");
    1822         if (!status) {
    1823             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    1824             return false;
    1825         }
    1826     }
    1827 
    1828     if (psArrayLength(output)) {
    1829         if (!convertIdToStr(output)) {
    1830             psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    1831             psFree(output);
    1832             return false;
    1833         }
    1834 
    1835         // negative simple so the default is true
    1836         if (!ippdbPrintMetadatas(stdout, output, "warpPendingSkyCell", !simple)) {
    1837             psError(PS_ERR_UNKNOWN, false, "failed to print array");
    1838             psFree(output);
    1839             return false;
    1840         }
    1841     }
    1842 
    1843     psFree(output);
    1844 
    1845     return true;
    1846 }
    1847 
    1848 
    1849 static bool addwarpedMode(pxConfig *config)
    1850 {
    1851     PS_ASSERT_PTR_NON_NULL(config, false);
    1852 
    1853     bool status = false;
    1854     psString warp_id = psMetadataLookupStr(&status, config->args, "-warp_id");
    1855     if (!status) {
    1856         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -warp_id");
    1857         return false;
    1858     }
    1859     if (!warp_id) {
    1860         psError(PS_ERR_UNKNOWN, true, "-warp_id is required");
    1861         return false;
    1862     }
    1863 
    1864     psString skycell_id = psMetadataLookupStr(&status, config->args, "-skycell_id");
    1865     if (!status) {
    1866         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -skycell_id");
    1867         return false;
    1868     }
    1869     if (!skycell_id) {
    1870         psError(PS_ERR_UNKNOWN, true, "-skycell_id is required");
    1871         return false;
    1872     }
    1873 
    1874     psString tess_id = psMetadataLookupStr(&status, config->args, "-tess_id");
    1875     if (!status) {
    1876         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -tess_id");
    1877         return false;
    1878     }
    1879     if (!tess_id) {
    1880         psError(PS_ERR_UNKNOWN, true, "-tess_id is required");
    1881         return false;
    1882     }
    1883 
    1884     psString uri = psMetadataLookupStr(&status, config->args, "-uri");
    1885     if (!status) {
    1886         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -uri");
    1887         return false;
    1888     }
    1889     if (!uri) {
    1890         psError(PS_ERR_UNKNOWN, true, "-uri is required");
    1891         return false;
    1892     }
    1893 
    1894     psString path_base = psMetadataLookupStr(&status, config->args, "-path_base");
    1895     if (!status) {
    1896         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -path_base");
    1897         return false;
    1898     }
    1899     if (!path_base) {
    1900         psError(PS_ERR_UNKNOWN, true, "-path_base is required");
    1901         return false;
    1902     }
    1903 
    1904     // optional
    1905     psF64 bg = psMetadataLookupF64(&status, config->args, "-bg");
    1906     if (!status) {
    1907         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg");
    1908         return false;
    1909     }
    1910 
    1911     psF64 bg_stdev = psMetadataLookupF64(&status, config->args, "-bg_stdev");
    1912     if (!status) {
    1913         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg_stdev");
    1914         return false;
    1915     }
    1916 
    1917     psF64 pixel_fill = psMetadataLookupF64(&status, config->args, "-pixel_fill");
    1918     if (!status) {
    1919         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -pixel_fill");
    1920         return false;
    1921     }
    1922 
    1923     // default values
    1924     psS16 code = psMetadataLookupS16(&status, config->args, "-code");
    1925     if (!status) {
    1926         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -code");
    1927         return false;
    1928     }
    1929 
    1930     // we don't want to insert the last skyfile in a run but then not mark the
    1931     // run as 'stop'
    1932     if (!psDBTransaction(config->dbh)) {
    1933         psError(PS_ERR_UNKNOWN, false, "database error");
    1934         return false;
    1935     }
    1936 
    1937     // XXX need to validate that this coresponds to an warpInputImfile
    1938     if (!warpSkyfileInsert(config->dbh,
    1939             (psS64)atoll(warp_id),
    1940             skycell_id,
    1941             tess_id,
    1942             uri,
    1943             path_base,
    1944             bg,
    1945             bg_stdev,
    1946             pixel_fill,
    1947             code
    1948         )) {
    1949         if (!psDBRollback(config->dbh)) {
    1950             psError(PS_ERR_UNKNOWN, false, "database error");
    1951         }
    1952         psError(PS_ERR_UNKNOWN, false, "database error");
    1953         return false;
    1954     }
    1955 
    1956     if (!warpCompletedRuns(config)) {
    1957         if (!psDBRollback(config->dbh)) {
    1958             psError(PS_ERR_UNKNOWN, false, "database error");
    1959         }
    1960         psError(PS_ERR_UNKNOWN, false, "database error");
    1961         return false;
    1962     }
    1963 
    1964     // point of no return
    1965     if (!psDBCommit(config->dbh)) {
    1966         psError(PS_ERR_UNKNOWN, false, "database error");
    1967         return false;
    1968     }
    1969 
    1970     return true;
    1971 }
    1972 
    1973 bool warpCompletedRuns(pxConfig *config)
    1974 {
    1975     PS_ASSERT_PTR_NON_NULL(config, false);
    1976 
    1977     // XXX this SQL has not been broken out to into seperate files as the MYSQL
    1978     // < 5 & MYSQL 5 versions need to be kept in sync
    1979 #if MYSQL5
    1980     // XXX at MySQL 4.1.21 (probably all of 4.1.x) chokes and dies on this
    1981     // statement as it thinks it is trying to select from the table being
    1982     // updated. The 4.1 manual says that nested sub-queries are explicited
    1983     // allowed to do this with update statements as a temporary table is
    1984     // created so that you are not actually selecting from the table you are
    1985     // modifying.
    1986     char *query =
    1987         "UPDATE warpRun\n"
    1988         "   SET warpRun.state = 'stop'\n"
    1989         " WHERE\n"
    1990         "   warpRun.warp_id =\n"
    1991         "   (SELECT DISTINCT\n"
    1992         "       warp_id\n"
    1993         "   FROM\n"
    1994         "       (SELECT DISTINCT\n"
    1995         "           warpRun.warp_id,\n"
    1996         "           warpSkyCellMap.warp_id as foo,\n"
    1997         "           warpSkyfile.warp_id as bar\n"
    1998         "       FROM warpRun\n"
    1999         "       JOIN warpSkyCellMap\n"
    2000         "           USING(warp_id)\n"
    2001         "       LEFT JOIN warpSkyfile\n"
    2002         "           USING(warp_id, skycell_id, tess_id)\n"
    2003         "       WHERE\n"
    2004         "           warpRun.state = 'run'\n"
    2005         "       GROUP BY\n"
    2006         "           warpRun.warp_id\n"
    2007         "       HAVING\n"
    2008         "       COUNT(warpSkyCellMap.warp_id) = COUNT(warpSkyfile.warp_id)\n"
    2009         "       ) as Foo\n"
    2010         "   )\n";
    2011 
    2012     if (!p_psDBRunQuery(config->dbh, query)) {
    2013         psError(PS_ERR_UNKNOWN, false, "database error");
    2014         return false;
    2015     }
    2016 #else // if MYSQL5
    2017 {
    2018     char *query =
    2019         "CREATE TEMPORARY TABLE finished\n"
    2020         " (warp_id INT, PRIMARY KEY(warp_id)) ENGINE=MEMORY\n";
    2021 
    2022     if (!p_psDBRunQuery(config->dbh, query)) {
    2023         psError(PS_ERR_UNKNOWN, false, "database error");
    2024         return false;
    2025     }
    2026 }
    2027 
    2028 {
    2029     char *query =
    2030         "INSERT INTO finished\n"
    2031         " SELECT\n"
    2032         "   warp_id\n"
    2033         " FROM\n"
    2034         "   (SELECT DISTINCT\n"
    2035         "       warpRun.warp_id,\n"
    2036         "       warpSkyCellMap.warp_id as foo,\n"
    2037         "       warpSkyfile.warp_id as bar\n"
    2038         "   FROM warpRun\n"
    2039         "   JOIN warpSkyCellMap\n"
    2040         "       USING(warp_id)\n"
    2041         "   LEFT JOIN warpSkyfile\n"
    2042         "       USING(warp_id, skycell_id, tess_id)\n"
    2043         "   WHERE\n"
    2044         "       warpRun.state = 'run'\n"
    2045         "   GROUP BY\n"
    2046         "       warpRun.warp_id\n"
    2047         "   HAVING\n"
    2048         "       COUNT(warpSkyCellMap.warp_id) = COUNT(warpSkyfile.warp_id)\n"
    2049         " ) as Foo \n";
    2050 
    2051     if (!p_psDBRunQuery(config->dbh, query)) {
    2052         psError(PS_ERR_UNKNOWN, false, "database error");
    2053         return false;
    2054     }
    2055 }
    2056 
    2057 {
    2058     char *query =
    2059         "UPDATE warpRun\n"
    2060         "   SET warpRun.state = 'stop'\n"
    2061         " WHERE\n"
    2062         "   warpRun.warp_id =\n"
    2063         "   (SELECT DISTINCT\n"
    2064         "       warp_id\n"
    2065         "   FROM finished\n"
    2066         "   )\n";
    2067 
    2068     if (!p_psDBRunQuery(config->dbh, query)) {
    2069         psError(PS_ERR_UNKNOWN, false, "database error");
    2070         return false;
    2071     }
    2072 }
    2073 #endif // if MYSQL5
    2074 
    2075     return true;
    2076 }
    2077 
    2078 static bool warpedMode(pxConfig *config)
    2079 {
    2080     PS_ASSERT_PTR_NON_NULL(config, false);
    2081 
    2082     bool status = false;
    2083     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    2084     if (!status) {
    2085         psError(PXTOOLS_ERR_PROG, false, "failed to lookup value for -limit");
    2086         return false;
    2087     }
    2088 
    2089     // find all rawImfiles matching the default query
    2090     psString query = pxDataGet("warptool_warped.sql");
    2091     if (!query) {
    2092         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    2093         return false;
    2094     }
    2095 
    2096     if (config->where) {
    2097         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "warpSkyfile");
    2098         psStringAppend(&query, " AND %s", whereClause);
    2099         psFree(whereClause);
    2100     }
    2101 
    2102     // treat limit == 0 as "no limit"
    2103     if (limit) {
    2104         psString limitString = psDBGenerateLimitSQL(limit);
    2105         psStringAppend(&query, " %s", limitString);
    2106         psFree(limitString);
    2107     }
    2108 
    2109     if (!p_psDBRunQuery(config->dbh, query)) {
    2110         psError(PS_ERR_UNKNOWN, false, "database error");
    2111         psFree(query);
    2112         return false;
    2113     }
    2114     psFree(query);
    2115 
    2116     psArray *output = p_psDBFetchResult(config->dbh);
    2117     if (!output) {
    2118         psErrorCode err = psErrorCodeLast();
    2119         switch (err) {
    2120             case PS_ERR_DB_CLIENT:
    2121                 psError(PXTOOLS_ERR_SYS, false, "database error");
    2122             case PS_ERR_DB_SERVER:
    2123                 psError(PXTOOLS_ERR_PROG, false, "database error");
    2124             default:
    2125                 psError(PXTOOLS_ERR_PROG, false, "unknown error");
    2126         }
    2127 
    2128         return false;
    2129     }
    2130     if (!psArrayLength(output)) {
    2131         psTrace("warptool", PS_LOG_INFO, "no rows found");
    2132         psFree(output);
    2133         return true;
    2134     }
    2135 
    2136     bool simple = false;
    2137     {
    2138         bool status = false;
    2139         simple = psMetadataLookupBool(&status, config->args, "-simple");
    2140         if (!status) {
    2141             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    2142             return false;
    2143         }
    2144     }
    2145 
    2146     if (psArrayLength(output)) {
    2147         if (!convertIdToStr(output)) {
    2148             psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    2149             psFree(output);
    2150             return false;
    2151         }
    2152 
    2153         // negative simple so the default is true
    2154         if (!ippdbPrintMetadatas(stdout, output, "warpSkyfile", !simple)) {
    2155             psError(PS_ERR_UNKNOWN, false, "failed to print array");
    2156             psFree(output);
    2157             return false;
    2158         }
    2159     }
    2160 
    2161     psFree(output);
    2162 
    2163     return true;
    2164 }
    2165 
    2166 
    2167 static bool revertwarpedMode(pxConfig *config)
    2168 {
    2169     PS_ASSERT_PTR_NON_NULL(config, false);
    2170 
    2171     psString query = pxDataGet("warptool_revertwarped.sql");
    2172     if (!query) {
    2173         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    2174         return false;
    2175     }
    2176 
    2177     if (config->where) {
    2178         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "warpSkyfile");
    2179         psStringAppend(&query, " AND %s", whereClause);
    2180         psFree(whereClause);
    2181     }
    2182 
    2183     if (!p_psDBRunQuery(config->dbh, query)) {
    2184         psError(PS_ERR_UNKNOWN, false, "database error");
    2185         psFree(query);
    2186         return false;
    2187     }
    2188     psFree(query);
    2189 
    2190     if (psDBAffectedRows(config->dbh) < 1) {
    2191         psError(PS_ERR_UNKNOWN, false, "should have affected atleast 1 row");
    2192         return false;
    2193     }
    2194 
    2195     return true;
    2196 }
    2197 #endif
    2198848
    2199849
    … …  
    2224874}
    2225875
    2226 
    2227 #if 0
    2228 static bool isValidMode(pxConfig *config, const char *mode)
    2229 {
    2230     PS_ASSERT_PTR_NON_NULL(config, false);
    2231     PS_ASSERT_PTR_NON_NULL(mode, false);
    2232 
    2233     // check that state is a valid string value
    2234     if (!(
    2235             (strncmp(mode, "warp", 5) == 0)
    2236             || (strncmp(mode, "diff", 5) == 0)
    2237             || (strncmp(mode, "stack", 6) == 0)
    2238             || (strncmp(mode, "magic", 6) == 0)
    2239         )
    2240     ) {
    2241         psError(PS_ERR_UNKNOWN, false,
    2242                 "invalid warpRun mode: %s", mode);
    2243         return false;
    2244     }
    2245 
    2246     return true;
    2247 }
    2248 #endif
    2249 
    2250876static bool parseAndInsertNodeDeps(pxConfig *config, psS64 magic_id, const char *filename)
    2251877{

  • trunk/ippTools/src/magictoolConfig.c

    r15501 r16170  
    4545    }
    4646
    47     psTime *time = psTimeGetNow(PS_TIME_TAI);
    48     psString now = psTimeToISO(time);
    49     psFree(time);
     47    psTime *now = psTimeGetNow(PS_TIME_TAI);
    5048
    5149    // -queue
    … …  
    6058    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-dvodb", 0,
    6159            "define dvodb", NULL);
    62     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-registered",  0,
     60    psMetadataAddTime(definerunArgs, PS_LIST_TAIL, "-registered",  0,
    6361            "time detrend run was registered", now);
    6462    psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-simple",  0,
    … …  
    162160    psMetadata *modes   = psMetadataAlloc();
    163161
    164     PXTOOL_ADD_MODE("-queue",           "", MAGICTOOL_MODE_QUEUE,           queueArgs);
    165     PXTOOL_ADD_MODE("-definerun",       "", MAGICTOOL_MODE_DEFINERUN,       definerunArgs);
    166     PXTOOL_ADD_MODE("-updaterun",       "", MAGICTOOL_MODE_UPDATERUN,       updaterunArgs);
    167     PXTOOL_ADD_MODE("-addinputskyfile", "", MAGICTOOL_MODE_ADDINPUTSKYFILE, addinputskyfileArgs);
    168     PXTOOL_ADD_MODE("-inputskyfile",    "", MAGICTOOL_MODE_INPUTSKYFILE,    inputskyfileArgs);
    169     PXTOOL_ADD_MODE("-inputtree",       "", MAGICTOOL_MODE_INPUTTREE,       inputtreeArgs);
    170     PXTOOL_ADD_MODE("-toprocess",       "", MAGICTOOL_MODE_TOPROCESS,       toprocessArgs);
    171     PXTOOL_ADD_MODE("-addresult",       "", MAGICTOOL_MODE_ADDRESULT,       addresultArgs);
    172     PXTOOL_ADD_MODE("-tomask",          "", MAGICTOOL_MODE_TOMASK,          tomaskArgs);
    173     PXTOOL_ADD_MODE("-addmask",         "", MAGICTOOL_MODE_ADDMASK,         addmaskArgs);
    174     PXTOOL_ADD_MODE("-toskyfilemask",   "", MAGICTOOL_MODE_TOSKYFILEMASK,   toskyfilemaskArgs);
    175     PXTOOL_ADD_MODE("-addskyfilemask",  "", MAGICTOOL_MODE_ADDSKYFILEMASK,  addskyfilemaskArgs);
     162    PXOPT_ADD_MODE("-queue",           "", MAGICTOOL_MODE_QUEUE,           queueArgs);
     163    PXOPT_ADD_MODE("-definerun",       "", MAGICTOOL_MODE_DEFINERUN,       definerunArgs);
     164    PXOPT_ADD_MODE("-updaterun",       "", MAGICTOOL_MODE_UPDATERUN,       updaterunArgs);
     165    PXOPT_ADD_MODE("-addinputskyfile", "", MAGICTOOL_MODE_ADDINPUTSKYFILE, addinputskyfileArgs);
     166    PXOPT_ADD_MODE("-inputskyfile",    "", MAGICTOOL_MODE_INPUTSKYFILE,    inputskyfileArgs);
     167    PXOPT_ADD_MODE("-inputtree",       "", MAGICTOOL_MODE_INPUTTREE,       inputtreeArgs);
     168    PXOPT_ADD_MODE("-toprocess",       "", MAGICTOOL_MODE_TOPROCESS,       toprocessArgs);
     169    PXOPT_ADD_MODE("-addresult",       "", MAGICTOOL_MODE_ADDRESULT,       addresultArgs);
     170    PXOPT_ADD_MODE("-tomask",          "", MAGICTOOL_MODE_TOMASK,          tomaskArgs);
     171    PXOPT_ADD_MODE("-addmask",         "", MAGICTOOL_MODE_ADDMASK,         addmaskArgs);
     172    PXOPT_ADD_MODE("-toskyfilemask",   "", MAGICTOOL_MODE_TOSKYFILEMASK,   toskyfilemaskArgs);
     173    PXOPT_ADD_MODE("-addskyfilemask",  "", MAGICTOOL_MODE_ADDSKYFILEMASK,  addskyfilemaskArgs);
    176174
    177175    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {

  • trunk/ippTools/src/pxcam.c

    r14023 r16170  
    5858bool pxcamQueueByChipID(pxConfig *config,
    5959                    psS64 chip_id,
    60                     psString workdir,
    61                     psString label,
    62                     psString recipe,
    63                     psString expgroup,
    64                     psString dvodb)
     60                    char *workdir,
     61                    char *label,
     62                    char *recipe,
     63                    char *expgroup,
     64                    char *dvodb,
     65                    char *tess_id,
     66                    char *end_stage)
    6567{
    6668    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    8890                expgroup ? expgroup : "NULL",
    8991                dvodb    ? dvodb    : "NULL",
     92                tess_id  ? tess_id  : "NULL",
     93                end_stage ? end_stage : "NULL",
    9094                (long long)chip_id
    9195    )) {

  • trunk/ippTools/src/pxcam.h

    r14018 r16170  
    2929bool pxcamQueueByChipID(pxConfig *config,
    3030                        psS64 chip_id,
    31                         psString workdir,
    32                         psString label,
    33                         psString recipe,
    34                         psString expgroup,
    35                         psString dvodb);
     31                        char *workdir,
     32                        char *label,
     33                        char *recipe,
     34                        char *expgroup,
     35                        char *dvodb,
     36                        char *tess_id,
     37                        char *end_stage);
    3638
    3739#endif // PXCAM_H

  • trunk/ippTools/src/pxchip.c

    r15614 r16170  
    5858psS64 pxchipQueueByExpTag(pxConfig *config,
    5959                         psS64 exp_id,
    60                          psString workdir,
    61                          psString label,
    62                          psString reduction,
    63                          psString expgroup,
    64                          psString dvodb)
     60                         char *workdir,
     61                         char *label,
     62                         char *reduction,
     63                         char *expgroup,
     64                         char *dvodb,
     65                         char *tess_id,
     66                         char *end_stage)
    6567{
    6668    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    7678            reduction,
    7779            expgroup,
    78             dvodb)
     80            dvodb,
     81            tess_id,
     82            end_stage)
    7983    ) {
    8084        psError(PS_ERR_UNKNOWN, false, "database error");

  • trunk/ippTools/src/pxchip.h

    r15580 r16170  
    2929psS64 pxchipQueueByExpTag(pxConfig *config,
    3030                         psS64 exp_id,
    31                          psString workdir,
    32                          psString label,
    33                          psString reduction,
    34                          psString expgroup,
    35                          psString dvodb);
     31                         char *workdir,
     32                         char *label,
     33                         char *reduction,
     34                         char *expgroup,
     35                         char *dvodb,
     36                         char *tess_id,
     37                         char *end_stage);
    3638
    3739#endif // PXCHIP_H

  • trunk/ippTools/src/pxconfig.c

    r14122 r16170  
    197197                goto ARG_REQUIRED;
    198198            case PS_DATA_STRING:
     199            case PS_DATA_TIME:
    199200            case PS_DATA_METADATA:
    200201                if (item->data.V) {

  • trunk/ippTools/src/pxinject.c

    r14132 r16170  
    7979    PS_ASSERT_PTR_NON_NULL(config, false);
    8080
    81     bool status = false;
    82     psString tmp_exp_name = psMetadataLookupStr(&status, config->args, "-tmp_exp_name");
    83     if (!status) {
    84         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -tmp_exp_name");
    85         return false;
    86     }
    87     if (!tmp_exp_name) {
    88         psError(PS_ERR_UNKNOWN, true, "-tmp_exp_name is required");
    89         return false;
    90     }
    91     psString tmp_camera = psMetadataLookupStr(&status, config->args, "-tmp_inst");
    92     if (!status) {
    93         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -tmp_inst");
    94         return false;
    95     }
    96     if (!tmp_camera) {
    97         psError(PS_ERR_UNKNOWN, true, "-tmp_inst is required");
    98         return false;
    99     }
    100     psString tmp_telescope = psMetadataLookupStr(&status, config->args, "-tmp_telescope");
    101     if (!status) {
    102         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -tmp_telescope");
    103         return false;
    104     }
    105     if (!tmp_telescope) {
    106         psError(PS_ERR_UNKNOWN, true, "-tmp_telescope is required");
    107         return false;
    108     }
    109 
    110     psString workdir = psMetadataLookupStr(&status, config->args, "-workdir");
    111     if (!status) {
    112         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -workdir");
    113         return false;
    114     }
    115     if (!workdir) {
    116         psError(PS_ERR_UNKNOWN, true, "-workdir is required");
    117         return false;
    118     }
    119 
    120     psString reduction = psMetadataLookupStr(&status, config->args, "-reduction");
    121     if (!status) {
    122         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -reduction");
    123         return false;
    124     }
     81    PXOPT_LOOKUP_STR(tmp_exp_name, config->args, "-tmp_exp_name", true, false);
     82    PXOPT_LOOKUP_STR(tmp_camera, config->args, "-tmp_inst", true, false);
     83    PXOPT_LOOKUP_STR(tmp_telescope, config->args, "-tmp_telescope", true, false);
     84    PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false);
     85    PXOPT_LOOKUP_STR(reduction, config->args, "-reduction", false, false);
     86    PXOPT_LOOKUP_STR(dvodb, config->args, "-dvodb", false, false);
     87    PXOPT_LOOKUP_STR(tess_id, config->args, "-tess_id", false, false);
     88    PXOPT_LOOKUP_STR(end_stage, config->args, "-end_stage", false, false);
     89    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    12590
    12691    if (!newExpInsert(config->dbh,
    … …  
    13297                workdir,
    13398                "dirty",
    134                 reduction
     99                reduction,
     100                dvodb,
     101                tess_id,
     102                end_stage
    135103            )
    136104        ) {
    … …  
    150118    psFree(exp_id);
    151119
    152     bool simple = false;
    153     {
    154         bool status = false;
    155         simple = psMetadataLookupBool(&status, config->args, "-simple");
    156         if (!status) {
    157             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    158             psFree(md);
    159             return false;
    160         }
    161     }
    162 
    163120    // negate simple so the default is true
    164121    if (!ippdbPrintMetadata(stdout, md, !simple)) {
    … …  
    177134    PS_ASSERT_PTR_NON_NULL(config, false);
    178135
    179     bool status = false;
    180     psString exp_id = psMetadataLookupStr(&status, config->args, "-exp_id");
    181     if (!status) {
    182         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_id");
    183         return false;
    184     }
    185     if (!exp_id) {
    186         psError(PS_ERR_UNKNOWN, true, "-exp_id is required");
    187         return false;
    188     }
    189 #if 0
    190     psString class = psMetadataLookupStr(&status, config->args, "-class");
    191     if (!status) {
    192         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -class");
    193         return false;
    194     }
    195     if (!class) {
    196         psError(PS_ERR_UNKNOWN, true, "-class is required");
    197         return false;
    198     }
    199 #endif
    200     psString tmp_class_id = psMetadataLookupStr(&status, config->args, "-tmp_class_id");
    201     if (!status) {
    202         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -tmp_class_id");
    203         return false;
    204     }
    205     if (!tmp_class_id) {
    206         psError(PS_ERR_UNKNOWN, true, "-tmp_class_id is required");
    207         return false;
    208     }
    209     psString uri = psMetadataLookupStr(&status, config->args, "-uri");
    210     if (!status) {
    211         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -uri");
    212         return false;
    213     }
    214     if (!uri) {
    215         psError(PS_ERR_UNKNOWN, true, "-uri is required");
    216         return false;
    217     }
     136    PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", true, false);
     137    PXOPT_LOOKUP_STR(tmp_class_id, config->args, "-tmp_class_id", true, false);
     138    PXOPT_LOOKUP_STR(uri, config->args, "-uri", true, false);
    218139
    219140    // insert with error flag state set to 0 (no errors)
    … …  
    231152    PS_ASSERT_PTR_NON_NULL(config, false);
    232153
    233     bool status = false;
    234     psString exp_id = psMetadataLookupStr(&status, config->args, "-exp_id");
    235     if (!status) {
    236         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_id");
    237         return false;
    238     }
    239     if (!exp_id) {
    240         psError(PS_ERR_UNKNOWN, true, "-exp_id is required");
    241         return false;
    242     }
    243 
    244     psString state = psMetadataLookupStr(&status, config->args, "-state");
    245     if (!status) {
    246         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -state");
    247         return false;
    248     }
    249     if (!state) {
    250         psError(PS_ERR_UNKNOWN, true, "-state is required");
    251         return false;
    252     }
     154    PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", true, false);
     155    PXOPT_LOOKUP_STR(state, config->args, "-state", true, false);
    253156
    254157    if (state) {

  • trunk/ippTools/src/pxinjectConfig.c

    r14132 r16170  
    5555    psMetadataAddStr(newExpArgs, PS_LIST_TAIL, "-reduction",  0,
    5656            "define reduction class", NULL);
     57    psMetadataAddStr(newExpArgs, PS_LIST_TAIL, "-dvodb",  0,
     58            "define the dvodb for the next processing step", NULL);
     59    psMetadataAddStr(newExpArgs, PS_LIST_TAIL, "-tess_id",  0,
     60            "define the tess_id for the next processing step", NULL);
     61    psMetadataAddStr(newExpArgs, PS_LIST_TAIL, "-end_stage",  0,
     62            "define the end goal processing step", NULL);
    5763    psMetadataAddBool(newExpArgs, PS_LIST_TAIL, "-simple",  0,
    5864            "use the simple output format", false);
    … …  
    7884    psMetadata *modes = psMetadataAlloc();
    7985
    80     PXTOOL_ADD_MODE("-newExp",      "", PXINJECT_MODE_NEWEXP,       newExpArgs);
    81     PXTOOL_ADD_MODE("-newImfile",   "", PXINJECT_MODE_NEWIMFILE,    newImfileArgs);
    82     PXTOOL_ADD_MODE("-updatenewExp",   "", PXINJECT_MODE_UPDATENEWEXP,    updatenewExpArgs);
     86    PXOPT_ADD_MODE("-newExp",      "", PXINJECT_MODE_NEWEXP,       newExpArgs);
     87    PXOPT_ADD_MODE("-newImfile",   "", PXINJECT_MODE_NEWIMFILE,    newImfileArgs);
     88    PXOPT_ADD_MODE("-updatenewExp",   "", PXINJECT_MODE_UPDATENEWEXP,    updatenewExpArgs);
    8389
    8490    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {

  • trunk/ippTools/src/pxtools.h

    r14490 r16170  
    5151bool pxGetOptions(FILE *stream, int argc, char **argv, pxConfig *config, psMetadata *modes, psMetadata *argSets);
    5252
    53 #define PXTOOL_ADD_MODE(option, comment, modeval, argset) \
     53#define PXOPT_ADD_MODE(option, comment, modeval, argset) \
    5454{ \
    5555    if (!psMetadataAddMetadata(argSets, PS_LIST_TAIL, option, 0, comment, argset)) {;\
    … …  
    6363}
    6464
     65#define PXOPT_LOOKUP_STR(var, md, key, required, ret) \
     66psString var; \
     67{ \
     68    bool status; \
     69 \
     70    var = psMetadataLookupStr(&status, md, key); \
     71    if (!status) { \
     72        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for %s", key); \
     73        return ret; \
     74    } \
     75 \
     76    if (required && (!var)) { \
     77        psError(PS_ERR_UNKNOWN, true, "%s is required", key); \
     78        return ret; \
     79    } \
     80}
     81
     82#define PXOPT_LOOKUP_F(var, md, key, type, required, ret) \
     83ps##type var; \
     84{ \
     85    bool status; \
     86 \
     87    var = psMetadataLookup##type(&status, md, key); \
     88    if (!status) { \
     89        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for %s", key); \
     90        return ret; \
     91    } \
     92 \
     93    if (required && isnan(var)) { \
     94        psError(PS_ERR_UNKNOWN, true, "%s is required", key); \
     95        return ret; \
     96    } \
     97}
     98
     99#define PXOPT_LOOKUP_F32(var, md, key, required, ret) \
     100    PXOPT_LOOKUP_F(var, md, key, F64, required, ret)
     101
     102#define PXOPT_LOOKUP_F64(var, md, key, required, ret) \
     103    PXOPT_LOOKUP_F(var, md, key, F64, required, ret)
     104
     105#define PXOPT_LOOKUP_PRIMITIVE(var, md, key, type, suffix, max, required, ret) \
     106type var; \
     107{ \
     108    bool status; \
     109 \
     110    var = psMetadataLookup##suffix(&status, md, key); \
     111    if (!status) { \
     112        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for %s", key); \
     113        return ret; \
     114    } \
     115 \
     116    if (required && (var == max)) { \
     117        psError(PS_ERR_UNKNOWN, true, "%s is required", key); \
     118        return ret; \
     119    } \
     120}
     121
     122#define PXOPT_LOOKUP_S16(var, md, key, required, ret) \
     123    PXOPT_LOOKUP_PRIMITIVE(var, md, key, psS16, S16, INT16_MAX, required, ret)
     124
     125#define PXOPT_LOOKUP_S32(var, md, key, required, ret) \
     126    PXOPT_LOOKUP_PRIMITIVE(var, md, key, psS32, S32, INT32_MAX, required, ret)
     127
     128#define PXOPT_LOOKUP_S64(var, md, key, required, ret) \
     129    PXOPT_LOOKUP_PRIMITIVE(var, md, key, psS64, S64, INT64_MAX, required, ret)
     130
     131#define PXOPT_LOOKUP_U16(var, md, key, required, ret) \
     132    PXOPT_LOOKUP_PRIMITIVE(var, md, key, psU16, U16, UINT16_MAX, required, ret)
     133
     134#define PXOPT_LOOKUP_U32(var, md, key, required, ret) \
     135    PXOPT_LOOKUP_PRIMITIVE(var, md, key, psU32, U32, UINT32_MAX, required, ret)
     136
     137#define PXOPT_LOOKUP_U64(var, md, key, required, ret) \
     138    PXOPT_LOOKUP_PRIMITIVE(var, md, key, psU64, U64, UINT64_MAX, required, ret)
     139
     140#define PXOPT_LOOKUP_TIME(var, md, key, required, ret) \
     141psTime *var; \
     142{ \
     143    bool status; \
     144 \
     145    var = psMetadataLookupTime(&status, md, key); \
     146    if (!status) { \
     147        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for %s", key); \
     148        return ret; \
     149    } \
     150 \
     151    if (required && (!var)) { \
     152        psError(PS_ERR_UNKNOWN, true, "%s is required", key); \
     153        return ret; \
     154    } \
     155}
     156
     157#define PXOPT_LOOKUP_BOOL(var, md, key, ret) \
     158bool var; \
     159{ \
     160    bool status; \
     161 \
     162    var = psMetadataLookupBool(&status, md, key); \
     163    if (!status) { \
     164        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for %s", key); \
     165        return ret; \
     166    } \
     167}
     168
     169// XXX the PXOPT_COPY_* macros free 'to' on error
     170
     171#define PXOPT_COPY_PRIMITIVE(from, to, type, suffix, oldname, newname, comment) \
     172{ \
     173    bool status = false; \
     174    type var = psMetadataLookup##suffix(&status, from, oldname); \
     175    if (!status) { \
     176        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for " oldname); \
     177        return false; \
     178    } \
     179    if (!psMetadataAdd##suffix(to, PS_LIST_TAIL, newname, PS_META_DUPLICATE_OK, comment, var)) { \
     180        psError(PS_ERR_UNKNOWN, false, "failed to add item " newname); \
     181        psFree(to); \
     182        return false; \
     183    } \
     184}
     185
     186#define PXOPT_COPY_V(from, to, type, suffix, oldname, newname, comment) \
     187{ \
     188    bool status = false; \
     189    type var = psMetadataLookup##suffix(&status, from, oldname); \
     190    if (!status) { \
     191        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for " oldname); \
     192        return false; \
     193    } \
     194    if (var) { \
     195        if (!psMetadataAdd##suffix(to, PS_LIST_TAIL, newname, PS_META_DUPLICATE_OK, comment, var)) { \
     196            psError(PS_ERR_UNKNOWN, false, "failed to add item " newname); \
     197            psFree(to); \
     198            return false; \
     199        } \
     200    }\
     201}
     202
     203#define PXOPT_COPY_F(from, to, type, oldname, newname, comment) \
     204{ \
     205    bool status = false; \
     206    ps##type var = psMetadataLookup##type(&status, from, oldname); \
     207    if (!status) { \
     208        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for " oldname); \
     209        return false; \
     210    } \
     211    if (!isnan(var)) { \
     212        if (!psMetadataAdd##type(to, PS_LIST_TAIL, newname, PS_META_DUPLICATE_OK, comment, var)) { \
     213            psError(PS_ERR_UNKNOWN, false, "failed to add item " newname); \
     214            psFree(to); \
     215            return false; \
     216        } \
     217    } \
     218}
     219
     220#define PXOPT_COPY_F32(from, to, oldname, newname, comment) \
     221  PXOPT_COPY_F(from, to, F32, oldname, newname, comment)
     222
     223#define PXOPT_COPY_F64(from, to, oldname, newname, comment) \
     224  PXOPT_COPY_F(from, to, F64, oldname, newname, comment)
     225
     226#define PXOPT_COPY_TIME(from, to, oldname, newname, comment) \
     227  PXOPT_COPY_V(from, to, psTime *, Time, oldname, newname, comment)
     228
     229#define PXOPT_COPY_STR(from, to, oldname, newname, comment) \
     230  PXOPT_COPY_V(from, to, psString, Str, oldname, newname, comment)
     231
     232#define PXOPT_COPY_S16(from, to, oldname, newname, comment) \
     233  PXOPT_COPY_PRIMITIVE(from, to, psS16, S16, oldname, newname, comment)
     234
     235#define PXOPT_COPY_S32(from, to, oldname, newname, comment) \
     236  PXOPT_COPY_PRIMITIVE(from, to, psS32, S32, oldname, newname, comment)
     237
     238#define PXOPT_COPY_S64(from, to, oldname, newname, comment) \
     239  PXOPT_COPY_PRIMITIVE(from, to, psS64, S64, oldname, newname, comment)
     240
     241#define PXOPT_COPY_U16(from, to, oldname, newname, comment) \
     242  PXOPT_COPY_PRIMITIVE(from, to, psU16, U16, oldname, newname, comment)
     243
     244#define PXOPT_COPY_U32(from, to, oldname, newname, comment) \
     245  PXOPT_COPY_PRIMITIVE(from, to, psU32, U32, oldname, newname, comment)
     246
     247#define PXOPT_COPY_U64(from, to, oldname, newname, comment) \
     248  PXOPT_COPY_PRIMITIVE(from, to, psU64, U64, oldname, newname, comment)
     249
    65250#endif // PXTOOLS_H

  • trunk/ippTools/src/pzgetexp.c

    r15091 r16170  
    6969    PS_ASSERT_PTR_NON_NULL(config, NULL);
    7070
    71     bool status = false;
    72     psString camera = psMetadataLookupStr(&status, config->args, "-inst");
    73     if (!status) {
    74         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -inst");
    75         return false;
    76     }
    77     if (!camera) {
    78         psError(PS_ERR_UNKNOWN, true, "-inst is required");
    79         return false;
    80     }
    81 
    82     psString telescope = psMetadataLookupStr(&status, config->args, "-telescope");
    83     if (!status) {
    84         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -telescope");
    85         return false;
    86     }
    87     if (!telescope) {
    88         psError(PS_ERR_UNKNOWN, true, "-telescope is required");
    89         return false;
    90     }
     71    // required
     72    PXOPT_LOOKUP_STR(camera, config->args, "-inst", true, false);
     73    PXOPT_LOOKUP_STR(telescope, config->args, "-telescope", true, false);
     74    PXOPT_LOOKUP_STR(uri, config->args, "-uri", true, false);
    9175
    9276    // find last fileset/exp_name (if we have one)
    … …  
    119103    // invoke dsproductls
    120104    // dsproductls --uri <> --last_fileset <>
    121     psString uri = psMetadataLookupStr(&status, config->args, "-uri");
    122105    psString cmd = NULL;
    123106    if (haveLastFileSet) {
    … …  
    275258    // these are constants for all records parsed -- look them up before we do
    276259    // any work
    277     bool status = false;
    278     char *camera = psMetadataLookupStr(&status, config->args, "-inst");
    279     if (!status) {
    280         psError(PS_ERR_UNKNOWN, false, "failed to lookup item '-inst'");
    281         return NULL;
    282     }
    283     char *telescope = psMetadataLookupStr(&status, config->args, "-telescope");
    284     if (!status) {
    285         psError(PS_ERR_UNKNOWN, false, "failed to lookup item '-telescope'");
    286         return NULL;
    287     }
     260    // required
     261    PXOPT_LOOKUP_STR(camera, config->args, "-inst", true, false);
     262    PXOPT_LOOKUP_STR(telescope, config->args, "-telescope", true, false);
    288263
    289264    // split the string into lines

  • trunk/ippTools/src/pzgetimfiles.c

    r15287 r16170  
    22 * pzgetimfiles.c
    33 *
    4  * Copyright (C) 2006  Joshua Hoblitt
     4 * Copyright (C) 2006-2008  Joshua Hoblitt
    55 *
    66 * This program is free software; you can redistribute it and/or modify it
    … …  
    7070    PS_ASSERT_PTR_NON_NULL(config, NULL);
    7171
    72     bool status = false;
    73     psString uri = psMetadataLookupStr(&status, config->args, "-uri");
    74     if (!status) {
    75         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -uri");
    76         return false;
    77     }
    78     if (!uri) {
    79         psError(PS_ERR_UNKNOWN, true, "-uri is required");
    80         return false;
    81     }
    82 
    83     psString filesetid = psMetadataLookupStr(&status, config->args, "-filesetid");
    84     if (!status) {
    85         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -filesetid");
    86         return false;
    87     }
    88     if (!filesetid) {
    89         psError(PS_ERR_UNKNOWN, true, "-filesetid is required");
    90         return false;
    91     }
    92 
    93     psString camera = psMetadataLookupStr(&status, config->args, "-inst");
    94     if (!status) {
    95         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -inst");
    96         return NULL;
    97     }
    98     if (!camera) {
    99         psError(PS_ERR_UNKNOWN, true, "-inst is required");
    100         return NULL;
    101     }
    102 
    103     psString telescope = psMetadataLookupStr(&status, config->args, "-telescope");
    104     if (!status) {
    105         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -telescope");
    106         return NULL;
    107     }
    108     if (!telescope) {
    109         psError(PS_ERR_UNKNOWN, true, "-telescope is required");
    110         return NULL;
    111     }
     72    // required
     73    PXOPT_LOOKUP_STR(uri, config->args, "-uri", true, false);
     74    PXOPT_LOOKUP_STR(filesetid, config->args, "-filesetid", true, false);
     75    PXOPT_LOOKUP_STR(camera, config->args, "-inst", true, false);
     76    PXOPT_LOOKUP_STR(telescope, config->args, "-telescope", true, false);
    11277
    11378    // invoke dsfilesetls
    … …  
    429394    // these are constants for all records parsed -- look them up before we do
    430395    // any work
    431     bool status = false;
    432     psString exp_name = psMetadataLookupStr(&status, config->args, "-filesetid");
    433     if (!status) {
    434         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for '-filesetid'");
    435         return NULL;
    436     }
    437     if (!exp_name) {
    438         psError(PS_ERR_UNKNOWN, true, "-filesetid is required");
    439         return NULL;
    440     }
    441 
    442     psString camera = psMetadataLookupStr(&status, config->args, "-inst");
    443     if (!status) {
    444         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -inst");
    445         return NULL;
    446     }
    447     if (!camera) {
    448         psError(PS_ERR_UNKNOWN, true, "-inst is required");
    449         return NULL;
    450     }
    451 
    452     psString telescope = psMetadataLookupStr(&status, config->args, "-telescope");
    453     if (!status) {
    454         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -telescope");
    455         return NULL;
    456     }
    457     if (!telescope) {
    458         psError(PS_ERR_UNKNOWN, true, "-telescope is required");
    459         return NULL;
    460     }
     396    PXOPT_LOOKUP_STR(exp_name, config->args, "-filesetid", true, false);
     397    PXOPT_LOOKUP_STR(camera, config->args, "-inst", true, false);
     398    PXOPT_LOOKUP_STR(telescope, config->args, "-telescope", true, false);
    461399
    462400    // split the string into lines

  • trunk/ippTools/src/pztool.c

    r15293 r16170  
    9292    PS_ASSERT_PTR_NON_NULL(config, false);
    9393
    94     bool status = false;
    95     psString camera = psMetadataLookupStr(&status, config->args, "-inst");
    96     if (!status) {
    97         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -inst");
    98         return false;
    99     }
    100     if (!camera) {
    101         psError(PS_ERR_UNKNOWN, true, "-inst is required");
    102         return false;
    103     }
    104 
    105     psString telescope = psMetadataLookupStr(&status, config->args, "-telescope");
    106     if (!status) {
    107         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -telescope");
    108         return false;
    109     }
    110     if (!telescope) {
    111         psError(PS_ERR_UNKNOWN, true, "-telescope is required");
    112         return false;
    113     }
    114 
    115     psString uri = psMetadataLookupStr(&status, config->args, "-uri");
    116     if (!status) {
    117         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -uri");
    118         return false;
    119     }
    120     if (!uri) {
    121         psError(PS_ERR_UNKNOWN, true, "-uri is required");
    122         return false;
    123     }
     94    // required
     95    PXOPT_LOOKUP_STR(camera, config->args, "-inst", true, false);
     96    PXOPT_LOOKUP_STR(telescope, config->args, "-telescope", true, false);
     97    PXOPT_LOOKUP_STR(uri, config->args, "-uri", true, false);
    12498
    12599    if (!pzDataStoreInsert(config->dbh,
    … …  
    139113    PS_ASSERT_PTR_NON_NULL(config, false);
    140114
     115    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     116
    141117    if (!p_psDBRunQuery(config->dbh, "SELECT * FROM pzDataStore")) {
    142118        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    153129        psFree(output);
    154130        return true;
    155     }
    156 
    157     bool simple = false;
    158     {
    159         bool status = false;
    160         simple = psMetadataLookupBool(&status, config->args, "-simple");
    161         if (!status) {
    162             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    163             return false;
    164         }
    165131    }
    166132
    … …  
    180146{
    181147    PS_ASSERT_PTR_NON_NULL(config, false);
     148
     149    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    182150
    183151    psString query = psStringCopy("SELECT * FROM summitExp");
    … …  
    207175    }
    208176
    209     bool simple = false;
    210     {
    211         bool status = false;
    212         simple = psMetadataLookupBool(&status, config->args, "-simple");
    213         if (!status) {
    214             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    215             return false;
    216         }
    217     }
    218 
    219177    // negative simple so the default is true
    220178    if (!ippdbPrintMetadatas(stdout, output, "summitExp", !simple)) {
    … …  
    233191    PS_ASSERT_PTR_NON_NULL(config, false);
    234192
    235     bool status = false;
    236     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    237     if (!status) {
    238         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
    239         return false;
    240     }
     193    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     194    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    241195
    242196    psString query = psStringCopy(
    … …  
    279233    }
    280234
    281     bool simple = false;
    282     {
    283         bool status = false;
    284         simple = psMetadataLookupBool(&status, config->args, "-simple");
    285         if (!status) {
    286             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    287             psFree(output);
    288             return false;
    289         }
    290     }
    291 
    292235    // negative simple so the default is true
    293236    if (!ippdbPrintMetadatas(stdout, output, "pzPendingExp", !simple)) {
    … …  
    306249    PS_ASSERT_PTR_NON_NULL(config, false);
    307250
    308     bool status = false;
    309     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    310     if (!status) {
    311         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
    312         return false;
    313     }
     251    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     252    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    314253
    315254    psArray *cameras = pzGetPendingCameras(config);
    … …  
    330269        }
    331270
     271        bool status;
    332272        psString camera = psMetadataLookupStr(&status, cameras->data[i], "camera");
    333273        psStringAppend(&query, " WHERE camera = \"%s\"", camera);
    … …  
    380320    psFree(cameraImfiles);
    381321
    382     bool simple = false;
    383     {
    384         bool status = false;
    385         simple = psMetadataLookupBool(&status, config->args, "-simple");
    386         if (!status) {
    387             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    388             psFree(output);
    389             return false;
    390         }
    391     }
    392 
    393322    // negative simple so the default is true
    394323    if (!ippdbPrintMetadatas(stdout, output, "pzPendingImfile", !simple)) {
    … …  
    407336    PS_ASSERT_PTR_NON_NULL(config, false);
    408337
    409     bool status = false;
    410     psString exp_name = psMetadataLookupStr(&status, config->args, "-exp_name");
    411     if (!status) {
    412         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_name");
    413         return false;
    414     }
    415     if (!exp_name) {
    416         psError(PS_ERR_UNKNOWN, true, "-exp_name is required");
    417         return false;
    418     }
    419 
    420     psString camera = psMetadataLookupStr(&status, config->args, "-inst");
    421     if (!status) {
    422         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -inst");
    423         return NULL;
    424     }
    425     if (!camera) {
    426         psError(PS_ERR_UNKNOWN, true, "-inst is required");
    427         return NULL;
    428     }
    429 
    430     psString telescope = psMetadataLookupStr(&status, config->args, "-telescope");
    431     if (!status) {
    432         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -telescope");
    433         return NULL;
    434     }
    435     if (!telescope) {
    436         psError(PS_ERR_UNKNOWN, true, "-telescope is required");
    437         return NULL;
    438     }
    439 
    440     psString class = psMetadataLookupStr(&status, config->args, "-class");
    441     if (!status) {
    442         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -class");
    443         return NULL;
    444     }
    445     if (!class) {
    446         psError(PS_ERR_UNKNOWN, true, "-class is required");
    447         return NULL;
    448     }
    449 
    450     psString class_id = psMetadataLookupStr(&status, config->args, "-class_id");
    451     if (!status) {
    452         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -class_id");
    453         return NULL;
    454     }
    455     if (!class_id) {
    456         psError(PS_ERR_UNKNOWN, true, "-class_id is required");
    457         return NULL;
    458     }
    459 
    460     psString uri = psMetadataLookupStr(&status, config->args, "-uri");
    461     if (!status) {
    462         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -uri");
    463         return false;
    464     }
    465     if (!uri) {
    466         psError(PS_ERR_UNKNOWN, true, "-uri is required");
    467         return false;
    468     }
     338    // required
     339    PXOPT_LOOKUP_STR(exp_name, config->args, "-exp_name", true, false);
     340    PXOPT_LOOKUP_STR(camera, config->args, "-inst", true, false);
     341    PXOPT_LOOKUP_STR(telescope, config->args, "-telescope", true, false);
     342    PXOPT_LOOKUP_STR(class, config->args, "-class", true, false);
     343    PXOPT_LOOKUP_STR(class_id, config->args, "-class_id", true, false);
     344    PXOPT_LOOKUP_STR(uri, config->args, "-uri", true, false);
    469345
    470346    // need to know exp_name, camera, telescope, class, class_id (to find the
    … …  
    476352        return false;
    477353    }
    478  
    479354
    480355    // cp the imfile into pzDoneImfile
    … …  
    568443    PS_ASSERT_PTR_NON_NULL(config, false);
    569444
     445    // XXX this is an ugly hack!
     446    // we are passing exp level info to a imfile level mode (-copydone)
     447    // these options are thrown away unless we just -copydone'd the last imfile
     448    // in an exp. 
     449    // This function MUST NOT be invoked from anywhere but copydoneMode().
     450 
     451    // optional
     452    PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", false, false);
     453    PXOPT_LOOKUP_STR(dvodb, config->args, "-dvodb", false, false);
     454    PXOPT_LOOKUP_STR(tess_id, config->args, "-tess_id", false, false);
     455    PXOPT_LOOKUP_STR(end_stage, config->args, "-end_stage", false, false);
     456
    570457    // find all exposures that have had all of their imfiles downloaded but do
    571458    // not appear in newExp
    … …  
    613500                    doneExp->telescope, // tmp_telescope
    614501                    "run",              // state
    615                     NULL,               // workdir
     502                    workdir,            // workdir
    616503                    "dirty",            // workdir state
    617                     NULL                // reduction class
     504                    NULL,               // reduction class
     505                    dvodb,              // dvodb
     506                    tess_id,            // tess_id
     507                    end_stage           // end_stage
    618508                )
    619509        ) {

  • trunk/ippTools/src/pztoolConfig.c

    r15234 r16170  
    114114    psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-uri", 0,
    115115            "define storage uri", NULL);
    116 
    117 #define PXTOOL_MODE(option, modeval, argset) \
    118 { \
    119     int N = 0; \
    120     if ((N = psArgumentGet (argc, argv, option))) { \
    121         psArgumentRemove (N, &argc, argv); \
    122         if (config->mode) { \
    123             psError(PS_ERR_UNKNOWN, true, "only one mode selection is allowed"); \
    124             psFree(config); \
    125             return NULL; \
    126         } \
    127         config->mode = modeval; \
    128         config->args = psMemIncrRefCounter(argset); \
    129     } \
    130     if (!psMetadataAddMetadata(argSets, PS_LIST_TAIL, option, 0, NULL, argset)) {;\
    131         psError(PS_ERR_UNKNOWN, false, "failed to add argset for %s", option); \
    132     } \
    133     psFree(argset); \
    134 }
     116    psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-workdir",  0,
     117        "define the \"default\" workdir for this exposure", NULL);
     118    psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-dvodb",  0,
     119        "define the dvodb for the next processing step", NULL);
     120    psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-tess_id",  0,
     121        "define the tess_id for the next processing step", NULL);
     122    psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-end_stage",  0,
     123        "define the end goal processing step", NULL);
    135124
    136125    psMetadata *argSets = psMetadataAlloc();
    137126    psMetadata *modes = psMetadataAlloc();
    138127
    139     PXTOOL_ADD_MODE("-adddatastore",    "", PZTOOL_MODE_ADDDATASTORE, adddatastoreArgs);
    140     PXTOOL_ADD_MODE("-datastore",       "", PZTOOL_MODE_DATASTORE,    datastoreArgs);
    141     PXTOOL_ADD_MODE("-seen",            "", PZTOOL_MODE_SEEN,         seenArgs);
    142     PXTOOL_ADD_MODE("-pendingexp",      "", PZTOOL_MODE_PENDINGEXP,   pendingexpArgs);
    143     PXTOOL_ADD_MODE("-pendingimfile",   "", PZTOOL_MODE_PENDINGIMFILE,pendingimfileArgs);
    144     PXTOOL_ADD_MODE("-copydone",        "", PZTOOL_MODE_COPYDONE,     copydoneArgs);
     128    PXOPT_ADD_MODE("-adddatastore",    "", PZTOOL_MODE_ADDDATASTORE, adddatastoreArgs);
     129    PXOPT_ADD_MODE("-datastore",       "", PZTOOL_MODE_DATASTORE,    datastoreArgs);
     130    PXOPT_ADD_MODE("-seen",            "", PZTOOL_MODE_SEEN,         seenArgs);
     131    PXOPT_ADD_MODE("-pendingexp",      "", PZTOOL_MODE_PENDINGEXP,   pendingexpArgs);
     132    PXOPT_ADD_MODE("-pendingimfile",   "", PZTOOL_MODE_PENDINGIMFILE,pendingimfileArgs);
     133    PXOPT_ADD_MODE("-copydone",        "", PZTOOL_MODE_COPYDONE,     copydoneArgs);
    145134
    146135    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {

  • trunk/ippTools/src/regtool.c

    r15778 r16170  
    4444static bool updateprocessedexpMode(pxConfig *config);
    4545
    46 
    47 // static guidePendingExpRow *newToP1PendingExp(newExpRow *newExp);
    48 //static chipPendingExpRow *newTochipPendingExp(pxConfig *config, newExpRow *newExp);
    49 //static chipInputImfileRow *rawImfileTochipInputImfile(pxConfig *config, psS64 chip_id, rawImfileRow *rawImfile);
    50 
    51 static rawExpRow *newToRawExp(pxConfig *config, newExpRow *exp);
    52 //static psU32 mapCodeStrToInt(const char *codeStr);
    53 
    54 
    5546# define MODECASE(caseName, func) \
    5647    case caseName: \
    … …  
    109100    PS_ASSERT_PTR_NON_NULL(config, false);
    110101
    111     bool status = false;
    112     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    113     if (!status) {
    114         psError(PXTOOLS_ERR_PROG, false, "failed to lookup value for -limit");
    115         return false;
    116     }
     102    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     103    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    117104
    118105    // select newImfiles that:
    … …  
    163150    }
    164151
    165     bool simple = false;
    166     simple = psMetadataLookupBool(&status, config->args, "-simple");
    167     if (!status) {
    168         psError(PXTOOLS_ERR_PROG, false, "failed to lookup value for -simple");
    169         return false;
    170     }
    171 
    172152    // negate simple so the default is true
    173153    if (!ippdbPrintMetadatas(stdout, output, "regPendingImfile", !simple)) {
    … …  
    187167    PS_ASSERT_PTR_NON_NULL(config, false);
    188168
    189     bool status = false;
    190169    // required
    191     psString exp_id = psMetadataLookupStr(&status, config->args, "-exp_id");
    192     if (!status) {
    193         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_id");
    194         return false;
    195     }
    196     if (!exp_id) {
    197         psError(PS_ERR_UNKNOWN, true, "-exp_id is required");
    198         return false;
    199     }
    200 
    201     psString exp_name = psMetadataLookupStr(&status, config->args, "-exp_name");
    202     if (!status) {
    203         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_name");
    204         return false;
    205     }
    206     if (!exp_name) {
    207         psError(PS_ERR_UNKNOWN, true, "-exp_name is required");
    208         return false;
    209     }
    210 
    211     psString camera = psMetadataLookupStr(&status, config->args, "-inst");
    212     if (!status) {
    213         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -inst");
    214         return false;
    215     }
    216     if (!camera) {
    217         psError(PS_ERR_UNKNOWN, true, "-inst is required");
    218         return false;
    219     }
    220 
    221     psString telescope = psMetadataLookupStr(&status, config->args, "-telescope");
    222     if (!status) {
    223         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -telescope");
    224         return false;
    225     }
    226     if (!telescope) {
    227         psError(PS_ERR_UNKNOWN, true, "-telescope is required");
    228         return false;
    229     }
    230 
    231     psString tmp_class_id = psMetadataLookupStr(&status, config->args, "-tmp_class_id");
    232     if (!status) {
    233         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -tmp_class_id");
    234         return false;
    235     }
    236     if (!tmp_class_id) {
    237         psError(PS_ERR_UNKNOWN, true, "-tmp_class_id is required");
    238     }
    239 
    240     psString class_id = psMetadataLookupStr(&status, config->args, "-class_id");
    241     if (!status) {
    242         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -class_id");
    243         return false;
    244     }
    245     if (!class_id) {
    246         psError(PS_ERR_UNKNOWN, true, "-class_id is required");
    247         return false;
    248     }
    249 
    250     psString uri = psMetadataLookupStr(&status, config->args, "-uri");
    251     if (!status) {
    252         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -uri");
    253         return false;
    254     }
    255     if (!uri) {
    256         psError(PS_ERR_UNKNOWN, true, "-uri is required");
    257         return false;
    258     }
     170    PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", true, false);
     171    PXOPT_LOOKUP_STR(exp_name, config->args, "-exp_name", true, false);
     172    PXOPT_LOOKUP_STR(camera, config->args, "-inst", true, false);
     173    PXOPT_LOOKUP_STR(telescope, config->args, "-telescope", true, false);
     174    PXOPT_LOOKUP_STR(tmp_class_id, config->args, "-tmp_class_id", true, false);
     175    PXOPT_LOOKUP_STR(class_id, config->args, "-class_id", true, false);
     176    PXOPT_LOOKUP_STR(uri, config->args, "-uri", true, false);
    259177
    260178    // optional
    261     psString exp_type = psMetadataLookupStr(&status, config->args, "-exp_type");
    262     if (!status) {
    263         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_type");
    264         return false;
    265     }
    266 
    267     psString filelevel = psMetadataLookupStr(&status, config->args, "-filelevel");
    268     if (!status) {
    269         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -filelevel");
    270         return false;
    271     }
    272 
    273     psString filter = psMetadataLookupStr(&status, config->args, "-filter");
    274     if (!status) {
    275         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -filter");
    276         return false;
    277     }
    278 
    279     psString comment = psMetadataLookupStr(&status, config->args, "-comment");
    280     if (!status) {
    281         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -comment");
    282         return false;
    283     }
    284 
    285     psF32 airmass = psMetadataLookupF32(&status, config->args, "-airmass");
    286     if (!status) {
    287         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -airmass");
    288         return false;
    289     }
    290 
    291     psF64 ra = psMetadataLookupF64(&status, config->args, "-ra");
    292     if (!status) {
    293         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -ra");
    294         return false;
    295     }
    296 
    297     psF64 decl = psMetadataLookupF64(&status, config->args, "-decl");
    298     if (!status) {
    299         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -decl");
    300         return false;
    301     }
    302 
    303     psF32 exp_time = psMetadataLookupF32(&status, config->args, "-exp_time");
    304     if (!status) {
    305         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_time");
    306         return false;
    307     }
    308 
    309     psF32 sat_pixel_frac = psMetadataLookupF32(&status, config->args, "-sat_pixel_frac");
    310     if (!status) {
    311         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -sat_pixel_frac");
    312         return false;
    313     }
    314 
    315     psF64 bg = psMetadataLookupF64(&status, config->args, "-bg");
    316     if (!status) {
    317         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg");
    318         return false;
    319     }
    320 
    321     psF64 bg_stdev = psMetadataLookupF64(&status, config->args, "-bg_stdev");
    322     if (!status) {
    323         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg_stdev");
    324         return false;
    325     }
    326 
    327     psF64 bg_mean_stdev = psMetadataLookupF64(&status, config->args, "-bg_mean_stdev");
    328     if (!status) {
    329         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg_mean_stdev");
    330         return false;
    331     }
    332 
    333     psF64 alt = psMetadataLookupF64(&status, config->args, "-alt");
    334     if (!status) {
    335         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -alt");
    336         return false;
    337     }
    338 
    339     psF64 az = psMetadataLookupF64(&status, config->args, "-az");
    340     if (!status) {
    341         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -az");
    342         return false;
    343     }
    344 
    345     psF32 ccd_temp = psMetadataLookupF32(&status, config->args, "-ccd_temp");
    346     if (!status) {
    347         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -ccd_temp");
    348         return false;
    349     }
    350 
    351     psF64 posang = psMetadataLookupF32(&status, config->args, "-posang");
    352     if (!status) {
    353         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -posang");
    354         return false;
    355     }
    356 
    357     psF32 m1_x = psMetadataLookupF32(&status, config->args, "-m1_x");
    358     if (!status) {
    359         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -m1_x");
    360         return false;
    361     }
    362     psF32 m1_y = psMetadataLookupF32(&status, config->args, "-m1_y");
    363     if (!status) {
    364         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -m1_y");
    365         return false;
    366     }
    367     psF32 m1_z = psMetadataLookupF32(&status, config->args, "-m1_z");
    368     if (!status) {
    369         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -m1_z");
    370         return false;
    371     }
    372     psF32 m1_tip = psMetadataLookupF32(&status, config->args, "-m1_tip");
    373     if (!status) {
    374         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -m1_tip");
    375         return false;
    376     }
    377     psF32 m1_tilt = psMetadataLookupF32(&status, config->args, "-m1_tilt");
    378     if (!status) {
    379         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -m1_tilt");
    380         return false;
    381     }
    382 
    383     psF32 m2_x = psMetadataLookupF32(&status, config->args, "-m2_x");
    384     if (!status) {
    385         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -m2_x");
    386         return false;
    387     }
    388     psF32 m2_y = psMetadataLookupF32(&status, config->args, "-m2_y");
    389     if (!status) {
    390         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -m2_y");
    391         return false;
    392     }
    393     psF32 m2_z = psMetadataLookupF32(&status, config->args, "-m2_z");
    394     if (!status) {
    395         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -m2_z");
    396         return false;
    397     }
    398     psF32 m2_tip = psMetadataLookupF32(&status, config->args, "-m2_tip");
    399     if (!status) {
    400         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -m2_tip");
    401         return false;
    402     }
    403     psF32 m2_tilt = psMetadataLookupF32(&status, config->args, "-m2_tilt");
    404     if (!status) {
    405         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -m2_tilt");
    406         return false;
    407     }
    408 
    409     psF32 env_temp = psMetadataLookupF32(&status, config->args, "-env_temperature");
    410     if (!status) {
    411         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -env_temperature");
    412         return false;
    413     }
    414     psF32 env_humid = psMetadataLookupF32(&status, config->args, "-env_humidity");
    415     if (!status) {
    416         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -env_humidity");
    417         return false;
    418     }
    419     psF32 env_wind = psMetadataLookupF32(&status, config->args, "-env_wind_speed");
    420     if (!status) {
    421         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -env_wind_speed");
    422         return false;
    423     }
    424     psF32 env_dir = psMetadataLookupF32(&status, config->args, "-env_wind_dir");
    425     if (!status) {
    426         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -env_wind_dir");
    427         return false;
    428     }
    429 
    430     psF32 teltemp_m1 = psMetadataLookupF32(&status, config->args, "-teltemp_m1");
    431     if (!status) {
    432         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -teltemp_m1");
    433         return false;
    434     }
    435     psF32 teltemp_m1cell = psMetadataLookupF32(&status, config->args, "-teltemp_m1cell");
    436     if (!status) {
    437         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -teltemp_m1cell");
    438         return false;
    439     }
    440     psF32 teltemp_m2 = psMetadataLookupF32(&status, config->args, "-teltemp_m2");
    441     if (!status) {
    442         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -teltemp_m2");
    443         return false;
    444     }
    445     psF32 teltemp_spider = psMetadataLookupF32(&status, config->args, "-teltemp_spider");
    446     if (!status) {
    447         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -teltemp_spider");
    448         return false;
    449     }
    450     psF32 teltemp_truss = psMetadataLookupF32(&status, config->args, "-teltemp_truss");
    451     if (!status) {
    452         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -teltemp_truss");
    453         return false;
    454     }
    455     psF32 teltemp_extra = psMetadataLookupF32(&status, config->args, "-teltemp_extra");
    456     if (!status) {
    457         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -teltemp_extra");
    458         return false;
    459     }
    460 
    461     psF32 pon_time = psMetadataLookupF32(&status, config->args, "-pon_time");
    462     if (!status) {
    463         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -pon_time");
    464         return false;
    465     }
    466 
    467     psF64 user_1 = psMetadataLookupF64(&status, config->args, "-user_1");
    468     if (!status) {
    469         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_1");
    470         return false;
    471     }
    472     psF64 user_2 = psMetadataLookupF64(&status, config->args, "-user_2");
    473     if (!status) {
    474         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_2");
    475         return false;
    476     }
    477     psF64 user_3 = psMetadataLookupF64(&status, config->args, "-user_3");
    478     if (!status) {
    479         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_3");
    480         return false;
    481     }
    482     psF64 user_4 = psMetadataLookupF64(&status, config->args, "-user_4");
    483     if (!status) {
    484         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_4");
    485         return false;
    486     }
    487     psF64 user_5 = psMetadataLookupF64(&status, config->args, "-user_5");
    488     if (!status) {
    489         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_5");
    490         return false;
    491     }
    492 
    493     psString object = psMetadataLookupStr(&status, config->args, "-object");
    494     if (!status) {
    495         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -object");
    496         return false;
    497     }
    498 
    499     psTime *dateobs = NULL;
    500     {
    501         psString dateobsStr = psMetadataLookupStr(&status, config->args, "-dateobs");
    502         if (!status) {
    503             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -dateobs");
    504             return false;
    505         }
    506         // pass through NULL as this is an optional field
    507         if (dateobsStr) {
    508             dateobs = psTimeFromISO(dateobsStr, PS_TIME_UTC);
    509         } else {
    510             dateobs = NULL;
    511         }
    512     }
    513 
    514     psS16 code = psMetadataLookupS16(&status, config->args, "-code");
    515     if (!status) {
    516         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -code");
    517         return false;
    518     }
     179    PXOPT_LOOKUP_STR(exp_type, config->args, "-exp_type", false, false);
     180    PXOPT_LOOKUP_STR(filelevel, config->args, "-filelevel", false, false);
     181    PXOPT_LOOKUP_STR(filter, config->args, "-filter", false, false);
     182    PXOPT_LOOKUP_STR(comment, config->args, "-comment", false, false);
     183
     184    PXOPT_LOOKUP_F32(airmass, config->args, "-airmass", false, false);
     185    PXOPT_LOOKUP_F64(ra, config->args, "-ra", false, false);
     186    PXOPT_LOOKUP_F64(decl, config->args, "-decl", false, false);
     187    PXOPT_LOOKUP_F32(exp_time, config->args, "-exp_time", false, false);
     188    PXOPT_LOOKUP_F32(sat_pixel_frac, config->args, "-sat_pixel_frac", false, false);
     189    PXOPT_LOOKUP_F64(bg, config->args, "-bg", false, false);
     190    PXOPT_LOOKUP_F64(bg_stdev, config->args, "-bg_stdev", false, false);
     191    PXOPT_LOOKUP_F64(bg_mean_stdev, config->args, "-bg_mean_stdev", false, false);
     192    PXOPT_LOOKUP_F64(alt, config->args, "-alt", false, false);
     193    PXOPT_LOOKUP_F64(az, config->args, "-az", false, false);
     194    PXOPT_LOOKUP_F32(ccd_temp, config->args, "-ccd_temp", false, false);
     195    PXOPT_LOOKUP_F64(posang, config->args, "-posang", false, false);
     196    PXOPT_LOOKUP_F32(m1_x, config->args, "-m1_x", false, false);
     197    PXOPT_LOOKUP_F32(m1_y, config->args, "-m1_y", false, false);
     198    PXOPT_LOOKUP_F32(m1_z, config->args, "-m1_z", false, false);
     199    PXOPT_LOOKUP_F32(m1_tip, config->args, "-m1_tip", false, false);
     200    PXOPT_LOOKUP_F32(m1_tilt, config->args, "-m1_tilt", false, false);
     201    PXOPT_LOOKUP_F32(m2_x, config->args, "-m2_x", false, false);
     202    PXOPT_LOOKUP_F32(m2_y, config->args, "-m2_y", false, false);
     203    PXOPT_LOOKUP_F32(m2_z, config->args, "-m2_z", false, false);
     204    PXOPT_LOOKUP_F32(m2_tip, config->args, "-m2_tip", false, false);
     205    PXOPT_LOOKUP_F32(m2_tilt, config->args, "-m2_tilt", false, false);
     206
     207    PXOPT_LOOKUP_F32(env_temp, config->args, "-env_temperature", false, false);
     208    PXOPT_LOOKUP_F32(env_humid, config->args, "-env_humidity", false, false);
     209    PXOPT_LOOKUP_F32(env_wind, config->args, "-env_wind_speed", false, false);
     210    PXOPT_LOOKUP_F32(env_dir, config->args, "-env_wind_dir", false, false);
     211    PXOPT_LOOKUP_F32(teltemp_m1, config->args, "-teltemp_m1", false, false);
     212    PXOPT_LOOKUP_F32(teltemp_m1cell, config->args, "-teltemp_m1cell", false, false);
     213    PXOPT_LOOKUP_F32(teltemp_m2, config->args, "-teltemp_m2", false, false);
     214    PXOPT_LOOKUP_F32(teltemp_spider, config->args, "-teltemp_spider", false, false);
     215    PXOPT_LOOKUP_F32(teltemp_truss, config->args, "-teltemp_truss", false, false);
     216    PXOPT_LOOKUP_F32(teltemp_extra, config->args, "-teltemp_extra", false, false);
     217    PXOPT_LOOKUP_F32(pon_time, config->args, "-pon_time", false, false);
     218    PXOPT_LOOKUP_F64(user_1, config->args, "-user_1", false, false);
     219    PXOPT_LOOKUP_F64(user_2, config->args, "-user_2", false, false);
     220    PXOPT_LOOKUP_F64(user_3, config->args, "-user_3", false, false);
     221    PXOPT_LOOKUP_F64(user_4, config->args, "-user_4", false, false);
     222    PXOPT_LOOKUP_F64(user_5, config->args, "-user_5", false, false);
     223    PXOPT_LOOKUP_STR(object, config->args, "-object", false, false);
     224    PXOPT_LOOKUP_TIME(dateobs, config->args, "-dateobs", false, false);
     225    PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
    519226
    520227    if (!rawImfileInsert(
    … …  
    574281    )) {
    575282        psError(PS_ERR_UNKNOWN, false, "database error");
    576         psFree(dateobs);
    577         return false;
    578     }
    579 
    580     psFree(dateobs);
     283        return false;
     284    }
    581285
    582286    return true;
    … …  
    588292    PS_ASSERT_PTR_NON_NULL(config, false);
    589293
    590     bool status = false;
    591     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    592     if (!status) {
    593         psError(PXTOOLS_ERR_PROG, false, "failed to lookup value for -limit");
    594         return false;
    595     }
    596 
    597     bool faulted = psMetadataLookupU64(&status, config->args, "-faulted");
    598     if (!status) {
    599         psError(PXTOOLS_ERR_PROG, false, "failed to lookup value for -faulted");
    600         return false;
    601     }
     294    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     295    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     296    PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    602297
    603298    psString query = pxDataGet("regtool_processedimfile.sql");
    … …  
    655350    }
    656351
    657     bool simple = false;
    658     {
    659         bool status = false;
    660         simple = psMetadataLookupBool(&status, config->args, "-simple");
    661         if (!status) {
    662             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    663             return false;
    664         }
    665     }
    666 
    667352    if (psArrayLength(output)) {
    668353        // negative simple so the default is true
    … …  
    716401    PS_ASSERT_PTR_NON_NULL(config, false);
    717402
    718     bool status = false;
    719     psS16 code = psMetadataLookupS16(&status, config->args, "-code");
    720     if (!status) {
    721         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -code");
    722         return false;
    723     }
    724     if (code == INT16_MAX) {
    725         psError(PS_ERR_UNKNOWN, true, "-code is required");
    726         return false;
    727     }
     403    PXOPT_LOOKUP_S16(code, config->args, "-code", true, false);
    728404
    729405    if (!pxSetFaultCode(config->dbh, "rawImfile", config->where, code)) {
    … …  
    740416    PS_ASSERT_PTR_NON_NULL(config, false);
    741417
    742     bool status = false;
    743     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    744     if (!status) {
    745         psError(PXTOOLS_ERR_PROG, false, "failed to lookup value for -limit");
    746         return false;
    747     }
     418    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     419    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    748420
    749421    // return only exps that:
    … …  
    792464    }
    793465
    794     bool simple = false;
    795     simple = psMetadataLookupBool(&status, config->args, "-simple");
    796     if (!status) {
    797         psError(PXTOOLS_ERR_PROG, false, "failed to lookup value for -simple");
    798         return false;
    799     }
    800 
    801466    // negate simple so the default is true
    802467    if (!ippdbPrintMetadatas(stdout, output, "regPendingExp", !simple)) {
    … …  
    821486    // that the correct count of imfiles is in rawImfile
    822487
    823     bool status = false;
    824     psString exp_id = psMetadataLookupStr(&status, config->args, "-exp_id");
    825     if (!status) {
    826         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_id");
    827         return false;
    828     }
    829     if (!exp_id) {
    830         psError(PS_ERR_UNKNOWN, true, "-exp_id is required");
    831         return false;
    832     }
    833 
    834     bool detrend = psMetadataLookupBool(&status, config->args, "-detrend");
    835     if (!status) {
    836         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -detrend");
    837         return false;
    838     }
     488    // required
     489    PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", true, false);
     490    PXOPT_LOOKUP_STR(exp_name, config->args, "-exp_name", true, false);
     491    PXOPT_LOOKUP_STR(camera, config->args, "-inst", true, false);
     492    PXOPT_LOOKUP_STR(telescope, config->args, "-telescope", true, false);
     493    PXOPT_LOOKUP_STR(exp_tag, config->args, "-exp_tag", true, false);
     494    PXOPT_LOOKUP_STR(filelevel, config->args, "-filelevel", true, false);
     495
     496    // optional
     497    PXOPT_LOOKUP_STR(dvodb, config->args, "-dvodb", false, false);
     498    PXOPT_LOOKUP_STR(tess_id, config->args, "-tess_id", false, false);
     499    PXOPT_LOOKUP_STR(end_stage, config->args, "-end_stage", false, false);
     500    PXOPT_LOOKUP_STR(exp_type, config->args, "-exp_type", false, false);
     501    PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", false, false);
     502    PXOPT_LOOKUP_STR(reduction, config->args, "-reduction", false, false);
     503    PXOPT_LOOKUP_STR(filter, config->args, "-filter", false, false);
     504    PXOPT_LOOKUP_STR(comment, config->args, "-comment", false, false);
     505    PXOPT_LOOKUP_F32(airmass, config->args, "-airmass", false, false);
     506    PXOPT_LOOKUP_F64(ra, config->args, "-ra", false, false);
     507    PXOPT_LOOKUP_F64(decl, config->args, "-decl", false, false);
     508    PXOPT_LOOKUP_F32(exp_time, config->args, "-exp_time", false, false);
     509    PXOPT_LOOKUP_F32(sat_pixel_frac, config->args, "-sat_pixel_frac", false, false);
     510    PXOPT_LOOKUP_F64(bg, config->args, "-bg", false, false);
     511    PXOPT_LOOKUP_F64(bg_stdev, config->args, "-bg_stdev", false, false);
     512    PXOPT_LOOKUP_F64(bg_mean_stdev, config->args, "-bg_mean_stdev", false, false);
     513    PXOPT_LOOKUP_F64(alt, config->args, "-alt", false, false);
     514    PXOPT_LOOKUP_F64(az, config->args, "-az", false, false);
     515    PXOPT_LOOKUP_F32(ccd_temp, config->args, "-ccd_temp", false, false);
     516    PXOPT_LOOKUP_F64(posang, config->args, "-posang", false, false);
     517    PXOPT_LOOKUP_F32(m1_x, config->args, "-m1_x", false, false);
     518    PXOPT_LOOKUP_F32(m1_y, config->args, "-m1_y", false, false);
     519    PXOPT_LOOKUP_F32(m1_z, config->args, "-m1_z", false, false);
     520    PXOPT_LOOKUP_F32(m1_tip, config->args, "-m1_tip", false, false);
     521    PXOPT_LOOKUP_F32(m1_tilt, config->args, "-m1_tilt", false, false);
     522    PXOPT_LOOKUP_F32(m2_x, config->args, "-m2_x", false, false);
     523    PXOPT_LOOKUP_F32(m2_y, config->args, "-m2_y", false, false);
     524    PXOPT_LOOKUP_F32(m2_z, config->args, "-m2_z", false, false);
     525    PXOPT_LOOKUP_F32(m2_tip, config->args, "-m2_tip", false, false);
     526    PXOPT_LOOKUP_F32(m2_tilt, config->args, "-m2_tilt", false, false);
     527
     528    PXOPT_LOOKUP_F32(env_temp, config->args, "-env_temperature", false, false);
     529    PXOPT_LOOKUP_F32(env_humid, config->args, "-env_humidity", false, false);
     530    PXOPT_LOOKUP_F32(env_wind, config->args, "-env_wind_speed", false, false);
     531    PXOPT_LOOKUP_F32(env_dir, config->args, "-env_wind_dir", false, false);
     532    PXOPT_LOOKUP_F32(teltemp_m1, config->args, "-teltemp_m1", false, false);
     533    PXOPT_LOOKUP_F32(teltemp_m1cell, config->args, "-teltemp_m1cell", false, false);
     534    PXOPT_LOOKUP_F32(teltemp_m2, config->args, "-teltemp_m2", false, false);
     535    PXOPT_LOOKUP_F32(teltemp_spider, config->args, "-teltemp_spider", false, false);
     536    PXOPT_LOOKUP_F32(teltemp_truss, config->args, "-teltemp_truss", false, false);
     537    PXOPT_LOOKUP_F32(teltemp_extra, config->args, "-teltemp_extra", false, false);
     538    PXOPT_LOOKUP_F32(pon_time, config->args, "-pon_time", false, false);
     539    PXOPT_LOOKUP_F64(user_1, config->args, "-user_1", false, false);
     540    PXOPT_LOOKUP_F64(user_2, config->args, "-user_2", false, false);
     541    PXOPT_LOOKUP_F64(user_3, config->args, "-user_3", false, false);
     542    PXOPT_LOOKUP_F64(user_4, config->args, "-user_4", false, false);
     543    PXOPT_LOOKUP_F64(user_5, config->args, "-user_5", false, false);
     544    PXOPT_LOOKUP_STR(object, config->args, "-object", false, false);
     545    PXOPT_LOOKUP_TIME(dateobs, config->args, "-dateobs", false, false);
     546
     547    // default
     548    PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
    839549
    840550    psString query = pxDataGet("regtool_pendingexp.sql");
    … …  
    847557        // build a query to search by exp_id
    848558        psMetadata *where = psMetadataAlloc();
    849         bool status = false;
    850         psString exp_id = psMetadataLookupStr(&status, config->args, "-exp_id");
    851         if (!status) {
    852             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_id");
     559        if (!psMetadataAddStr(where, PS_LIST_TAIL, "exp_id", 0, "==", exp_id)) {
     560            psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
     561            psFree(where);
    853562            psFree(query);
    854563            return false;
    855564        }
    856         if (exp_id) {
    857             if (!psMetadataAddStr(where, PS_LIST_TAIL, "exp_id", 0, "==", exp_id)) {
    858                 psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    859                 psFree(where);
    860                 psFree(query);
    861                 return false;
    862             }
    863         }
    864 
    865565
    866566        psString whereClause = psDBGenerateWhereSQL(where, NULL);
    … …  
    898598        return false;
    899599    }
     600    // sanity check that we only got one row
     601    if (psArrayLength(output) != 1) {
     602        // rollback
     603        if (!psDBRollback(config->dbh)) {
     604            psError(PS_ERR_UNKNOWN, false, "database error");
     605        }
     606        psError(PS_ERR_UNKNOWN, false, "should have gotten 1 row but %lu rows were returned", psArrayLength(output));
     607        psFree(output);
     608        return NULL;
     609    }
    900610
    901611    if (!psDBTransaction(config->dbh)) {
    … …  
    906616
    907617    // insert the exp into rawExp
    908     for (long i = 0; psArrayLength(output) > i; i++) {
    909         psMetadata *row = output->data[i];
    910         // convert metadata into a newExp object
    911         newExpRow *newExp = newExpObjectFromMetadata(row);
    912         // convert newExp object into a rawExp object
    913         rawExpRow *rawExp = newToRawExp(config, newExp);
    914         if (!rawExp) {
    915             // rollback
    916             if (!psDBRollback(config->dbh)) {
    917                 psError(PS_ERR_UNKNOWN, false, "database error");
    918             }
    919             psError(PS_ERR_UNKNOWN, false, "failed to convert newExp to rawExp");
    920             psFree(newExp);
    921             psFree(output);
    922             return false;
    923         }
    924         psFree(newExp);
    925 
    926         // insert the rawExp object into the database
    927         if (!rawExpInsertObject(config->dbh, rawExp)) {
    928             // rollback
    929             if (!psDBRollback(config->dbh)) {
    930                 psError(PS_ERR_UNKNOWN, false, "database error");
    931             }
    932             psError(PS_ERR_UNKNOWN, false, "database error");
    933             psFree(rawExp);
    934             psFree(output);
    935             return false;
    936         }
    937 
    938         // if this is a detrend image don't put it in the chip queue (and we're
    939         // done)
    940         if (detrend) {
    941             // set the state for the newExp to stop
    942             if (!pxnewExpSetState(config, exp_id, "stop")) {
    943                 // rollback
    944                 if (!psDBRollback(config->dbh)) {
    945                     psError(PS_ERR_UNKNOWN, false, "database error");
    946                 }
    947                 psError(PS_ERR_UNKNOWN, false, "failed to change newExp.state for exp_id: %s", exp_id);
    948                 psFree(rawExp);
    949                 psFree(output);
    950                 return false;
    951             }
    952             psFree(rawExp);
    953             continue;
    954         }
    955 
    956 
    957         // set the state for the newExp to stop
    958         if (!pxnewExpSetState(config, exp_id, "stop")) {
    959             // rollback
    960             if (!psDBRollback(config->dbh)) {
    961                 psError(PS_ERR_UNKNOWN, false, "database error");
    962             }
    963             psError(PS_ERR_UNKNOWN, false, "failed to change newExp.state for exp_id: %s", exp_id);
    964             psFree(rawExp);
    965             psFree(output);
    966             return false;
    967         }
    968 
    969         // insert an entry into the chipPendingExp table
    970         // this can only be run as the newExp's state has been set to stop
    971         if (!pxchipQueueByExpTag(config,
    972                     rawExp->exp_id,
    973                     rawExp->workdir,
    974                     NULL, // label
    975                     rawExp->reduction,
    976                     NULL, // expgroup
    977                     NULL  // dvodb
    978         )) {
    979             // rollback
    980             if (!psDBRollback(config->dbh)) {
    981                 psError(PS_ERR_UNKNOWN, false, "database error");
    982             }
    983             psError(PS_ERR_UNKNOWN, false, "failed to queue chipPendingExp");
    984             psFree(rawExp);
    985             psFree(output);
    986             return false;
    987         }
    988         psFree(rawExp);
    989     }
     618    psMetadata *row = output->data[0];
     619    // convert metadata into a newExp object
     620    newExpRow *newExp = newExpObjectFromMetadata(row);
    990621    psFree(output);
    991622
    992     if (!psDBCommit(config->dbh)) {
    993         psError(PS_ERR_UNKNOWN, false, "database error");
    994         return false;
    995     }
    996 
    997     return true;
    998 }
    999 
    1000 
    1001 static bool processedexpMode(pxConfig *config)
    1002 {
    1003     PS_ASSERT_PTR_NON_NULL(config, false);
    1004 
    1005     bool status = false;
    1006     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    1007     if (!status) {
    1008         psError(PXTOOLS_ERR_PROG, false, "failed to lookup value for -limit");
    1009         return false;
    1010     }
    1011 
    1012     bool faulted = psMetadataLookupU64(&status, config->args, "-faulted");
    1013     if (!status) {
    1014         psError(PXTOOLS_ERR_PROG, false, "failed to lookup value for -faulted");
    1015         return false;
    1016     }
    1017 
    1018     psString query = pxDataGet("regtool_processedexp.sql");
    1019     if (!query) {
    1020         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    1021         return false;
    1022     }
    1023 
    1024     if (config->where) {
    1025         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "rawExp");
    1026         psStringAppend(&query, " AND %s", whereClause);
    1027         psFree(whereClause);
    1028     }
    1029 
    1030     if (faulted) {
    1031         // list only faulted rows
    1032         psStringAppend(&query, " %s", "AND rawExp.fault != 0");
    1033     } else {
    1034         // don't list faulted rows
    1035         psStringAppend(&query, " %s", "AND rawExp.fault = 0");
    1036     }
    1037 
    1038     // treat limit == 0 as "no limit"
    1039     if (limit) {
    1040         psString limitString = psDBGenerateLimitSQL(limit);
    1041         psStringAppend(&query, " %s", limitString);
    1042         psFree(limitString);
    1043     }
    1044 
    1045     if (!p_psDBRunQuery(config->dbh, query)) {
    1046         psError(PS_ERR_UNKNOWN, false, "database error");
    1047         return false;
    1048     }
    1049     psFree(query);
    1050 
    1051     psArray *output = p_psDBFetchResult(config->dbh);
    1052     if (!output) {
    1053         psErrorCode err = psErrorCodeLast();
    1054         switch (err) {
    1055             case PS_ERR_DB_CLIENT:
    1056                 psError(PXTOOLS_ERR_SYS, false, "database error");
    1057             case PS_ERR_DB_SERVER:
    1058                 psError(PXTOOLS_ERR_PROG, false, "database error");
    1059             default:
    1060                 psError(PXTOOLS_ERR_PROG, false, "unknown error");
    1061         }
    1062 
    1063         return false;
    1064     }
    1065     if (!psArrayLength(output)) {
    1066         psTrace("regtool", PS_LOG_INFO, "no rows found");
    1067         psFree(output);
    1068         return true;
    1069     }
    1070 
    1071     bool simple = false;
    1072     {
    1073         bool status = false;
    1074         simple = psMetadataLookupBool(&status, config->args, "-simple");
    1075         if (!status) {
    1076             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    1077             return false;
    1078         }
    1079     }
    1080 
    1081     if (psArrayLength(output)) {
    1082         // negative simple so the default is true
    1083         if (!ippdbPrintMetadatas(stdout, output, "rawExp", !simple)) {
    1084             psError(PS_ERR_UNKNOWN, false, "failed to print array");
    1085             psFree(output);
    1086             return false;
    1087         }
    1088     }
    1089 
    1090     psFree(output);
    1091 
    1092     return true;
    1093 }
    1094 
    1095 static bool revertprocessedexpMode(pxConfig *config)
    1096 {
    1097     PS_ASSERT_PTR_NON_NULL(config, false);
    1098 
    1099     psString query = pxDataGet("regtool_revertprocessedexp.sql");
    1100     if (!query) {
    1101         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    1102         return false;
    1103     }
    1104 
    1105     if (config->where) {
    1106         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "rawExp");
    1107         psStringAppend(&query, " AND %s", whereClause);
    1108         psFree(whereClause);
    1109     }
    1110 
    1111     if (!p_psDBRunQuery(config->dbh, query)) {
    1112         psError(PS_ERR_UNKNOWN, false, "database error");
    1113         psFree(query);
    1114         return false;
    1115     }
    1116     psFree(query);
    1117 
    1118     if (psDBAffectedRows(config->dbh) < 1) {
    1119         psError(PS_ERR_UNKNOWN, false, "should have affected atleast 1 row");
    1120         return false;
    1121     }
    1122 
    1123     return true;
    1124 }
    1125 
    1126 
    1127 static bool updateprocessedexpMode(pxConfig *config)
    1128 {
    1129     bool status = false;
    1130     psS16 code = psMetadataLookupS16(&status, config->args, "-code");
    1131     if (!status) {
    1132         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -code");
    1133         return false;
    1134     }
    1135     if (code == INT16_MAX) {
    1136         psError(PS_ERR_UNKNOWN, true, "-code is required");
    1137         return false;
    1138     }
    1139 
    1140     if (!pxSetFaultCode(config->dbh, "rawExp", config->where, code)) {
    1141         psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag");
    1142         return false;
    1143     }
    1144 
    1145     return true;
    1146 }
    1147 
    1148 
    1149 # if 0
    1150 static guidePendingExpRow *newToP1PendingExp(newExpRow *newExp)
    1151 {
    1152     return guidePendingExpRowAlloc(
    1153         newExp->exp_id,
    1154         newExp->camera,
    1155         newExp->telescope,
    1156         newExp->exp_type,
    1157         newExp->imfiles,
    1158         "my filter",
    1159         0.1, // airmass
    1160         0.2, // ra
    1161         0.3, // dec
    1162         0.4, // exp time
    1163         0.5, // background
    1164         "my recipe",
    1165         0xff // XXX calc version number
    1166     );
    1167 }
    1168 #endif
    1169 
    1170 
    1171 #if 0
    1172 static chipPendingExpRow *newTochipPendingExp(pxConfig *config, newExpRow *exp)
    1173 {
    1174     PS_ASSERT_PTR_NON_NULL(config, NULL);
    1175     PS_ASSERT_PTR_NON_NULL(exp, NULL);
    1176 
    1177     // optional
    1178     bool status = false;
    1179     psString label = psMetadataLookupStr(&status, config->args, "-label");
    1180     if (!status) {
    1181         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -label");
    1182         return false;
    1183     }
    1184 
    1185     chipPendingExpRow *chipExp = chipPendingExpRowAlloc(
    1186             0,              // chip ID, assigned by db
    1187             exp->exp_id,
    1188             0xdeadbeef,     // guide version
    1189             label,
    1190             "my recipe",    // recipe
    1191             NULL,           // expgroup
    1192             NULL            // dvodb
    1193     );
    1194 
    1195     return chipExp;
    1196 }
    1197 
    1198 
    1199 static chipInputImfileRow *rawImfileTochipInputImfile(pxConfig *config, psS64 chip_id, rawImfileRow *rawImfile)
    1200 {
    1201     return chipInputImfileRowAlloc(
    1202             chip_id,
    1203             rawImfile->class_id,
    1204             rawImfile->uri
    1205     );
    1206 }
    1207 #endif
    1208 
    1209 
    1210 static rawExpRow *newToRawExp(pxConfig *config, newExpRow *exp)
    1211 {
    1212     PS_ASSERT_PTR_NON_NULL(config, NULL);
    1213     PS_ASSERT_PTR_NON_NULL(exp, NULL);
    1214 
    1215     bool status = false;
    1216     // required
    1217     psString exp_name = psMetadataLookupStr(&status, config->args, "-exp_name");
    1218     if (!status) {
    1219         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_name");
    1220         return false;
    1221     }
    1222     if (!exp_name) {
    1223         psError(PS_ERR_UNKNOWN, true, "-exp_name is required");
    1224         return false;
    1225     }
    1226 
    1227     psString camera = psMetadataLookupStr(&status, config->args, "-inst");
    1228     if (!status) {
    1229         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -inst");
    1230         return false;
    1231     }
    1232     if (!camera) {
    1233         psError(PS_ERR_UNKNOWN, true, "-inst is required");
    1234         return false;
    1235     }
    1236 
    1237     psString telescope = psMetadataLookupStr(&status, config->args, "-telescope");
    1238     if (!status) {
    1239         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -telescope");
    1240         return false;
    1241     }
    1242     if (!telescope) {
    1243         psError(PS_ERR_UNKNOWN, true, "-telescope is required");
    1244         return false;
    1245     }
    1246 
    1247     psString exp_tag = psMetadataLookupStr(&status, config->args, "-exp_tag");
    1248     if (!status) {
    1249         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_tag");
    1250         return false;
    1251     }
    1252     if (!exp_tag) {
    1253         psError(PS_ERR_UNKNOWN, true, "-exp_tag is required");
    1254         return false;
    1255     }
    1256 
    1257     // optional
    1258     psString exp_type = psMetadataLookupStr(&status, config->args, "-exp_type");
    1259     if (!status) {
    1260         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_type");
    1261         return false;
    1262     }
    1263 
    1264     psString filelevel = psMetadataLookupStr(&status, config->args, "-filelevel");
    1265     if (!status) {
    1266         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -filelevel");
    1267         return false;
    1268     }
    1269     if (!filelevel) {
    1270         psError(PS_ERR_UNKNOWN, true, "-filelevel is required");
    1271         return false;
    1272     }
    1273 
    1274     psString workdir = psMetadataLookupStr(&status, config->args, "-workdir");
    1275     if (!status) {
    1276         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -workdir");
    1277         return false;
    1278     }
    1279 
    1280     psString reduction = psMetadataLookupStr(&status, config->args, "-reduction");
    1281     if (!status) {
    1282         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -reduction");
    1283         return false;
    1284     }
    1285 
    1286     psString filter = psMetadataLookupStr(&status, config->args, "-filter");
    1287     if (!status) {
    1288         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -filter");
    1289         return false;
    1290     }
    1291 
    1292     psString comment = psMetadataLookupStr(&status, config->args, "-comment");
    1293     if (!status) {
    1294         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -comment");
    1295         return false;
    1296     }
    1297 
    1298     psF32 airmass = psMetadataLookupF32(&status, config->args, "-airmass");
    1299     if (!status) {
    1300         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -airmass");
    1301         return false;
    1302     }
    1303 
    1304     psF64 ra = psMetadataLookupF64(&status, config->args, "-ra");
    1305     if (!status) {
    1306         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -ra");
    1307         return false;
    1308     }
    1309 
    1310     psF64 decl = psMetadataLookupF64(&status, config->args, "-decl");
    1311     if (!status) {
    1312         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -decl");
    1313         return false;
    1314     }
    1315 
    1316     psF32 exp_time = psMetadataLookupF32(&status, config->args, "-exp_time");
    1317     if (!status) {
    1318         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_time");
    1319         return false;
    1320     }
    1321 
    1322     psF32 sat_pixel_frac = psMetadataLookupF32(&status, config->args, "-sat_pixel_frac");
    1323     if (!status) {
    1324         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -sat_pixel_frac");
    1325         return false;
    1326     }
    1327 
    1328     psF64 bg = psMetadataLookupF64(&status, config->args, "-bg");
    1329     if (!status) {
    1330         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg");
    1331         return false;
    1332     }
    1333 
    1334     psF64 bg_stdev = psMetadataLookupF64(&status, config->args, "-bg_stdev");
    1335     if (!status) {
    1336         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg_stdev");
    1337         return false;
    1338     }
    1339 
    1340     psF64 bg_mean_stdev = psMetadataLookupF64(&status, config->args, "-bg_mean_stdev");
    1341     if (!status) {
    1342         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg_mean_stdev");
    1343         return false;
    1344     }
    1345 
    1346     psF64 alt = psMetadataLookupF64(&status, config->args, "-alt");
    1347     if (!status) {
    1348         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -alt");
    1349         return false;
    1350     }
    1351 
    1352     psF64 az = psMetadataLookupF64(&status, config->args, "-az");
    1353     if (!status) {
    1354         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -az");
    1355         return false;
    1356     }
    1357 
    1358     psF32 ccd_temp = psMetadataLookupF32(&status, config->args, "-ccd_temp");
    1359     if (!status) {
    1360         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -ccd_temp");
    1361         return false;
    1362     }
    1363 
    1364     psF64 posang = psMetadataLookupF32(&status, config->args, "-posang");
    1365     if (!status) {
    1366         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -posang");
    1367         return false;
    1368     }
    1369 
    1370     psF32 m1_x = psMetadataLookupF32(&status, config->args, "-m1_x");
    1371     if (!status) {
    1372         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -m1_x");
    1373         return false;
    1374     }
    1375     psF32 m1_y = psMetadataLookupF32(&status, config->args, "-m1_y");
    1376     if (!status) {
    1377         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -m1_y");
    1378         return false;
    1379     }
    1380     psF32 m1_z = psMetadataLookupF32(&status, config->args, "-m1_z");
    1381     if (!status) {
    1382         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -m1_z");
    1383         return false;
    1384     }
    1385     psF32 m1_tip = psMetadataLookupF32(&status, config->args, "-m1_tip");
    1386     if (!status) {
    1387         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -m1_tip");
    1388         return false;
    1389     }
    1390     psF32 m1_tilt = psMetadataLookupF32(&status, config->args, "-m1_tilt");
    1391     if (!status) {
    1392         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -m1_tilt");
    1393         return false;
    1394     }
    1395 
    1396     psF32 m2_x = psMetadataLookupF32(&status, config->args, "-m2_x");
    1397     if (!status) {
    1398         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -m2_x");
    1399         return false;
    1400     }
    1401     psF32 m2_y = psMetadataLookupF32(&status, config->args, "-m2_y");
    1402     if (!status) {
    1403         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -m2_y");
    1404         return false;
    1405     }
    1406     psF32 m2_z = psMetadataLookupF32(&status, config->args, "-m2_z");
    1407     if (!status) {
    1408         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -m2_z");
    1409         return false;
    1410     }
    1411     psF32 m2_tip = psMetadataLookupF32(&status, config->args, "-m2_tip");
    1412     if (!status) {
    1413         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -m2_tip");
    1414         return false;
    1415     }
    1416     psF32 m2_tilt = psMetadataLookupF32(&status, config->args, "-m2_tilt");
    1417     if (!status) {
    1418         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -m2_tilt");
    1419         return false;
    1420     }
    1421 
    1422     psF32 env_temp = psMetadataLookupF32(&status, config->args, "-env_temperature");
    1423     if (!status) {
    1424         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -env_temperature");
    1425         return false;
    1426     }
    1427     psF32 env_humid = psMetadataLookupF32(&status, config->args, "-env_humidity");
    1428     if (!status) {
    1429         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -env_humidity");
    1430         return false;
    1431     }
    1432     psF32 env_wind = psMetadataLookupF32(&status, config->args, "-env_wind_speed");
    1433     if (!status) {
    1434         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -env_wind_speed");
    1435         return false;
    1436     }
    1437     psF32 env_dir = psMetadataLookupF32(&status, config->args, "-env_wind_dir");
    1438     if (!status) {
    1439         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -env_wind_dir");
    1440         return false;
    1441     }
    1442 
    1443     psF32 teltemp_m1 = psMetadataLookupF32(&status, config->args, "-teltemp_m1");
    1444     if (!status) {
    1445         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -teltemp_m1");
    1446         return false;
    1447     }
    1448     psF32 teltemp_m1cell = psMetadataLookupF32(&status, config->args, "-teltemp_m1cell");
    1449     if (!status) {
    1450         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -teltemp_m1cell");
    1451         return false;
    1452     }
    1453     psF32 teltemp_m2 = psMetadataLookupF32(&status, config->args, "-teltemp_m2");
    1454     if (!status) {
    1455         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -teltemp_m2");
    1456         return false;
    1457     }
    1458     psF32 teltemp_spider = psMetadataLookupF32(&status, config->args, "-teltemp_spider");
    1459     if (!status) {
    1460         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -teltemp_spider");
    1461         return false;
    1462     }
    1463     psF32 teltemp_truss = psMetadataLookupF32(&status, config->args, "-teltemp_truss");
    1464     if (!status) {
    1465         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -teltemp_truss");
    1466         return false;
    1467     }
    1468     psF32 teltemp_extra = psMetadataLookupF32(&status, config->args, "-teltemp_extra");
    1469     if (!status) {
    1470         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -teltemp_extra");
    1471         return false;
    1472     }
    1473 
    1474     psF32 pon_time = psMetadataLookupF32(&status, config->args, "-pon_time");
    1475     if (!status) {
    1476         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -pon_time");
    1477         return false;
    1478     }
    1479 
    1480     psF64 user_1 = psMetadataLookupF64(&status, config->args, "-user_1");
    1481     if (!status) {
    1482         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_1");
    1483         return false;
    1484     }
    1485     psF64 user_2 = psMetadataLookupF64(&status, config->args, "-user_2");
    1486     if (!status) {
    1487         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_2");
    1488         return false;
    1489     }
    1490     psF64 user_3 = psMetadataLookupF64(&status, config->args, "-user_3");
    1491     if (!status) {
    1492         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_3");
    1493         return false;
    1494     }
    1495     psF64 user_4 = psMetadataLookupF64(&status, config->args, "-user_4");
    1496     if (!status) {
    1497         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_4");
    1498         return false;
    1499     }
    1500     psF64 user_5 = psMetadataLookupF64(&status, config->args, "-user_5");
    1501     if (!status) {
    1502         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_5");
    1503         return false;
    1504     }
    1505 
    1506     psString object = psMetadataLookupStr(&status, config->args, "-object");
    1507     if (!status) {
    1508         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -object");
    1509         return false;
    1510     }
    1511 
    1512     psTime *dateobs = NULL;
    1513     {
    1514         psString dateobsStr = psMetadataLookupStr(&status, config->args, "-dateobs");
    1515         if (!status) {
    1516             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -dateobs");
    1517             return false;
    1518         }
    1519         // pass through NULL as this is an optional field
    1520         if (dateobsStr) {
    1521             dateobs = psTimeFromISO(dateobsStr, PS_TIME_UTC);
    1522         } else {
    1523             dateobs = NULL;
    1524         }
    1525     }
    1526 
    1527     // default
    1528     psS16 code = psMetadataLookupS16(&status, config->args, "-code");
    1529     if (!status) {
    1530         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -code");
    1531         return false;
    1532     }
    1533 
    1534     rawExpRow *raw = rawExpRowAlloc(
    1535         exp->exp_id,
     623    // carry through these values
     624    // new CLI options overwrite existing values
     625    workdir   = workdir ? workdir : newExp->workdir;
     626    reduction = reduction ? reduction : newExp->reduction;
     627    dvodb     = dvodb ? dvodb : newExp->dvodb;
     628    tess_id   = tess_id ? tess_id : newExp->tess_id;
     629    end_stage = end_stage ? end_stage : newExp->end_stage;
     630
     631    psFree(newExp);
     632
     633    if (!rawExpInsert(config->dbh,
     634        (psS64)atoll(exp_id),
    1536635        exp_name,
    1537636        camera,
    … …  
    1541640        exp_type,
    1542641        filelevel,
    1543         workdir ? workdir : exp->workdir,
    1544         reduction ? reduction : exp->reduction,
     642        workdir,
     643        reduction,
     644        dvodb,
     645        tess_id,
     646        end_stage,
    1545647        filter,
    1546         comment,
     648        comment,
    1547649        airmass,
    1548650        ra,
    … …  
    1557659        ccd_temp,
    1558660        posang,
    1559         m1_x,
    1560         m1_y,
    1561         m1_z,
    1562         m1_tip,
    1563         m1_tilt,
    1564         m2_x,
    1565         m2_y,
    1566         m2_z,
    1567         m2_tip,
    1568         m2_tilt,
    1569         env_temp,
    1570         env_humid,
    1571         env_wind,
    1572         env_dir,
    1573         teltemp_m1,
    1574         teltemp_m1cell,
    1575         teltemp_m2,
    1576         teltemp_spider,
    1577         teltemp_truss,
    1578         teltemp_extra,
    1579         pon_time,
     661        m1_x,
     662        m1_y,
     663        m1_z,
     664        m1_tip,
     665        m1_tilt,
     666        m2_x,
     667        m2_y,
     668        m2_z,
     669        m2_tip,
     670        m2_tilt,
     671        env_temp,
     672        env_humid,
     673        env_wind,
     674        env_dir,
     675        teltemp_m1,
     676        teltemp_m1cell,
     677        teltemp_m2,
     678        teltemp_spider,
     679        teltemp_truss,
     680        teltemp_extra,
     681        pon_time,
    1580682        user_1,
    1581683        user_2,
    … …  
    1586688        0.0,
    1587689        code
    1588     );
    1589 
    1590     if (dateobs) {
    1591         psFree(dateobs);
    1592     }
    1593 
    1594     return raw;
    1595 }
     690    )) {
     691        // rollback
     692        if (!psDBRollback(config->dbh)) {
     693            psError(PS_ERR_UNKNOWN, false, "database error");
     694        }
     695        psError(PS_ERR_UNKNOWN, false, "database error");
     696        return false;
     697    }
     698
     699    // set the state for the newExp to stop
     700    if (!pxnewExpSetState(config, exp_id, "stop")) {
     701        // rollback
     702        if (!psDBRollback(config->dbh)) {
     703            psError(PS_ERR_UNKNOWN, false, "database error");
     704        }
     705        psError(PS_ERR_UNKNOWN, false, "failed to change newExp.state for exp_id: %s", exp_id);
     706        return false;
     707    }
     708
     709    // should we stop here and proceed on to the chip stage?
     710    if (psStrcasestr(end_stage, "reg")) {
     711        // then we are done here
     712        if (!psDBCommit(config->dbh)) {
     713            psError(PS_ERR_UNKNOWN, false, "database error");
     714            return false;
     715        }
     716
     717        return true;
     718    }
     719    // else continue on...
     720
     721
     722    // insert an entry into the chipPendingExp table
     723    // this can only be run as the newExp's state has been set to stop
     724    if (!pxchipQueueByExpTag(config,
     725                (psS64)atoll(exp_id),
     726                workdir,
     727                NULL, // label
     728                reduction,
     729                NULL, // expgroup
     730                dvodb,
     731                tess_id,
     732                end_stage
     733    )) {
     734        // rollback
     735        if (!psDBRollback(config->dbh)) {
     736            psError(PS_ERR_UNKNOWN, false, "database error");
     737        }
     738        psError(PS_ERR_UNKNOWN, false, "failed to queue chipPendingExp");
     739        return false;
     740    }
     741
     742    if (!psDBCommit(config->dbh)) {
     743        psError(PS_ERR_UNKNOWN, false, "database error");
     744        return false;
     745    }
     746
     747    return true;
     748}
     749
     750
     751static bool processedexpMode(pxConfig *config)
     752{
     753    PS_ASSERT_PTR_NON_NULL(config, false);
     754
     755    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     756    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     757    PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
     758
     759    psString query = pxDataGet("regtool_processedexp.sql");
     760    if (!query) {
     761        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     762        return false;
     763    }
     764
     765    if (config->where) {
     766        psString whereClause = psDBGenerateWhereConditionSQL(config->where, "rawExp");
     767        psStringAppend(&query, " AND %s", whereClause);
     768        psFree(whereClause);
     769    }
     770
     771    if (faulted) {
     772        // list only faulted rows
     773        psStringAppend(&query, " %s", "AND rawExp.fault != 0");
     774    } else {
     775        // don't list faulted rows
     776        psStringAppend(&query, " %s", "AND rawExp.fault = 0");
     777    }
     778
     779    // treat limit == 0 as "no limit"
     780    if (limit) {
     781        psString limitString = psDBGenerateLimitSQL(limit);
     782        psStringAppend(&query, " %s", limitString);
     783        psFree(limitString);
     784    }
     785
     786    if (!p_psDBRunQuery(config->dbh, query)) {
     787        psError(PS_ERR_UNKNOWN, false, "database error");
     788        return false;
     789    }
     790    psFree(query);
     791
     792    psArray *output = p_psDBFetchResult(config->dbh);
     793    if (!output) {
     794        psErrorCode err = psErrorCodeLast();
     795        switch (err) {
     796            case PS_ERR_DB_CLIENT:
     797                psError(PXTOOLS_ERR_SYS, false, "database error");
     798            case PS_ERR_DB_SERVER:
     799                psError(PXTOOLS_ERR_PROG, false, "database error");
     800            default:
     801                psError(PXTOOLS_ERR_PROG, false, "unknown error");
     802        }
     803
     804        return false;
     805    }
     806    if (!psArrayLength(output)) {
     807        psTrace("regtool", PS_LOG_INFO, "no rows found");
     808        psFree(output);
     809        return true;
     810    }
     811
     812    if (psArrayLength(output)) {
     813        // negative simple so the default is true
     814        if (!ippdbPrintMetadatas(stdout, output, "rawExp", !simple)) {
     815            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     816            psFree(output);
     817            return false;
     818        }
     819    }
     820
     821    psFree(output);
     822
     823    return true;
     824}
     825
     826static bool revertprocessedexpMode(pxConfig *config)
     827{
     828    PS_ASSERT_PTR_NON_NULL(config, false);
     829
     830    psString query = pxDataGet("regtool_revertprocessedexp.sql");
     831    if (!query) {
     832        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     833        return false;
     834    }
     835
     836    if (config->where) {
     837        psString whereClause = psDBGenerateWhereConditionSQL(config->where, "rawExp");
     838        psStringAppend(&query, " AND %s", whereClause);
     839        psFree(whereClause);
     840    }
     841
     842    if (!p_psDBRunQuery(config->dbh, query)) {
     843        psError(PS_ERR_UNKNOWN, false, "database error");
     844        psFree(query);
     845        return false;
     846    }
     847    psFree(query);
     848
     849    if (psDBAffectedRows(config->dbh) < 1) {
     850        psError(PS_ERR_UNKNOWN, false, "should have affected atleast 1 row");
     851        return false;
     852    }
     853
     854    return true;
     855}
     856
     857
     858static bool updateprocessedexpMode(pxConfig *config)
     859{
     860    PS_ASSERT_PTR_NON_NULL(config, false);
     861
     862    PXOPT_LOOKUP_S16(code, config->args, "-code", true, false);
     863
     864    if (!pxSetFaultCode(config->dbh, "rawExp", config->where, code)) {
     865        psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag");
     866        return false;
     867    }
     868
     869    return true;
     870}

  • trunk/ippTools/src/regtoolConfig.c

    r15776 r16170  
    161161    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-object",  0,
    162162        "define exposure object", NULL);
    163     psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-dateobs",  0,
     163    psMetadataAddTime(addprocessedimfileArgs, PS_LIST_TAIL, "-dateobs",  0,
    164164        "define observation time", NULL);
    165165    psMetadataAddS16(addprocessedimfileArgs, PS_LIST_TAIL, "-code",  0,
    … …  
    226226    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-exp_tag",  0,
    227227        "define the external exposure tag name (required)", NULL);
    228     psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-dateobs",  0,
     228    psMetadataAddTime(addprocessedexpArgs, PS_LIST_TAIL, "-dateobs",  0,
    229229        "define observation time", NULL);
    230230    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-exp_type",  0,
    … …  
    234234    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-workdir",  0,
    235235        "define the \"default\" workdir for this exposure", NULL);
     236    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-dvodb",  0,
     237        "define the dvodb for the next processing step", NULL);
     238    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-tess_id",  0,
     239        "define the tess_id for the next processing step", NULL);
     240    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-end_stage",  0,
     241        "define the end goal processing step", NULL);
    236242    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-reduction",  0,
    237243        "define the \"default\" reduction class for this exposure", NULL);
    … …  
    328334        "define URL", NULL);
    329335    */
    330     psMetadataAddBool(addprocessedexpArgs, PS_LIST_TAIL, "-detrend",  0,
    331         "declare this as detrend data", false);
    332336
    333337    // -processedexp
    … …  
    360364    psMetadata *modes = psMetadataAlloc();
    361365
    362     PXTOOL_ADD_MODE("-pendingimfile",           "", REGTOOL_MODE_PENDINGIMFILE, pendingimfileArgs);
    363     PXTOOL_ADD_MODE("-addprocessedimfile",      "",  REGTOOL_MODE_ADDPROCESSEDIMFILE, addprocessedimfileArgs);
    364     PXTOOL_ADD_MODE("-processedimfile",         "", REGTOOL_MODE_PROCESSEDIMFILE, processedimfileArgs);
    365     PXTOOL_ADD_MODE("-revertprocessedimfile",   "", REGTOOL_MODE_REVERTPROCESSEDIMFILE, revertprocessedimfileArgs);
    366     PXTOOL_ADD_MODE("-updateprocessedimfile",   "",   REGTOOL_MODE_UPDATEPROCESSEDIMFILE, updateprocessedimfileArgs);
    367     PXTOOL_ADD_MODE("-pendingexp",              "",       REGTOOL_MODE_PENDINGEXP,pendingexpArgs);
    368     PXTOOL_ADD_MODE("-addprocessedexp",         "",  REGTOOL_MODE_ADDPROCESSEDEXP, addprocessedexpArgs);
    369     PXTOOL_ADD_MODE("-processedexp",            "",     REGTOOL_MODE_PROCESSEDEXP, processedexpArgs);
    370     PXTOOL_ADD_MODE("-revertprocessedexp",      "", REGTOOL_MODE_REVERTPROCESSEDEXP, revertprocessedexpArgs);
    371     PXTOOL_ADD_MODE("-updateprocessedexp",      "",  REGTOOL_MODE_UPDATEPROCESSEDEXP,      updatedprocessedexpArgs);
     366    PXOPT_ADD_MODE("-pendingimfile",           "", REGTOOL_MODE_PENDINGIMFILE, pendingimfileArgs);
     367    PXOPT_ADD_MODE("-addprocessedimfile",      "",  REGTOOL_MODE_ADDPROCESSEDIMFILE, addprocessedimfileArgs);
     368    PXOPT_ADD_MODE("-processedimfile",         "", REGTOOL_MODE_PROCESSEDIMFILE, processedimfileArgs);
     369    PXOPT_ADD_MODE("-revertprocessedimfile",   "", REGTOOL_MODE_REVERTPROCESSEDIMFILE, revertprocessedimfileArgs);
     370    PXOPT_ADD_MODE("-updateprocessedimfile",   "",   REGTOOL_MODE_UPDATEPROCESSEDIMFILE, updateprocessedimfileArgs);
     371    PXOPT_ADD_MODE("-pendingexp",              "",       REGTOOL_MODE_PENDINGEXP,pendingexpArgs);
     372    PXOPT_ADD_MODE("-addprocessedexp",         "",  REGTOOL_MODE_ADDPROCESSEDEXP, addprocessedexpArgs);
     373    PXOPT_ADD_MODE("-processedexp",            "",     REGTOOL_MODE_PROCESSEDEXP, processedexpArgs);
     374    PXOPT_ADD_MODE("-revertprocessedexp",      "", REGTOOL_MODE_REVERTPROCESSEDEXP, revertprocessedexpArgs);
     375    PXOPT_ADD_MODE("-updateprocessedexp",      "",  REGTOOL_MODE_UPDATEPROCESSEDEXP,      updatedprocessedexpArgs);
    372376
    373377    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {

  • trunk/ippTools/src/stacktool.c

    r15376 r16170  
    9595
    9696    // required options
    97     bool status = false;
    98     psString workdir = psMetadataLookupStr(&status, config->args, "-workdir");
    99     if (!status) {
    100         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -workdir");
    101         return false;
    102     }
    103     if (!workdir) {
    104         psError(PS_ERR_UNKNOWN, true, "-workdir is required");
    105         return false;
    106     }
    107 
    108     psString skycell_id = psMetadataLookupStr(&status, config->args, "-skycell_id");
    109     if (!status) {
    110         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -skycell_id");
    111         return false;
    112     }
    113     if (!skycell_id) {
    114         psError(PS_ERR_UNKNOWN, true, "-skycell_id is required");
    115         return false;
    116     }
    117 
    118     psString tess_id = psMetadataLookupStr(&status, config->args, "-tess_id");
    119     if (!status) {
    120         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -tess_id");
    121         return false;
    122     }
    123     if (!tess_id) {
    124         psError(PS_ERR_UNKNOWN, true, "-tess_id is required");
    125         return false;
    126     }
     97    PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false);
     98    PXOPT_LOOKUP_STR(skycell_id, config->args, "-skycell_id", true, false);
     99    PXOPT_LOOKUP_STR(tess_id, config->args, "-tess_id", true, false);
     100
     101    // default
     102    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     103    PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
    127104
    128105    // we have to support multipe exp_ids
    … …  
    132109        psError(PS_ERR_UNKNOWN, true, "-warp_id is required");
    133110        return false;
    134     }
    135 
    136     psTime *registered = NULL;
    137     {
    138         psString registeredStr = psMetadataLookupStr(&status, config->args, "-registered");
    139         if (!status) {
    140             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -registered");
    141             return false;
    142         }
    143         // pass through NULL as this is an optional field
    144         if (registeredStr) {
    145             registered = psTimeFromISO(registeredStr, PS_TIME_UTC);
    146         } else {
    147             registered = NULL;
    148         }
    149111    }
    150112
    … …  
    158120            tess_id
    159121    );
    160     psFree(registered);
    161122    if (!run) {
    162123        psError(PS_ERR_UNKNOWN, false, "failed to alloc stackRun object");
    … …  
    210171    }
    211172
    212     bool simple = false;
    213     {
    214         bool status = false;
    215         simple = psMetadataLookupBool(&status, config->args, "-simple");
    216         if (!status) {
    217             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    218             psFree(run);
    219             return false;
    220         }
    221     }
    222 
    223173    if (!stackRunPrintObject(stdout, run, !simple)) {
    224174            psError(PS_ERR_UNKNOWN, false, "failed to print object");
    … …  
    237187    PS_ASSERT_PTR_NON_NULL(config, false);
    238188
    239     bool status = false;
    240     psString stack_id = psMetadataLookupStr(&status, config->args, "-stack_id");
    241     if (!status) {
    242         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -stack_id");
    243         return false;
    244     }
    245     if (!stack_id) {
    246         psError(PS_ERR_UNKNOWN, true, "-stack_id is required");
    247         return false;
    248     }
    249 
    250     psString state = psMetadataLookupStr(&status, config->args, "-state");
    251     if (!status) {
    252         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -state");
    253         return false;
    254     }
    255     if (!state) {
    256         psError(PS_ERR_UNKNOWN, true, "-state is required");
    257         return false;
    258     }
     189    PXOPT_LOOKUP_STR(stack_id, config->args, "-stack_id", true, false);
     190    PXOPT_LOOKUP_STR(state, config->args, "-state", true, false);
    259191
    260192    if (state) {
    … …  
    271203    PS_ASSERT_PTR_NON_NULL(config, false);
    272204
    273     bool status = false;
    274     psString stack_id = psMetadataLookupStr(&status, config->args, "-stack_id");
    275     if (!status) {
    276         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -stack_id");
    277         return false;
    278     }
    279     if (!stack_id) {
    280         psError(PS_ERR_UNKNOWN, true, "-stack_id is required");
    281         return false;
    282 
    283     }
    284 
    285     psString warp_id = psMetadataLookupStr(&status, config->args, "-warp_id");
    286     if (!status) {
    287         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -warp_id");
    288         return false;
    289     }
    290     if (!warp_id) {
    291         psError(PS_ERR_UNKNOWN, true, "-warp_id is required");
    292         return false;
    293     }
    294 
     205    PXOPT_LOOKUP_STR(stack_id, config->args, "-stack_id", true, false);
     206    PXOPT_LOOKUP_STR(warp_id, config->args, "-warp_id", true, false);
    295207
    296208    // XXX need to validate the warp_id here
    … …  
    313225    PS_ASSERT_PTR_NON_NULL(config, false);
    314226
    315     bool status = false;
    316     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    317     if (!status) {
    318         psError(PXTOOLS_ERR_PROG, false, "failed to lookup value for -limit");
    319         return false;
    320     }
     227    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     228    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    321229
    322230    psString query = pxDataGet("stacktool_inputskyfile.sql");
    … …  
    366274    }
    367275
    368     bool simple = false;
    369     {
    370         bool status = false;
    371         simple = psMetadataLookupBool(&status, config->args, "-simple");
    372         if (!status) {
    373             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    374             return false;
    375         }
    376     }
    377 
    378276    if (psArrayLength(output)) {
    379277        if (!convertIdToStr(output)) {
    … …  
    401299    PS_ASSERT_PTR_NON_NULL(config, false);
    402300
    403     bool status = false;
    404     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    405     if (!status) {
    406         psError(PXTOOLS_ERR_PROG, false, "failed to lookup value for -limit");
    407         return false;
    408     }
     301    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     302    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    409303
    410304    psString query = pxDataGet("stacktool_tosum.sql");
    … …  
    454348    }
    455349
    456     bool simple = false;
    457     {
    458         bool status = false;
    459         simple = psMetadataLookupBool(&status, config->args, "-simple");
    460         if (!status) {
    461             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    462             return false;
    463         }
    464     }
    465 
    466350    if (psArrayLength(output)) {
    467351        if (!convertIdToStr(output)) {
    … …  
    489373    PS_ASSERT_PTR_NON_NULL(config, false);
    490374
    491     bool status = false;
    492     psString stack_id = psMetadataLookupStr(&status, config->args, "-stack_id");
    493     if (!status) {
    494         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -stack_id");
    495         return false;
    496     }
    497     if (!stack_id) {
    498         psError(PS_ERR_UNKNOWN, true, "-stack_id is required");
    499         return false;
    500 
    501     }
    502 
    503     psString uri = psMetadataLookupStr(&status, config->args, "-uri");
    504     if (!status) {
    505         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -uri");
    506         return false;
    507     }
    508 
    509     psString path_base = psMetadataLookupStr(&status, config->args, "-path_base");
    510     if (!status) {
    511         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -path_base");
    512         return false;
    513     }
     375    // required
     376    PXOPT_LOOKUP_STR(stack_id, config->args, "-stack_id", true, false);
    514377
    515378    // optional
    516     psF64 bg = psMetadataLookupF64(&status, config->args, "-bg");
    517     if (!status) {
    518         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg");
    519         return false;
    520     }
    521 
    522     psF64 bg_stdev = psMetadataLookupF64(&status, config->args, "-bg_stdev");
    523     if (!status) {
    524         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg_stdev");
    525         return false;
    526     }
    527 
    528     psF64 good_frac = psMetadataLookupF64(&status, config->args, "-good_frac");
    529     if (!status) {
    530         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -good_frac");
    531         return false;
    532     }
     379    PXOPT_LOOKUP_STR(uri, config->args, "-uri", false, false);
     380    PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", false, false);
     381    PXOPT_LOOKUP_F64(bg, config->args, "-bg", false, false);
     382    PXOPT_LOOKUP_F64(bg_stdev, config->args, "-bg_stdev", false, false);
     383    PXOPT_LOOKUP_F64(good_frac, config->args, "-good_frac", false, false);
    533384
    534385    // default values
    535     psS16 code = psMetadataLookupS16(&status, config->args, "-code");
    536     if (!status) {
    537         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -code");
    538         return false;
    539     }
     386    PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
    540387
    541388    if (!psDBTransaction(config->dbh)) {
    … …  
    585432    PS_ASSERT_PTR_NON_NULL(config, false);
    586433
    587     bool status = false;
    588     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    589     if (!status) {
    590         psError(PXTOOLS_ERR_PROG, false, "failed to lookup value for -limit");
    591         return false;
    592     }
     434    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     435    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    593436
    594437    psString query = pxDataGet("stacktool_sumskyfile.sql");
    … …  
    638481    }
    639482
    640     bool simple = false;
    641     {
    642         bool status = false;
    643         simple = psMetadataLookupBool(&status, config->args, "-simple");
    644         if (!status) {
    645             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    646             return false;
    647         }
    648     }
    649 
    650483    if (psArrayLength(output)) {
    651484        if (!convertIdToStr(output)) {

  • trunk/ippTools/src/stacktoolConfig.c

    r15376 r16170  
    4343    }
    4444
    45     psTime *time = psTimeGetNow(PS_TIME_TAI);
    46     psString now = psTimeToISO(time);
    47     psFree(time);
     45    psTime *now = psTimeGetNow(PS_TIME_TAI);
    4846
    4947    // -definerun
    … …  
    5149    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-workdir", 0,
    5250            "define workdir (required)", NULL);
    53     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-registered",  0,
     51    psMetadataAddTime(definerunArgs, PS_LIST_TAIL, "-registered",  0,
    5452            "time detrend run was registered", now);
    5553    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-skycell_id",  0,
    … …  
    146144    psMetadata *modes   = psMetadataAlloc();
    147145
    148     PXTOOL_ADD_MODE("-definerun",       "", STACKTOOL_MODE_DEFINERUN,      definerunArgs);
    149     PXTOOL_ADD_MODE("-updaterun",       "", STACKTOOL_MODE_UPDATERUN,      updaterunArgs);
    150     PXTOOL_ADD_MODE("-addinputskyfile", "", STACKTOOL_MODE_ADDINPUTSKYFILE, addinputskyfileArgs);
    151     PXTOOL_ADD_MODE("-inputskyfile",    "", STACKTOOL_MODE_INPUTSKYFILE,    inputskyfileArgs);
    152     PXTOOL_ADD_MODE("-tosum",           "", STACKTOOL_MODE_TOSUM,          tosumArgs);
    153     PXTOOL_ADD_MODE("-addsumskyfile",   "", STACKTOOL_MODE_ADDSUMSKYFILE,   addsumskyfileArgs);
    154     PXTOOL_ADD_MODE("-sumskyfile",      "", STACKTOOL_MODE_SUMSKYFILE,      sumskyfileArgs);
    155     PXTOOL_ADD_MODE("-revertsumskyfile","", STACKTOOL_MODE_REVERTSUMSKYFILE,      revertsumskyfileArgs);
     146    PXOPT_ADD_MODE("-definerun",       "", STACKTOOL_MODE_DEFINERUN,      definerunArgs);
     147    PXOPT_ADD_MODE("-updaterun",       "", STACKTOOL_MODE_UPDATERUN,      updaterunArgs);
     148    PXOPT_ADD_MODE("-addinputskyfile", "", STACKTOOL_MODE_ADDINPUTSKYFILE, addinputskyfileArgs);
     149    PXOPT_ADD_MODE("-inputskyfile",    "", STACKTOOL_MODE_INPUTSKYFILE,    inputskyfileArgs);
     150    PXOPT_ADD_MODE("-tosum",           "", STACKTOOL_MODE_TOSUM,          tosumArgs);
     151    PXOPT_ADD_MODE("-addsumskyfile",   "", STACKTOOL_MODE_ADDSUMSKYFILE,   addsumskyfileArgs);
     152    PXOPT_ADD_MODE("-sumskyfile",      "", STACKTOOL_MODE_SUMSKYFILE,      sumskyfileArgs);
     153    PXOPT_ADD_MODE("-revertsumskyfile","", STACKTOOL_MODE_REVERTSUMSKYFILE,      revertsumskyfileArgs);
    156154
    157155    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {

  • trunk/ippTools/src/warptool.c

    r15532 r16170  
    108108
    109109    // required options
    110     bool status = false;
    111     psString mode = psMetadataLookupStr(&status, config->args, "-mode");
    112     if (!status) {
    113         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -survey_mode");
    114         return false;
    115     }
    116     if (!mode) {
    117         psError(PS_ERR_UNKNOWN, true, "-mode is required");
    118         return false;
    119     }
     110    PXOPT_LOOKUP_STR(mode, config->args, "-mode", true, false);
    120111    // check mode
    121112    if (mode && !isValidMode(config, mode)) {
    … …  
    123114        return false;
    124115    }
    125 
    126     psString workdir = psMetadataLookupStr(&status, config->args, "-workdir");
    127     if (!status) {
    128         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -workdir");
    129         return false;
    130     }
    131     if (!workdir) {
    132         psError(PS_ERR_UNKNOWN, true, "-workdir is required");
    133         return false;
    134     }
    135 
    136     psTime *registered = NULL;
    137     {
    138         psString registeredStr = psMetadataLookupStr(&status, config->args, "-registered");
    139         if (!status) {
    140             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -registered");
    141             return false;
    142         }
    143         // pass through NULL as this is an optional field
    144         if (registeredStr) {
    145             registered = psTimeFromISO(registeredStr, PS_TIME_UTC);
    146         } else {
    147             registered = NULL;
    148         }
    149     }
     116    PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false);
     117
     118    // optional
     119    PXOPT_LOOKUP_STR(dvodb, config->args, "-dvodb", false, false);
     120    PXOPT_LOOKUP_STR(tess_id, config->args, "-tess_id", false, false);
     121    PXOPT_LOOKUP_STR(end_stage, config->args, "-end_stage", false, false);
     122
     123    // default
     124    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     125    PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
    150126
    151127    warpRunRow *warpRun = warpRunRowAlloc(
    … …  
    154130            "reg",      // state
    155131            workdir,
    156             NULL,       // dvodb
     132            "dirty",    // workdir_state
     133            dvodb,
     134            tess_id,
     135            end_stage,
    157136            registered
    158137    );
    159     psFree(registered);
    160138    if (!warpRun) {
    161139        psError(PS_ERR_UNKNOWN, false, "failed to alloc warpRun object");
    … …  
    171149    psS64 warp_id = psDBLastInsertID(config->dbh);
    172150    warpRun->warp_id = warp_id;
    173 
    174     bool simple = false;
    175     {
    176         bool status = false;
    177         simple = psMetadataLookupBool(&status, config->args, "-simple");
    178         if (!status) {
    179             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    180             psFree(warpRun);
    181             return false;
    182         }
    183     }
    184151
    185152    if (!warpRunPrintObject(stdout, warpRun, !simple)) {
    … …  
    255222    PS_ASSERT_PTR_NON_NULL(config, false);
    256223
    257     bool status = false;
    258     psString warp_id = psMetadataLookupStr(&status, config->args, "-warp_id");
    259     if (!status) {
    260         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -warpt_id");
    261         return false;
    262     }
    263     if (!warp_id) {
    264         psError(PS_ERR_UNKNOWN, true, "-warp_id is required");
    265         return false;
    266     }
    267 
    268     psString state = psMetadataLookupStr(&status, config->args, "-state");
    269     if (!status) {
    270         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -state");
    271         return false;
    272     }
    273     if (!state) {
    274         psError(PS_ERR_UNKNOWN, true, "-state is required");
    275         return false;
    276     }
     224    PXOPT_LOOKUP_STR(warp_id, config->args, "-warp_id", true, false);
     225    PXOPT_LOOKUP_STR(state, config->args, "-state", true, false);
    277226
    278227    if (state) {
    … …  
    289238    PS_ASSERT_PTR_NON_NULL(config, false);
    290239
    291     bool status = false;
    292     psString warp_id = psMetadataLookupStr(&status, config->args, "-warp_id");
    293     if (!status) {
    294         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -warp_id");
    295         return false;
    296     }
    297     if (!warp_id) {
    298         psError(PS_ERR_UNKNOWN, true, "-warp_id is required");
    299         return false;
    300     }
    301 
    302     psString cam_id = psMetadataLookupStr(&status, config->args, "-cam_id");
    303     if (!status) {
    304         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -cam_id");
    305         return false;
    306     }
    307     if (!cam_id) {
    308         psError(PS_ERR_UNKNOWN, true, "-cam_id is required");
    309         return false;
    310     }
     240    PXOPT_LOOKUP_STR(warp_id, config->args, "-warp_id", true, false);
     241    PXOPT_LOOKUP_STR(cam_id, config->args, "-cam_id", true, false);
    311242
    312243    // defaults to false
    313     bool magiced = psMetadataLookupBool(&status, config->args, "-magiced");
    314     if (!status) {
    315         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -magiced");
    316         return false;
    317     }
    318 
    319     // XXX need to validate the warp_id here
    320     // XXX instead of validiting it here we should just use forgein key
    321     // constrants
     244    PXOPT_LOOKUP_BOOL(magiced, config->args, "-magiced", false);
     245
    322246    if (!warpInputExpInsert(config->dbh,
    323247            (psS64)atoll(warp_id),
    … …  
    337261    PS_ASSERT_PTR_NON_NULL(config, false);
    338262
    339     bool status = false;
    340     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    341     if (!status) {
    342         psError(PXTOOLS_ERR_PROG, false, "failed to lookup value for -limit");
    343         return false;
    344     }
     263    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     264    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    345265
    346266    // find all rawImfiles matching the default query
    … …  
    391311    }
    392312
    393     bool simple = false;
    394     {
    395         bool status = false;
    396         simple = psMetadataLookupBool(&status, config->args, "-simple");
    397         if (!status) {
    398             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    399             return false;
    400         }
    401     }
    402 
    403313    if (psArrayLength(output)) {
    404314        if (!convertIdToStr(output)) {
    … …  
    426336    PS_ASSERT_PTR_NON_NULL(config, false);
    427337
    428     bool status = false;
    429     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    430     if (!status) {
    431         psError(PXTOOLS_ERR_PROG, false, "failed to lookup value for -limit");
    432         return false;
    433     }
     338    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     339    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    434340
    435341    // find all rawImfiles matching the default query
    … …  
    480386    }
    481387
    482     bool simple = false;
    483     {
    484         bool status = false;
    485         simple = psMetadataLookupBool(&status, config->args, "-simple");
    486         if (!status) {
    487             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    488             return false;
    489         }
    490     }
    491 
    492388    if (psArrayLength(output)) {
    493389        if (!convertIdToStr(output)) {
    … …  
    515411    PS_ASSERT_PTR_NON_NULL(config, false);
    516412
    517     bool status = false;
    518     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    519     if (!status) {
    520         psError(PXTOOLS_ERR_PROG, false, "failed to lookup value for -limit");
    521         return false;
    522     }
     413    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     414    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    523415
    524416    // find all rawImfiles matching the default query
    … …  
    569461    }
    570462
    571     bool simple = false;
    572     {
    573         bool status = false;
    574         simple = psMetadataLookupBool(&status, config->args, "-simple");
    575         if (!status) {
    576             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    577             return false;
    578         }
    579     }
    580 
    581463    if (psArrayLength(output)) {
    582464        if (!convertIdToStr(output)) {
    … …  
    599481}
    600482
    601 
     483   
    602484static bool addoverlapMode(pxConfig *config)
    603485{
    604486    PS_ASSERT_PTR_NON_NULL(config, false);
    605487
    606     bool status = false;
    607     psString mapfile = psMetadataLookupStr(&status, config->args, "-mapfile");
    608     if (!status) {
    609         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -mapfile");
    610         return false;
    611     }
    612     if (!mapfile) {
    613         psError(PS_ERR_UNKNOWN, true, "-mapfile is required");
    614         return false;
    615     }
     488    PXOPT_LOOKUP_STR(mapfile, config->args, "-mapfile", false, false);
    616489
    617490    if (!psDBTransaction(config->dbh)) {
    … …  
    703576    PS_ASSERT_PTR_NON_NULL(config, false);
    704577
    705     bool status = false;
    706     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    707     if (!status) {
    708         psError(PXTOOLS_ERR_PROG, false, "failed to lookup value for -limit");
    709         return false;
    710     }
     578    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     579    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    711580
    712581    // find all rawImfiles matching the default query
    … …  
    757626    }
    758627
    759     bool simple = false;
    760     {
    761         bool status = false;
    762         simple = psMetadataLookupBool(&status, config->args, "-simple");
    763         if (!status) {
    764             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    765             return false;
    766         }
    767     }
    768 
    769628    if (psArrayLength(output)) {
    770629        if (!convertIdToStr(output)) {
    … …  
    792651    PS_ASSERT_PTR_NON_NULL(config, false);
    793652
    794     bool status = false;
    795     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    796     if (!status) {
    797         psError(PXTOOLS_ERR_PROG, false, "failed to lookup value for -limit");
    798         return false;
    799     }
     653    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     654    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    800655
    801656    // find all rawImfiles matching the default query
    … …  
    846701    }
    847702
    848     bool simple = false;
    849     {
    850         bool status = false;
    851         simple = psMetadataLookupBool(&status, config->args, "-simple");
    852         if (!status) {
    853             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    854             return false;
    855         }
    856     }
    857 
    858703    if (psArrayLength(output)) {
    859704        if (!convertIdToStr(output)) {
    … …  
    881726    PS_ASSERT_PTR_NON_NULL(config, false);
    882727
    883     bool status = false;
    884     psString warp_id = psMetadataLookupStr(&status, config->args, "-warp_id");
    885     if (!status) {
    886         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -warp_id");
    887         return false;
    888     }
    889     if (!warp_id) {
    890         psError(PS_ERR_UNKNOWN, true, "-warp_id is required");
    891         return false;
    892     }
    893 
    894     psString skycell_id = psMetadataLookupStr(&status, config->args, "-skycell_id");
    895     if (!status) {
    896         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -skycell_id");
    897         return false;
    898     }
    899     if (!skycell_id) {
    900         psError(PS_ERR_UNKNOWN, true, "-skycell_id is required");
    901         return false;
    902     }
    903 
    904     psString tess_id = psMetadataLookupStr(&status, config->args, "-tess_id");
    905     if (!status) {
    906         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -tess_id");
    907         return false;
    908     }
    909     if (!tess_id) {
    910         psError(PS_ERR_UNKNOWN, true, "-tess_id is required");
    911         return false;
    912     }
    913 
    914     psString uri = psMetadataLookupStr(&status, config->args, "-uri");
    915     if (!status) {
    916         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -uri");
    917         return false;
    918     }
    919 
    920     psString path_base = psMetadataLookupStr(&status, config->args, "-path_base");
    921     if (!status) {
    922         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -path_base");
    923         return false;
    924     }
     728    PXOPT_LOOKUP_STR(warp_id, config->args, "-warp_id", true, false);
     729    PXOPT_LOOKUP_STR(skycell_id, config->args, "-skycell_id", true, false);
     730    PXOPT_LOOKUP_STR(tess_id, config->args, "-tess_id", true, false);
    925731
    926732    // optional
    927     psF64 bg = psMetadataLookupF64(&status, config->args, "-bg");
    928     if (!status) {
    929         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg");
    930         return false;
    931     }
    932 
    933     psF64 bg_stdev = psMetadataLookupF64(&status, config->args, "-bg_stdev");
    934     if (!status) {
    935         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg_stdev");
    936         return false;
    937     }
    938 
    939     psF64 good_frac = psMetadataLookupF64(&status, config->args, "-good_frac");
    940     if (!status) {
    941         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -good_frac");
    942         return false;
    943     }
    944 
    945     bool ignore = psMetadataLookupBool(&status, config->args, "-ignore");
    946     if (!status) {
    947         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -ignore");
    948         return false;
    949     }
     733    PXOPT_LOOKUP_STR(uri, config->args, "-uri", false, false);
     734    PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", false, false);
     735    PXOPT_LOOKUP_F64(bg, config->args, "-bg", false, false);
     736    PXOPT_LOOKUP_F64(bg_stdev, config->args, "-bg_stdev", false, false);
     737    PXOPT_LOOKUP_F64(good_frac, config->args, "-good_frac", false, false);
     738    PXOPT_LOOKUP_BOOL(ignore, config->args, "-ignore", false);
    950739
    951740    // default values
    952     psS16 code = psMetadataLookupS16(&status, config->args, "-code");
    953     if (!status) {
    954         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -code");
    955         return false;
    956     }
     741    PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
    957742
    958743    // we don't want to insert the last skyfile in a run but then not mark the
    … …  
    1071856        "       USING(warp_id)\n"
    1072857        "   LEFT JOIN warpSkyfile\n"
    1073         "       USING(warp_id, skycell_id, tess_id)\n"
     858        "       USING(warp_id, skycell_id)\n"
    1074859        "   WHERE\n"
    1075860        "       warpRun.state = 'run'\n"
    … …  
    1111896    PS_ASSERT_PTR_NON_NULL(config, false);
    1112897
    1113     bool status = false;
    1114     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    1115     if (!status) {
    1116         psError(PXTOOLS_ERR_PROG, false, "failed to lookup value for -limit");
    1117         return false;
    1118     }
     898    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     899    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    1119900
    1120901    // find all rawImfiles matching the default query
    … …  
    1165946    }
    1166947
    1167     bool simple = false;
    1168     {
    1169         bool status = false;
    1170         simple = psMetadataLookupBool(&status, config->args, "-simple");
    1171         if (!status) {
    1172             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    1173             return false;
    1174         }
    1175     }
    1176 
    1177948    if (psArrayLength(output)) {
    1178949        if (!convertIdToStr(output)) {

  • trunk/ippTools/src/warptoolConfig.c

    r15532 r16170  
    4545    }
    4646
    47     psTime *time = psTimeGetNow(PS_TIME_TAI);
    48     psString now = psTimeToISO(time);
    49     psFree(time);
     47    psTime *now = psTimeGetNow(PS_TIME_TAI);
    5048
    5149    // -definerun
    … …  
    5553    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-workdir", 0,
    5654            "define workdir (required)", NULL);
    57     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-registered",  0,
     55    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-dvodb", 0,
     56            "define dvodb", NULL);
     57    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-tess_id", 0,
     58            "define tess_id", NULL);
     59    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-end_stage", 0,
     60            "define end stage", NULL);
     61    psMetadataAddTime(definerunArgs, PS_LIST_TAIL, "-registered",  0,
    5862            "time detrend run was registered", now);
    5963    psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-simple",  0,
    … …  
    6670    psMetadataAddStr(runoneArgs, PS_LIST_TAIL, "-workdir", 0,
    6771            "define workdir (required)", NULL);
    68     psMetadataAddStr(runoneArgs, PS_LIST_TAIL, "-registered",  0,
     72    psMetadataAddTime(runoneArgs, PS_LIST_TAIL, "-registered",  0,
    6973            "time detrend run was registered", now);
    7074    psMetadataAddStr(runoneArgs, PS_LIST_TAIL, "-cam_id", 0,
    … …  
    212216    psMetadata *modes   = psMetadataAlloc();
    213217
    214     PXTOOL_ADD_MODE("-definerun",       "", WARPTOOL_MODE_DEFINERUN,      definerunArgs);
    215     PXTOOL_ADD_MODE("-runone",          "", WARPTOOL_MODE_RUNONE,         runoneArgs);
    216     PXTOOL_ADD_MODE("-updaterun",       "", WARPTOOL_MODE_UPDATERUN,      updaterunArgs);
    217     PXTOOL_ADD_MODE("-addinputexp",     "", WARPTOOL_MODE_ADDINPUTEXP,    addinputexpArgs);
    218     PXTOOL_ADD_MODE("-exp",             "", WARPTOOL_MODE_EXP,            expArgs);
    219     PXTOOL_ADD_MODE("-imfile",          "", WARPTOOL_MODE_IMFILE,         imfileArgs);
    220     PXTOOL_ADD_MODE("-tooverlap",       "", WARPTOOL_MODE_TOOVERLAP,      tooverlapArgs);
    221     PXTOOL_ADD_MODE("-addoverlap",      "", WARPTOOL_MODE_ADDOVERLAP,     addoverlapArgs);
    222     PXTOOL_ADD_MODE("-scmap",           "", WARPTOOL_MODE_SCMAP,          scmapArgs);
    223     PXTOOL_ADD_MODE("-towarped",        "", WARPTOOL_MODE_TOWARPED,       towarpedArgs);
    224     PXTOOL_ADD_MODE("-addwarped",       "", WARPTOOL_MODE_ADDWARPED,      addwarpedArgs);
    225     PXTOOL_ADD_MODE("-warped",          "", WARPTOOL_MODE_WARPED,         warpedArgs);
    226     PXTOOL_ADD_MODE("-revertwarped",    "", WARPTOOL_MODE_REVERTWARPED,   revertwarpedArgs);
     218    PXOPT_ADD_MODE("-definerun",       "", WARPTOOL_MODE_DEFINERUN,      definerunArgs);
     219    PXOPT_ADD_MODE("-runone",          "", WARPTOOL_MODE_RUNONE,         runoneArgs);
     220    PXOPT_ADD_MODE("-updaterun",       "", WARPTOOL_MODE_UPDATERUN,      updaterunArgs);
     221    PXOPT_ADD_MODE("-addinputexp",     "", WARPTOOL_MODE_ADDINPUTEXP,    addinputexpArgs);
     222    PXOPT_ADD_MODE("-exp",             "", WARPTOOL_MODE_EXP,            expArgs);
     223    PXOPT_ADD_MODE("-imfile",          "", WARPTOOL_MODE_IMFILE,         imfileArgs);
     224    PXOPT_ADD_MODE("-tooverlap",       "", WARPTOOL_MODE_TOOVERLAP,      tooverlapArgs);
     225    PXOPT_ADD_MODE("-addoverlap",      "", WARPTOOL_MODE_ADDOVERLAP,     addoverlapArgs);
     226    PXOPT_ADD_MODE("-scmap",           "", WARPTOOL_MODE_SCMAP,          scmapArgs);
     227    PXOPT_ADD_MODE("-towarped",        "", WARPTOOL_MODE_TOWARPED,       towarpedArgs);
     228    PXOPT_ADD_MODE("-addwarped",       "", WARPTOOL_MODE_ADDWARPED,      addwarpedArgs);
     229    PXOPT_ADD_MODE("-warped",          "", WARPTOOL_MODE_WARPED,         warpedArgs);
     230    PXOPT_ADD_MODE("-revertwarped",    "", WARPTOOL_MODE_REVERTWARPED,   revertwarpedArgs);
    227231
    228232    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {
Note: See TracChangeset for help on using the changeset viewer.