IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 11197


Ignore:
Timestamp:
Jan 19, 2007, 3:30:29 PM (19 years ago)
Author:
jhoblitt
Message:

implement dettool detRun.{_min, _max} range support

Location:
trunk/ippTools
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/ippTools/configure.ac

    r11142 r11197  
    1616PKG_CHECK_MODULES([PSLIB], [pslib >= 0.12.99])
    1717PKG_CHECK_MODULES([PSMODULES], [psmodules >= 0.12.0])
    18 PKG_CHECK_MODULES([IPPDB], [ippdb >= 0.0.77])
     18PKG_CHECK_MODULES([IPPDB], [ippdb >= 0.0.78])
    1919
    2020dnl check for PSDB support

  • trunk/ippTools/scripts/dettest.sh

    r11138 r11197  
    77./p0test.sh -detrend || exit 1
    88
    9 #dettool -definebyquery -det_type flat -exp_type fooflat -filter foo -airmass 10 -exp_time 30.0 -ccd_temp 100 -posang 360 -object iobject || exit 1
    10 det_id=`dettool -definebyquery -det_type flat -exp_type fooflat -filter foo -airmass 10 -exp_time 30.0 -object iobject -workdir file::///some/path -simple | cut -f1 -d" "` || exit 1
     9det_id=`dettool -definebyquery -det_type flat -exp_type fooflat -filter foo -airmass_min 1 -airmass_max 10 -exp_time_min 10 -exp_time_max 30.0 -workdir file::///some/path -simple | cut -f1 -d" "` || exit 1
    1110
    1211dettool -raw || exit 1

  • trunk/ippTools/src/dettool.c

    r11168 r11197  
    255255        return false;
    256256    }
     257    psString camera = psMetadataLookupStr(&status, config->args, "-inst");
     258    if (!status) {
     259        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -inst");
     260        return false;
     261    }
     262
     263    psString telescope = psMetadataLookupStr(&status, config->args, "-telescope");
     264    if (!status) {
     265        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -telescope");
     266        return false;
     267    }
    257268
    258269    psString exp_type = psMetadataLookupStr(&status, config->args, "-exp_type");
    … …  
    268279    }
    269280
    270     psF32 airmass = psMetadataLookupF32(&status, config->args, "-airmass");
    271     if (!status) {
    272         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -airmass");
    273         return false;
    274     }
    275 
    276     psF32 exp_time = psMetadataLookupF32(&status, config->args, "-exp_time");
    277     if (!status) {
    278         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_time");
    279         return false;
    280     }
    281 
    282     psF32 ccd_temp = psMetadataLookupF32(&status, config->args, "-ccd_temp");
    283     if (!status) {
    284         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -ccd_temp");
    285         return false;
    286     }
    287 
    288     psF64 posang = psMetadataLookupF32(&status, config->args, "-posang");
    289     if (!status) {
    290         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -posang");
    291         return false;
    292     }
    293 
    294     psString object = psMetadataLookupStr(&status, config->args, "-object");
    295     if (!status) {
    296         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -object");
     281    psF32 airmass_min = psMetadataLookupF32(&status, config->args, "-airmass_min");
     282    if (!status) {
     283        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -airmass_min");
     284        return false;
     285    }
     286
     287    psF32 airmass_max = psMetadataLookupF32(&status, config->args, "-airmass_max");
     288    if (!status) {
     289        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -airmass_max");
     290        return false;
     291    }
     292
     293    psF32 exp_time_min = psMetadataLookupF32(&status, config->args, "-exp_time_min");
     294    if (!status) {
     295        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_time_min");
     296        return false;
     297    }
     298
     299    psF32 exp_time_max = psMetadataLookupF32(&status, config->args, "-exp_time_max");
     300    if (!status) {
     301        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_time_max");
     302        return false;
     303    }
     304
     305    psF32 ccd_temp_min = psMetadataLookupF32(&status, config->args, "-ccd_temp_min");
     306    if (!status) {
     307        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -ccd_temp_min");
     308        return false;
     309    }
     310
     311    psF32 ccd_temp_max = psMetadataLookupF32(&status, config->args, "-ccd_temp_max");
     312    if (!status) {
     313        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -ccd_temp_max");
     314        return false;
     315    }
     316
     317    psF64 posang_min = psMetadataLookupF32(&status, config->args, "-posang_min");
     318    if (!status) {
     319        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -posang_min");
     320        return false;
     321    }
     322
     323    psF64 posang_max = psMetadataLookupF32(&status, config->args, "-posang_max");
     324    if (!status) {
     325        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -posang_max");
    297326        return false;
    298327    }
    … …  
    314343        } else {
    315344            registered = NULL;
     345        }
     346    }
     347
     348    psTime *time_begin = NULL;
     349    {
     350        psString time_beginStr = psMetadataLookupStr(&status, config->args, "-time_begin");
     351        if (!status) {
     352            psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -time_begin");
     353            return false;
     354        }
     355        // pass through NULL as this is an optional field
     356        if (time_beginStr) {
     357            time_begin = psTimeFromISO(time_beginStr, PS_TIME_UTC);
     358            if (!time_begin) {
     359                psError(PS_ERR_UNKNOWN, false, "error in time format %s", time_beginStr);
     360                return false;
     361            }
     362        } else {
     363            time_begin = NULL;
     364        }
     365    }
     366
     367    psTime *time_end = NULL;
     368    {
     369        psString time_endStr = psMetadataLookupStr(&status, config->args, "-time_end");
     370        if (!status) {
     371            psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -time_end");
     372            return false;
     373        }
     374        // pass through NULL as this is an optional field
     375        if (time_endStr) {
     376            time_end = psTimeFromISO(time_endStr, PS_TIME_UTC);
     377            if (!time_end) {
     378                psError(PS_ERR_UNKNOWN, false, "error in time format %s", time_endStr);
     379                return false;
     380            }
     381        } else {
     382            time_end = NULL;
    316383        }
    317384    }
    … …  
    430497            mode,
    431498            "run",
     499            workdir,
     500            camera,
     501            telescope,
    432502            exp_type,
    433             workdir,
    434503            filter,
    435             airmass,
    436             exp_time,
    437             ccd_temp,
    438             posang,
    439             object,
     504            airmass_min,
     505            airmass_max,
     506            exp_time_min,
     507            exp_time_max,
     508            ccd_temp_min,
     509            ccd_temp_max,
     510            posang_min,
     511            posang_max,
    440512            registered,
     513            time_begin,
     514            time_end,
    441515            use_begin,
    442516            use_end
    443517        );
     518    psFree(registered);
     519    psFree(time_begin);
     520    psFree(time_end);
     521    psFree(use_begin);
     522    psFree(use_end);
    444523    long det_id = psDBLastInsertID(config->dbh);
    445524
    … …  
    589668            }
    590669        }
     670
    591671        // map -inst -> camera
    592672        psString camera = psMetadataLookupStr(&status, config->args, "-select_inst");
    … …  
    602682            }
    603683        }
     684
    604685        psString telescope = psMetadataLookupStr(&status, config->args, "-select_telescope");
    605686        if (!status) {
    … …  
    614695            }
    615696        }
     697
    616698        psString filter = psMetadataLookupStr(&status, config->args, "-select_filter");
    617699        if (!status) {
    … …  
    626708            }
    627709        }
     710
    628711        psString uri = psMetadataLookupStr(&status, config->args, "-select_uri");
    629712        if (!status) {
    … …  
    708791    }
    709792
     793    psString camera = psMetadataLookupStr(&status, config->args, "-inst");
     794    if (!status) {
     795        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -inst");
     796        return false;
     797    }
     798
     799    psString telescope = psMetadataLookupStr(&status, config->args, "-telescope");
     800    if (!status) {
     801        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -telescope");
     802        return false;
     803    }
     804
    710805    psString exp_type = psMetadataLookupStr(&status, config->args, "-exp_type");
    711806    if (!status) {
    … …  
    720815    }
    721816
    722     psF32 airmass = psMetadataLookupF32(&status, config->args, "-airmass");
    723     if (!status) {
    724         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -airmass");
    725         return false;
    726     }
    727 
    728     psF32 exp_time = psMetadataLookupF32(&status, config->args, "-exp_time");
    729     if (!status) {
    730         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_time");
    731         return false;
    732     }
    733 
    734     psF32 ccd_temp = psMetadataLookupF32(&status, config->args, "-ccd_temp");
    735     if (!status) {
    736         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -ccd_temp");
    737         return false;
    738     }
    739 
    740     psF64 posang = psMetadataLookupF32(&status, config->args, "-posang");
    741     if (!status) {
    742         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -posang");
    743         return false;
    744     }
    745 
    746     psString object = psMetadataLookupStr(&status, config->args, "-object");
    747     if (!status) {
    748         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -object");
    749         return false;
    750     }
     817    psF32 airmass_min = psMetadataLookupF32(&status, config->args, "-airmass_min");
     818    if (!status) {
     819        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -airmass_min");
     820        return false;
     821    }
     822
     823    psF32 airmass_max = psMetadataLookupF32(&status, config->args, "-airmass_max");
     824    if (!status) {
     825        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -airmass_max");
     826        return false;
     827    }
     828
     829    psF32 exp_time_min = psMetadataLookupF32(&status, config->args, "-exp_time_min");
     830    if (!status) {
     831        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_time_min");
     832        return false;
     833    }
     834
     835    psF32 exp_time_max = psMetadataLookupF32(&status, config->args, "-exp_time_max");
     836    if (!status) {
     837        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_time_max");
     838        return false;
     839    }
     840
     841    psF32 ccd_temp_min = psMetadataLookupF32(&status, config->args, "-ccd_temp_min");
     842    if (!status) {
     843        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -ccd_temp_min");
     844        return false;
     845    }
     846
     847    psF32 ccd_temp_max = psMetadataLookupF32(&status, config->args, "-ccd_temp_max");
     848    if (!status) {
     849        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -ccd_temp_max");
     850        return false;
     851    }
     852
     853    psF64 posang_min = psMetadataLookupF32(&status, config->args, "-posang_min");
     854    if (!status) {
     855        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -posang_min");
     856        return false;
     857    }
     858
     859    psF64 posang_max = psMetadataLookupF32(&status, config->args, "-posang_max");
     860    if (!status) {
     861        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -posang_max");
     862        return false;
     863    }
     864
    751865    psTime *registered = NULL;
    752866    {
    … …  
    768882    }
    769883
     884    psTime *time_begin = NULL;
     885    {
     886        psString time_beginStr = psMetadataLookupStr(&status, config->args, "-time_begin");
     887        if (!status) {
     888            psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -time_begin");
     889            return false;
     890        }
     891        // pass through NULL as this is an optional field
     892        if (time_beginStr) {
     893            time_begin = psTimeFromISO(time_beginStr, PS_TIME_UTC);
     894            if (!time_begin) {
     895                psError(PS_ERR_UNKNOWN, false, "error in time format %s", time_beginStr);
     896                return false;
     897            }
     898        } else {
     899            time_begin = NULL;
     900        }
     901    }
     902
     903    psTime *time_end = NULL;
     904    {
     905        psString time_endStr = psMetadataLookupStr(&status, config->args, "-time_end");
     906        if (!status) {
     907            psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -time_end");
     908            return false;
     909        }
     910        // pass through NULL as this is an optional field
     911        if (time_endStr) {
     912            time_end = psTimeFromISO(time_endStr, PS_TIME_UTC);
     913            if (!time_end) {
     914                psError(PS_ERR_UNKNOWN, false, "error in time format %s", time_endStr);
     915                return false;
     916            }
     917        } else {
     918            time_end = NULL;
     919        }
     920    }
     921
    770922    psTime *use_begin = NULL;
    771923    {
    … …  
    8741026    // XXX det_id
    8751027    detRunInsert(config->dbh,
    876             0,
    877             0,
     1028            0,      // det_id
     1029            0,      // iteration
    8781030            det_type,
    8791031            mode,
    880             "run",
     1032            "run",  // state
     1033            workdir,
     1034            camera,
     1035            telescope,
    8811036            exp_type,
    882             workdir,
    8831037            filter,
    884             airmass,
    885             exp_time,
    886             ccd_temp,
    887             posang,
    888             object,
     1038            airmass_min,
     1039            airmass_max,
     1040            exp_time_min,
     1041            exp_time_max,
     1042            ccd_temp_min,
     1043            ccd_temp_max,
     1044            posang_min,
     1045            posang_max,
    8891046            registered,
     1047            time_begin,
     1048            time_end,
    8901049            use_begin,
    8911050            use_end
    8921051        );
    8931052    psFree(registered);
     1053    psFree(time_begin);
     1054    psFree(time_end);
     1055    psFree(use_end);
    8941056    psFree(use_begin);
    8951057    psFree(use_end);
    … …  
    10421204    }
    10431205
     1206    psString camera = psMetadataLookupStr(&status, config->args, "-set_inst");
     1207    if (!status) {
     1208        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_inst");
     1209        return false;
     1210    }
     1211    if (camera) {
     1212        psFree(detRun->camera);
     1213        detRun->camera = psStringCopy(camera);
     1214    }
     1215
     1216    psString telescope = psMetadataLookupStr(&status, config->args, "-set_telescope");
     1217    if (!status) {
     1218        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_telescope");
     1219        return false;
     1220    }
     1221    if (telescope) {
     1222        psFree(detRun->telescope);
     1223        detRun->telescope = psStringCopy(telescope);
     1224    }
     1225
    10441226    psString exp_type = psMetadataLookupStr(&status, config->args, "-set_exp_type");
    10451227    if (!status) {
    … …  
    10621244    }
    10631245
    1064     psF32 airmass = psMetadataLookupF32(&status, config->args, "-set_airmass");
    1065     if (!status) {
    1066         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_airmass");
    1067         return false;
    1068     }
    1069     if (!isnan(airmass)) {
    1070         detRun->airmass = airmass;
    1071     }
    1072 
    1073     psF32 exp_time = psMetadataLookupF32(&status, config->args, "-set_exp_time");
    1074     if (!status) {
    1075         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_exp_time");
    1076         return false;
    1077     }
    1078     if (!isnan(exp_time)) {
    1079         detRun->exp_time = exp_time;
    1080     }
    1081 
    1082     psF32 ccd_temp = psMetadataLookupF32(&status, config->args, "-set_ccd_temp");
    1083     if (!status) {
    1084         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_ccd_temp");
    1085         return false;
    1086     }
    1087     if (!isnan(ccd_temp)) {
    1088         detRun->ccd_temp = ccd_temp;
    1089     }
    1090 
    1091     psF64 posang = psMetadataLookupF32(&status, config->args, "-set_posang");
    1092     if (!status) {
    1093         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_posang");
    1094         return false;
    1095     }
    1096     if (!isnan(posang)) {
    1097         detRun->posang = posang;
    1098     }
    1099 
    1100     psString object = psMetadataLookupStr(&status, config->args, "-set_object");
    1101     if (!status) {
    1102         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_object");
    1103         return false;
    1104     }
    1105     if (object) {
    1106         psFree(detRun->object);
    1107         detRun->object = psStringCopy(object);
     1246    psF32 airmass_min = psMetadataLookupF32(&status, config->args, "-set_airmass_min");
     1247    if (!status) {
     1248        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_airmass_min");
     1249        return false;
     1250    }
     1251    if (!isnan(airmass_min)) {
     1252        detRun->airmass_min = airmass_min;
     1253    }
     1254
     1255    psF32 airmass_max = psMetadataLookupF32(&status, config->args, "-set_airmass_max");
     1256    if (!status) {
     1257        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_airmass_max");
     1258        return false;
     1259    }
     1260    if (!isnan(airmass_max)) {
     1261        detRun->airmass_max = airmass_max;
     1262    }
     1263
     1264    psF32 exp_time_min = psMetadataLookupF32(&status, config->args, "-set_exp_time_min");
     1265    if (!status) {
     1266        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_exp_time_min");
     1267        return false;
     1268    }
     1269    if (!isnan(exp_time_min)) {
     1270        detRun->exp_time_min = exp_time_min;
     1271    }
     1272
     1273    psF32 exp_time_max = psMetadataLookupF32(&status, config->args, "-set_exp_time_max");
     1274    if (!status) {
     1275        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_exp_time_max");
     1276        return false;
     1277    }
     1278    if (!isnan(exp_time_max)) {
     1279        detRun->exp_time_max = exp_time_max;
     1280    }
     1281
     1282    psF32 ccd_temp_min = psMetadataLookupF32(&status, config->args, "-set_ccd_temp_min");
     1283    if (!status) {
     1284        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_ccd_temp_min");
     1285        return false;
     1286    }
     1287    if (!isnan(ccd_temp_min)) {
     1288        detRun->ccd_temp_min = ccd_temp_min;
     1289    }
     1290
     1291    psF32 ccd_temp_max = psMetadataLookupF32(&status, config->args, "-set_ccd_temp_max");
     1292    if (!status) {
     1293        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_ccd_temp_max");
     1294        return false;
     1295    }
     1296    if (!isnan(ccd_temp_max)) {
     1297        detRun->ccd_temp_max = ccd_temp_max;
     1298    }
     1299
     1300    psF64 posang_min = psMetadataLookupF32(&status, config->args, "-set_posang_min");
     1301    if (!status) {
     1302        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_posang_min");
     1303        return false;
     1304    }
     1305    if (!isnan(posang_min)) {
     1306        detRun->posang_min = posang_min;
     1307    }
     1308
     1309    psF64 posang_max = psMetadataLookupF32(&status, config->args, "-set_posang_max");
     1310    if (!status) {
     1311        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_posang_max");
     1312        return false;
     1313    }
     1314    if (!isnan(posang_max)) {
     1315        detRun->posang_max = posang_max;
    11081316    }
    11091317
    … …  
    11211329            detRun->registered = psMemIncrRefCounter(registered);
    11221330            psFree(registered);
     1331        }
     1332    }
     1333
     1334    psTime *time_begin = NULL;
     1335    {
     1336        psString time_beginStr = psMetadataLookupStr(&status, config->args, "-set_time_begin");
     1337        if (!status) {
     1338            psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_time_begin");
     1339            return false;
     1340        }
     1341        // pass through NULL as this is an optional field
     1342        if (time_beginStr) {
     1343            psFree(detRun->time_begin);
     1344            time_begin = psTimeFromISO(time_beginStr, PS_TIME_UTC);
     1345            detRun->time_begin = psMemIncrRefCounter(time_begin);
     1346            psFree(time_begin);
     1347        }
     1348    }
     1349
     1350    psTime *time_end = NULL;
     1351    {
     1352        psString time_endStr = psMetadataLookupStr(&status, config->args, "-set_time_end");
     1353        if (!status) {
     1354            psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -set_time_end");
     1355            return false;
     1356        }
     1357        // pass through NULL as this is an optional field
     1358        if (time_endStr) {
     1359            psFree(detRun->time_end);
     1360            time_end = psTimeFromISO(time_endStr, PS_TIME_UTC);
     1361            detRun->time_end = psMemIncrRefCounter(time_end);
     1362            psFree(time_end);
    11231363        }
    11241364    }
    … …  
    57676007    }
    57686008
     6009    psString camera = psMetadataLookupStr(&status, config->args, "-inst");
     6010    if (!status) {
     6011        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -inst");
     6012        return false;
     6013    }
     6014
     6015    psString telescope = psMetadataLookupStr(&status, config->args, "-telescope");
     6016    if (!status) {
     6017        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -telescope");
     6018        return false;
     6019    }
     6020
    57696021    psString exp_type = psMetadataLookupStr(&status, config->args, "-exp_type");
    57706022    if (!status) {
    … …  
    57796031    }
    57806032
    5781     psF32 airmass = psMetadataLookupF32(&status, config->args, "-airmass");
    5782     if (!status) {
    5783         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -airmass");
    5784         return false;
    5785     }
    5786 
    5787     psF32 exp_time = psMetadataLookupF32(&status, config->args, "-exp_time");
    5788     if (!status) {
    5789         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_time");
    5790         return false;
    5791     }
    5792 
    5793     psF32 ccd_temp = psMetadataLookupF32(&status, config->args, "-ccd_temp");
    5794     if (!status) {
    5795         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -ccd_temp");
    5796         return false;
    5797     }
    5798 
    5799     psF64 posang = psMetadataLookupF32(&status, config->args, "-posang");
    5800     if (!status) {
    5801         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -posang");
    5802         return false;
    5803     }
    5804 
    5805     psString object = psMetadataLookupStr(&status, config->args, "-object");
    5806     if (!status) {
    5807         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -object");
     6033    psF32 airmass_min = psMetadataLookupF32(&status, config->args, "-airmass_min");
     6034    if (!status) {
     6035        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -airmass_min");
     6036        return false;
     6037    }
     6038
     6039    psF32 airmass_max = psMetadataLookupF32(&status, config->args, "-airmass_max");
     6040    if (!status) {
     6041        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -airmass_max");
     6042        return false;
     6043    }
     6044
     6045    psF32 exp_time_min = psMetadataLookupF32(&status, config->args, "-exp_time_min");
     6046    if (!status) {
     6047        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_time_min");
     6048        return false;
     6049    }
     6050
     6051    psF32 exp_time_max = psMetadataLookupF32(&status, config->args, "-exp_time_max");
     6052    if (!status) {
     6053        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_time_max");
     6054        return false;
     6055    }
     6056
     6057    psF32 ccd_temp_min = psMetadataLookupF32(&status, config->args, "-ccd_temp_min");
     6058    if (!status) {
     6059        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -ccd_temp_min");
     6060        return false;
     6061    }
     6062
     6063    psF32 ccd_temp_max = psMetadataLookupF32(&status, config->args, "-ccd_temp_max");
     6064    if (!status) {
     6065        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -ccd_temp_max");
     6066        return false;
     6067    }
     6068
     6069    psF64 posang_min = psMetadataLookupF32(&status, config->args, "-posang_min");
     6070    if (!status) {
     6071        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -posang_min");
     6072        return false;
     6073    }
     6074
     6075    psF64 posang_max = psMetadataLookupF32(&status, config->args, "-posang_max");
     6076    if (!status) {
     6077        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -posang_max");
    58086078        return false;
    58096079    }
    … …  
    58246094    }
    58256095
     6096    psTime *time_begin = NULL;
     6097    {
     6098        psString time_beginStr = psMetadataLookupStr(&status, config->args, "-time_begin");
     6099        if (!status) {
     6100            psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -time_begin");
     6101            return false;
     6102        }
     6103        // pass through NULL as this is an optional field
     6104        if (time_beginStr) {
     6105            time_begin = psTimeFromISO(time_beginStr, PS_TIME_UTC);
     6106        } else {
     6107            time_begin = NULL;
     6108        }
     6109    }
     6110
     6111    psTime *time_end = NULL;
     6112    {
     6113        psString time_endStr = psMetadataLookupStr(&status, config->args, "-time_end");
     6114        if (!status) {
     6115            psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -time_end");
     6116            return false;
     6117        }
     6118        // pass through NULL as this is an optional field
     6119        if (time_endStr) {
     6120            time_end = psTimeFromISO(time_endStr, PS_TIME_UTC);
     6121        } else {
     6122            time_end = NULL;
     6123        }
     6124    }
     6125
    58266126    psTime *use_begin = NULL;
    58276127    {
    … …  
    58786178
    58796179    if (!detRunInsert(config->dbh,
    5880             0,
    5881             0,  // the iteration is fixed at 0
     6180            0,          // det_id
     6181            0,          // the iteration is fixed at 0
    58826182            det_type,
    58836183            mode,
    5884             "reg",
     6184            "reg",      // state
     6185            workdir,
     6186            camera,
     6187            telescope,
    58856188            exp_type,
    5886             workdir,
    58876189            filter,
    5888             airmass,
    5889             exp_time,
    5890             ccd_temp,
    5891             posang,
    5892             object,
     6190            airmass_min,
     6191            airmass_max,
     6192            exp_time_min,
     6193            exp_time_max,
     6194            ccd_temp_min,
     6195            ccd_temp_max,
     6196            posang_min,
     6197            posang_max,
    58936198            registered,
     6199            time_begin,
     6200            time_end,
    58946201            use_begin,
    58956202            use_end

  • trunk/ippTools/src/dettoolConfig.c

    r11138 r11197  
    7272    psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-mode",  0,
    7373            "define the mode of this detrend run", "master");
     74    psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-workdir",  0,
     75            "define workdir (required)", NULL);
     76    psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-inst",  0,
     77            "define camera", NULL);
     78    psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-telescope",  0,
     79            "define telescope", NULL);
    7480    psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-exp_type",  0,
    7581            "define exposure type", NULL);
    76     psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-workdir",  0,
    77             "define workdir (required)", NULL);
    7882    psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-filter",  0,
    7983            "define filter ", NULL);
    80     psMetadataAddF32(definebytagArgs, PS_LIST_TAIL, "-airmass",  0,
    81             "define airmass", NAN);
    82     psMetadataAddF32(definebytagArgs, PS_LIST_TAIL, "-exp_time",  0,
    83             "define exposure time", NAN);
    84     psMetadataAddF64(definebytagArgs, PS_LIST_TAIL, "-ccd_temp",  0,
    85             "define ccd tempature", NAN);
    86     psMetadataAddF64(definebytagArgs, PS_LIST_TAIL, "-posang",  0,
    87             "define rotator position angle", NAN);
    88     psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-object",  0,
    89             "define exposure object", NULL);
     84    psMetadataAddF32(definebytagArgs, PS_LIST_TAIL, "-airmass_min",  0,
     85            "define min airmass", NAN);
     86    psMetadataAddF32(definebytagArgs, PS_LIST_TAIL, "-airmass_max",  0,
     87            "define max airmass", NAN);
     88    psMetadataAddF32(definebytagArgs, PS_LIST_TAIL, "-exp_time_min",  0,
     89            "define min exposure time", NAN);
     90    psMetadataAddF32(definebytagArgs, PS_LIST_TAIL, "-exp_time_max",  0,
     91            "define max exposure time", NAN);
     92    psMetadataAddF64(definebytagArgs, PS_LIST_TAIL, "-ccd_temp_min",  0,
     93            "define min ccd tempature", NAN);
     94    psMetadataAddF64(definebytagArgs, PS_LIST_TAIL, "-ccd_temp_max",  0,
     95            "define max ccd tempature", NAN);
     96    psMetadataAddF64(definebytagArgs, PS_LIST_TAIL, "-posang_min",  0,
     97            "define min rotator position angle", NAN);
     98    psMetadataAddF64(definebytagArgs, PS_LIST_TAIL, "-posang_max",  0,
     99            "define max rotator position angle", NAN);
    90100    psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-registered",  0,
    91101            "time detrend run was registered", now);
     102    psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-time_begin",  0,
     103            "detrend applyes to exposures taken during this peroid", NULL);
     104    psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-time_end",  0,
     105            "detrend applyes to exposures taken during this peroid", NULL);
    92106    psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-use_begin",  0,
    93107            "start of detrend run applicable peroid", NULL);
    … …  
    103117    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-mode",  0,
    104118            "define the mode of this detrend run", "master");
     119    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-workdir",  0,
     120            "define workdir (required)", NULL);
     121    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-inst",  0,
     122            "define camera", NULL);
     123    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-telescope",  0,
     124            "define telescope", NULL);
    105125    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-exp_type",  0,
    106126            "define exposure type", NULL);
    107     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-workdir",  0,
    108             "define workdir (required)", NULL);
    109127    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-filter",  0,
    110128            "define filter ", NULL);
    111     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-airmass",  0,
    112             "define airmass", NAN);
    113     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-exp_time",  0,
    114             "define exposure time", NAN);
    115     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-ccd_temp",  0,
    116             "define ccd tempature", NAN);
    117     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-posang",  0,
    118             "define rotator position angle", NAN);
    119     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-object",  0,
    120             "define exposure object", NULL);
     129    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-airmass_min",  0,
     130            "define min airmass", NAN);
     131    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-airmass_max",  0,
     132            "define max airmass", NAN);
     133    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-exp_time_min",  0,
     134            "define min exposure time", NAN);
     135    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-exp_time_max",  0,
     136            "define max exposure time", NAN);
     137    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-ccd_temp_min",  0,
     138            "define min ccd tempature", NAN);
     139    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-ccd_temp_max",  0,
     140            "define max ccd tempature", NAN);
     141    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-posang_min",  0,
     142            "define min rotator position angle", NAN);
     143    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-posang_max",  0,
     144            "define max rotator position angle", NAN);
    121145    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-registered",  0,
    122146            "time detrend run was registered", now);
     147    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-time_begin",  0,
     148            "detrend applyes to exposures taken during this peroid", NULL);
     149    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-time_end",  0,
     150            "detrend applyes to exposures taken during this peroid", NULL);
    123151    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-use_begin",  0,
    124152            "start of detrend run applicable peroid", NULL);
    … …  
    158186    psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-set_filter",  0,
    159187            "define filter ", NULL);
    160     psMetadataAddF32(definebydetrunArgs, PS_LIST_TAIL, "-set_airmass",  0,
     188    psMetadataAddF32(definebydetrunArgs, PS_LIST_TAIL, "-set_airmass_min",  0,
    161189            "define airmass", NAN);
    162     psMetadataAddF32(definebydetrunArgs, PS_LIST_TAIL, "-set_exp_time",  0,
     190    psMetadataAddF32(definebydetrunArgs, PS_LIST_TAIL, "-set_airmass_max",  0,
     191            "define airmass", NAN);
     192    psMetadataAddF32(definebydetrunArgs, PS_LIST_TAIL, "-set_exp_time_min",  0,
    163193            "define exposure time", NAN);
    164     psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_ccd_temp",  0,
     194    psMetadataAddF32(definebydetrunArgs, PS_LIST_TAIL, "-set_exp_time_max",  0,
     195            "define exposure time", NAN);
     196    psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_ccd_temp_min",  0,
    165197            "define ccd tempature", NAN);
    166     psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_posang",  0,
     198    psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_ccd_temp_max",  0,
     199            "define ccd tempature", NAN);
     200    psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_posang_min",  0,
    167201            "define rotator position angle", NAN);
    168     psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-set_object",  0,
    169             "define exposure object", NULL);
     202    psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_posang_max",  0,
     203            "define rotator position angle", NAN);
    170204    psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-set_registered",  0,
    171205            "time detrend run was registered", now);
     206    psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-set_time_begin",  0,
     207            "start of peroid to apply detrend too", NULL);
     208    psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-set_time_end",  0,
     209            "end of peroid to apply detrend too", NULL);
    172210    psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-set_use_begin",  0,
    173211            "start of detrend run applicable peroid", NULL);
    … …  
    655693    psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-mode",  0,
    656694            "define the mode of this detrend run", "master");
     695    psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-workdir",  0,
     696            "define workdir (required)", NULL);
     697    psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-inst",  0,
     698            "define camera", NULL);
     699    psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-telescope",  0,
     700            "define telescope", NULL);
    657701    psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-exp_type",  0,
    658702            "define exposure type", NULL);
    659     psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-workdir",  0,
    660             "define workdir (required)", NULL);
    661703    psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-filter",  0,
    662704            "define filter ", NULL);
    663     psMetadataAddF32(register_detrendArgs, PS_LIST_TAIL, "-airmass",  0,
    664             "define airmass", NAN);
    665     psMetadataAddF32(register_detrendArgs, PS_LIST_TAIL, "-exp_time",  0,
    666             "define exposure time", NAN);
    667     psMetadataAddF64(register_detrendArgs, PS_LIST_TAIL, "-ccd_temp",  0,
    668             "define ccd tempature", NAN);
    669     psMetadataAddF64(register_detrendArgs, PS_LIST_TAIL, "-posang",  0,
    670             "define rotator position angle", NAN);
    671     psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-object",  0,
    672             "define exposure object", NULL);
     705    psMetadataAddF32(register_detrendArgs, PS_LIST_TAIL, "-airmass_min",  0,
     706            "define min airmass", NAN);
     707    psMetadataAddF32(register_detrendArgs, PS_LIST_TAIL, "-airmass_max",  0,
     708            "define max airmass", NAN);
     709    psMetadataAddF32(register_detrendArgs, PS_LIST_TAIL, "-exp_time_min",  0,
     710            "define min exposure time", NAN);
     711    psMetadataAddF32(register_detrendArgs, PS_LIST_TAIL, "-exp_time_max",  0,
     712            "define max exposure time", NAN);
     713    psMetadataAddF64(register_detrendArgs, PS_LIST_TAIL, "-ccd_temp_min",  0,
     714            "define min ccd tempature", NAN);
     715    psMetadataAddF64(register_detrendArgs, PS_LIST_TAIL, "-ccd_temp_max",  0,
     716            "define max ccd tempature", NAN);
     717    psMetadataAddF64(register_detrendArgs, PS_LIST_TAIL, "-posang_min",  0,
     718            "define min rotator position angle", NAN);
     719    psMetadataAddF64(register_detrendArgs, PS_LIST_TAIL, "-posang_max",  0,
     720            "define max rotator position angle", NAN);
    673721    psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-registered",  0,
    674722            "time detrend run was registered", now);
     723    psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-time_begin",  0,
     724            "detrend applyes to exposures taken during this peroid", NULL);
     725    psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-time_end",  0,
     726            "detrend applyes to exposures taken during this peroid", NULL);
    675727    psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-use_begin",  0,
    676728            "start of detrend run applicable peroid", NULL);
    … …  
    715767        if (config->mode) { \
    716768            psError(PS_ERR_UNKNOWN, true, "only one mode selection is allowed"); \
     769            psFree(argset); \
     770            psFree(argSets); \
    717771            goto FAIL; \
    718772        } \
    … …  
    907961
    908962FAIL:
    909     psFree(config);
     963//    psFree(config);
    910964    pmConfigDone();
    911965    psLibFinalize();
Note: See TracChangeset for help on using the changeset viewer.