IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 8250


Ignore:
Timestamp:
Aug 8, 2006, 6:27:04 PM (20 years ago)
Author:
jhoblitt
Message:

major overhaul to p0search;

remove -pending
remove -update
add -pendingimfile
add -pendingexp (not yet working)
add -updateexp
add -updateimfile

move newToRawDetrendExp() from pxframes.c -> p0search.c

Location:
trunk/ippTools/src
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/ippTools/src/pxframes.c

    r8187 r8250  
    66
    77#include "pxtools.h"
    8 
    9 static rawDetrendExpRow *newToRawDetrendExp(pxConfig *config, newExpRow *exp);
    108
    119#define PX_FRAME_ALLOC(frametype, exptype) \
    … …  
    160158}
    161159
     160/*
    162161rawDetrendFrame *newToRawDetrendFrame(pxConfig *config, newFrame *newFrame)
    163162{
    … …  
    189188    return rawDetrendFrame;
    190189}
     190*/
    191191
    192192bool rawDetrendFrameInsert(pxConfig *config, rawDetrendFrame *frame)
    … …  
    213213    return true;
    214214}
    215 
    216 static rawDetrendExpRow *newToRawDetrendExp(pxConfig *config, newExpRow *exp)
    217 {
    218     PS_ASSERT_PTR_NON_NULL(config, NULL);
    219     PS_ASSERT_PTR_NON_NULL(exp, NULL);
    220 
    221     bool status = false;
    222     psString filter = psMetadataLookupStr(&status, config->args, "-filter");
    223     if (!status) {
    224         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -filter");
    225         return false;
    226     }
    227     if (!filter) {
    228         psError(PS_ERR_UNKNOWN, true, "-filter is required");
    229         return false;
    230     }
    231     psF32 airmass = psMetadataLookupF32(&status, config->args, "-airmass");
    232     if (!status) {
    233         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -airmass");
    234         return false;
    235     }
    236     if (isnan(airmass)) {
    237         psError(PS_ERR_UNKNOWN, true, "-airmass is required");
    238         return false;
    239     }
    240     psF64 ra = psMetadataLookupF64(&status, config->args, "-ra");
    241     if (!status) {
    242         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -ra");
    243         return false;
    244     }
    245     if (isnan(ra)) {
    246         psError(PS_ERR_UNKNOWN, true, "-airmass is required");
    247         return false;
    248     }
    249     psF64 decl = psMetadataLookupF64(&status, config->args, "-decl");
    250     if (!status) {
    251         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -decl");
    252         return false;
    253     }
    254     if (isnan(decl)) {
    255         psError(PS_ERR_UNKNOWN, true, "-decl is required");
    256         return false;
    257     }
    258     psF32 exp_time = psMetadataLookupF32(&status, config->args, "-exp_time");
    259     if (isnan(exp_time)) {
    260         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_time");
    261         return false;
    262     }
    263     if (!exp_time) {
    264         psError(PS_ERR_UNKNOWN, true, "-exp_time is required");
    265         return false;
    266     }
    267     psF64 background = psMetadataLookupF64(&status, config->args, "-background");
    268     if (!status) {
    269         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -background");
    270         return false;
    271     }
    272     if (!exp_time) {
    273         psError(PS_ERR_UNKNOWN, true, "-background is required");
    274         return false;
    275     }
    276 
    277     return rawDetrendExpRowAlloc(
    278         exp->exp_id,
    279         exp->camera,
    280         exp->telescope,
    281         exp->exp_type,
    282         exp->imfiles,
    283         filter,
    284         airmass,
    285         ra,
    286         decl,
    287         exp_time,
    288         background
    289     );
    290 }

  • trunk/ippTools/src/regtool.c

    r8188 r8250  
    88#include "p0search.h"
    99
    10 static bool pendingMode(pxConfig *config);
    11 static bool updateMode(pxConfig *config);
     10static bool pendingexpMode(pxConfig *config);
     11static bool pendingimfileMode(pxConfig *config);
     12static bool updateexpMode(pxConfig *config);
     13static bool updateimfileMode(pxConfig *config);
    1214static psArray *newFrameSearchPending(pxConfig *config);
    1315static p1PendingExpRow *newToP1PendingExp(newExpRow *newExp);
    … …  
    1618static rawScienceFrame *newToRawScienceFrame(pxConfig *config, newFrame *newFrame);
    1719static rawScienceExpRow *newToRawScienceExp(pxConfig *config, newExpRow *exp);
     20static rawDetrendExpRow *newToRawDetrendExp(pxConfig *config, newExpRow *exp);
     21static rawImfileRow *newToRawImfile(pxConfig *config, newImfileRow *exp);
    1822
    1923
    … …  
    3236
    3337    switch (config->mode) {
    34         MODECASE(P0SEARCH_MODE_PENDING, pendingMode);
    35         MODECASE(P0SEARCH_MODE_UPDATE, updateMode);
     38        MODECASE(P0SEARCH_MODE_PENDINGEXP,      pendingexpMode);
     39        MODECASE(P0SEARCH_MODE_PENDINGIMFILE,   pendingimfileMode);
     40        MODECASE(P0SEARCH_MODE_UPDATEEXP,       updateexpMode);
     41        MODECASE(P0SEARCH_MODE_UPDATEIMFILE,    updateimfileMode);
    3642        default:
    3743            psAbort(argv[0], "invalid option (this should not happen)");
    … …  
    5258}
    5359
    54 static bool pendingMode(pxConfig *config)
     60static bool pendingexpMode(pxConfig *config)
    5561{
    5662    PS_ASSERT_PTR_NON_NULL(config, false);
    5763
    58     psArray *new = newFrameSearchPending(config);
    59     if (!new) {
    60         psError(PS_ERR_UNKNOWN, false, "no newFrames found");
    61         return false;
    62     }
    63 
    64     bool status = newFramePrint(stdout, config, new);
    65     if (!status) {
    66         psError(PS_ERR_UNKNOWN, false,"newFramePrint() failed");
    67         psFree(new);
    68         return false;
    69     }
    70 
    71     psFree(new);
     64    // return only exps that are not in rawScienceExp or rawDetrendExp and have
     65    // ALL of their imfiles in rawImfile (by count) and have no associated
     66    // imfiles left in newImfile
     67
     68    char *query =
     69        "SELECT newExp.* FROM newExp"
     70        " LEFT JOIN rawScienceExp USING(exp_id)"
     71        " LEFT JOIN rawDetrendExp USING (exp_id)"
     72        " LEFT JOIN newImfile USING (exp_id)"
     73        " WHERE newExp.exp_id is NOT NULL"
     74        " AND rawScienceExp.exp_id IS NULL"
     75        " AND rawDetrendExp.exp_id IS NULL"
     76        " AND newImfile.exp_id IS NULL"
     77        " AND newExp.imfiles = (SELECT COUNT(exp_id)"
     78                                " FROM rawImfile GROUP BY exp_id)";
     79
     80    if (!p_psDBRunQuery(config->dbh, query)) {
     81        psError(PS_ERR_UNKNOWN, false, "database error");
     82        return false;
     83    }
     84
     85    psArray *output = p_psDBFetchResult(config->dbh);
     86    if (!output) {
     87        // XXX check psError here
     88        psError(PS_ERR_UNKNOWN, false, "failed to fetch the database result");
     89        return false;
     90    }
     91
     92    bool simple = false;
     93    {
     94        bool status = false;
     95        simple = psMetadataLookupBool(&status, config->args, "-simple");
     96        if (!status) {
     97            psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
     98            return false;
     99        }
     100    }
     101
     102    // negate simple so the default is true
     103    if (!ippdbPrintMetadatas(stdout, output, "newImfile", !simple)) {
     104        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     105        psFree(output);
     106        return false;
     107    }
     108
     109    psFree(output);
    72110
    73111    return true;
    74112}
    75113
    76 static bool updateMode(pxConfig *config)
     114static bool pendingimfileMode(pxConfig *config)
    77115{
    78116    PS_ASSERT_PTR_NON_NULL(config, false);
     117
     118    // select newImfiles who's exp_id is in newExp AND don't have their exp_id
     119    // in rawScienceExp or rawDetrendExp
     120    // XXX having the same exp_id in newExp and raw*Exp is probably an error
     121    // that should be checked for
     122    char *query =
     123        "SELECT newImfile.* FROM newImfile"
     124        " LEFT JOIN newExp USING(exp_id)"
     125        " LEFT JOIN rawScienceExp USING(exp_id)"
     126        " LEFT JOIN rawDetrendExp USING (exp_id)"
     127        " WHERE newExp.exp_id is NOT NULL"
     128        " AND rawScienceExp.exp_id IS NULL"
     129        " AND rawDetrendExp.exp_id IS NULL";
     130
     131    if (!p_psDBRunQuery(config->dbh, query)) {
     132        psError(PS_ERR_UNKNOWN, false, "database error");
     133        return false;
     134    }
     135
     136    psArray *output = p_psDBFetchResult(config->dbh);
     137    if (!output) {
     138        // XXX check psError here
     139        psError(PS_ERR_UNKNOWN, false, "failed to fetch the database result");
     140        return false;
     141    }
     142
     143    bool simple = false;
     144    {
     145        bool status = false;
     146        simple = psMetadataLookupBool(&status, config->args, "-simple");
     147        if (!status) {
     148            psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
     149            return false;
     150        }
     151    }
     152
     153    // negate simple so the default is true
     154    if (!ippdbPrintMetadatas(stdout, output, "newImfile", !simple)) {
     155        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     156        psFree(output);
     157        return false;
     158    }
     159
     160    psFree(output);
     161
     162    return true;
     163}
     164
     165static bool updateexpMode(pxConfig *config)
     166{
     167    PS_ASSERT_PTR_NON_NULL(config, false);
     168
     169    // make sure that the exp_id(s) are ready to be updated based on the same
     170    // critera used in pendingexpMode
     171    char *query =
     172        "SELECT newImfile.* FROM newImfile"
     173        " LEFT JOIN newExp USING(exp_id)"
     174        " LEFT JOIN rawScienceExp USING(exp_id)"
     175        " LEFT JOIN rawDetrendExp USING (exp_id)"
     176        " WHERE newExp.exp_id is NOT NULL"
     177        " AND rawScienceExp.exp_id IS NULL"
     178        " AND rawDetrendExp.exp_id IS NULL";
     179
     180    if (!p_psDBRunQuery(config->dbh, query)) {
     181        psError(PS_ERR_UNKNOWN, false, "database error");
     182        return false;
     183    }
     184
     185    psArray *output = p_psDBFetchResult(config->dbh);
     186    if (!output) {
     187        // XXX check psError here
     188        psError(PS_ERR_UNKNOWN, false, "failed to fetch the database result");
     189        return false;
     190    }
    79191
    80192    bool status = false;
    … …  
    85197    }
    86198
    87     psArray *new = newFrameSearchPending(config);
    88     if (!new) {
    89         psError(PS_ERR_UNKNOWN, false, "no newFrames found");
    90         return true;
    91     }
    92 
    93     // insert 'new' rawScience & detrendframes
    94     if (psArrayLength(new) > 0) {
    95         // start a transaction so we don't end up file raw* frames but no
    96         // p2Pending*, etc.
     199    for (long i = 0; psArrayLength(output) > i; i++) {
     200    }
     201
     202    return true;
     203}
     204
     205static bool updateimfileMode(pxConfig *config)
     206{
     207    PS_ASSERT_PTR_NON_NULL(config, false);
     208
     209    // XXX search by the whole frame some imfiles without a newExp don't get
     210    // processed -- this may not be the correct thing to do
     211    char *query =
     212        "SELECT * FROM"
     213            " (SELECT newImfile.* FROM newImfile"
     214                " LEFT JOIN newExp USING(exp_id)"
     215                " LEFT JOIN rawScienceExp USING(exp_id)"
     216                " LEFT JOIN rawDetrendExp USING (exp_id)"
     217                " WHERE newExp.exp_id IS NOT NULL"
     218                " AND rawScienceExp.exp_id IS NULL"
     219                " AND rawDetrendExp.exp_id IS NULL) AS foo"
     220        " %s"; // WHERE class is generated from exp_id, class, & class_id
     221
     222    char *whereClaus = NULL;
     223    {
     224        psMetadata *where = psMetadataAlloc();
     225        bool status = false;
     226        psString exp_id = psMetadataLookupStr(&status, config->args, "-exp_id");
     227        if (!status) {
     228            psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_id");
     229            return false;
     230        }
     231        if (exp_id) {
     232            if (!psMetadataAddStr(where, PS_LIST_TAIL, "exp_id", 0, "==", exp_id)) {
     233                psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
     234                psFree(where);
     235                return false;
     236            }
     237        }
     238        psString class = psMetadataLookupStr(&status, config->args, "-class");
     239        if (!status) {
     240            psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -class");
     241            return false;
     242        }
     243        if (class) {
     244            if (!psMetadataAddStr(where, PS_LIST_TAIL, "class", 0, "==", class)) {
     245                psError(PS_ERR_UNKNOWN, false, "failed to add item class");
     246                psFree(where);
     247                return false;
     248            }
     249        }
     250        psString class_id = psMetadataLookupStr(&status, config->args, "-class_id");
     251        if (!status) {
     252            psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -class_id");
     253            return false;
     254        }
     255        if (class_id) {
     256            if (!psMetadataAddStr(where, PS_LIST_TAIL, "class_id", 0, "==", class_id)) {
     257                psError(PS_ERR_UNKNOWN, false, "failed to add item class_id");
     258                psFree(where);
     259                return false;
     260            }
     261        }
     262
     263        // there's not
     264        whereClaus = psDBGenerateWhereSQL(where);
     265        psFree(where);
     266    }
     267
     268    if (!p_psDBRunQuery(config->dbh, query, whereClaus)) {
     269        psError(PS_ERR_UNKNOWN, false, "database error");
     270        psFree(whereClaus);
     271        return false;
     272    }
     273    psFree(whereClaus);
     274
     275    psArray *newImfiles = p_psDBFetchResult(config->dbh);
     276    if (!newImfiles) {
     277        // XXX check psError here
     278        psError(PS_ERR_UNKNOWN, false, "failed to fetch the database result");
     279        return false;
     280    }
     281
     282    // insert 'newImfile's into rawImfile
     283    if (psArrayLength(newImfiles) > 0) {
     284        // start a transaction so we don't end up half of the imfiles we were
     285        // trying to update uninserted
    97286        if (!psDBTransaction(config->dbh)) {
    98287            psError(PS_ERR_UNKNOWN, false, "database error");
    99             psFree(exp);
    100             psFree(new);
     288            psFree(newImfiles);
    101289            return false;
    102290        }
    103291
    104         for (long i = 0; i < psArrayLength(new); i++) {
    105             newFrame *newFrame = new->data[i];
    106             if (detrend) {
    107                 // it's a detrend frame
    108                 rawDetrendFrame *frame = newToRawDetrendFrame(config, newFrame);
    109                 if (!frame) {
    110                     psError(PS_ERR_UNKNOWN, false, "failed to convert new frame into a detrend frame");
    111                     psFree(new);
    112                     return false;
    113                 }
    114                 if (!rawDetrendFrameInsert(config, frame)) {
    115                     // rollback
    116                     if (!psDBRollback(config->dbh)) {
    117                         psError(PS_ERR_UNKNOWN, false, "database error");
    118                     }
    119                     psError(PS_ERR_UNKNOWN, false, "failed to insert frame into the database");
    120                     psFree(frame);
    121                     psFree(new);
    122                     return false;
    123                 }
    124                 psFree(frame);
    125                 continue;
    126             }
    127 
    128             // else
    129             // it's a science frame
    130             // insert into into rawScienceExp
    131             rawScienceFrame *frame = newToRawScienceFrame(config, newFrame);
    132             if (!frame) {
     292        for (long i = 0; i < psArrayLength(newImfiles); i++) {
     293            newImfileRow *object = newImfileObjectFromMetadata(newImfiles->data[i]);
     294            rawImfileRow *imfile = newToRawImfile(config, object);
     295            psFree(object);
     296            if (!imfile) {
    133297                // rollback
    134298                if (!psDBRollback(config->dbh)) {
    135299                    psError(PS_ERR_UNKNOWN, false, "database error");
    136300                }
    137                 psError(PS_ERR_UNKNOWN, false, "failed to convert new frame into a science frame");
    138                 psFree(new);
     301                psError(PS_ERR_UNKNOWN, false, "failed to create a new rawImfile row");
     302                psFree(newImfiles);
    139303                return false;
    140304            }
    141             if (!rawScienceFrameInsert(config, frame)) {
     305            if (!rawImfileInsertObject(config->dbh, imfile)) {
    142306                // rollback
    143307                if (!psDBRollback(config->dbh)) {
    144308                    psError(PS_ERR_UNKNOWN, false, "database error");
    145309                }
    146                 psError(PS_ERR_UNKNOWN, false, "failed to insert frame into the database");
    147                 psFree(frame);
    148                 psFree(new);
     310                psError(PS_ERR_UNKNOWN, false, "failed to insert row into the database");
     311                psFree(imfile);
     312                psFree(newImfiles);
    149313                return false;
    150314            }
    151             psFree(frame);
    152 
    153             // insert into into p2PendingExp
    154             // XXX add a newToP2PendingFrame()
    155             // XXX add a p2PendingFrameInsert()
    156             p2PendingExpRow *exp = newToP2PendingExp(config, newFrame->exposure);
    157             if (!exp) {
    158                 // rollback
    159                 if (!psDBRollback(config->dbh)) {
    160                     psError(PS_ERR_UNKNOWN, false, "database error");
    161                 }
    162                 psError(PS_ERR_UNKNOWN, false, "failed to convert newExp into a p2PendingExp");
    163                 psFree(new);
    164                 return false;
    165             }
    166 
    167             if (!p2PendingExpInsertObject(config->dbh, exp)) {
    168                 // rollback
    169                 if (!psDBRollback(config->dbh)) {
    170                     psError(PS_ERR_UNKNOWN, false, "database error");
    171                 }
    172                 psError(PS_ERR_UNKNOWN, false, "failed to insert p2PendingExp into the database");
    173                 psFree(exp);
    174                 psFree(new);
    175                 return false;
    176             }
    177             psFree(exp);
    178 
    179             // insert into into p2PendingImfiles
    180             for (long i = 0; i < psArrayLength(newFrame->images); i++) {
    181                 p2PendingImfileRow *imfile = newImfileToP2PendingImfile(newFrame->images->data[i]);
    182                 if (!p2PendingImfileInsertObject(config->dbh, imfile)) {
    183                     // rollback
    184                     if (!psDBRollback(config->dbh)) {
    185                         psError(PS_ERR_UNKNOWN, false, "database error");
    186                     }
    187                     psError(PS_ERR_UNKNOWN, false, "failed to insert p2PendingImfile into the database");
    188                     psFree(imfile);
    189                     psFree(new);
    190                     return false;
    191                 }
    192                 psFree(imfile);
    193             }
    194         }
    195         // point of no return for p2Pending[Exp|Imfile]
     315            psFree(imfile);
     316        }
     317
     318        // point of no return for rawImfile
    196319        if (!psDBCommit(config->dbh)) {
    197320            psError(PS_ERR_UNKNOWN, false, "database error");
     321            psFree(newImfiles);
    198322            return false;
    199323        }
    200324    }
    201325
    202     psFree(new);
     326    psFree(newImfiles);
    203327
    204328    return true;
    205329}
    206330
     331#if 0
    207332static psArray *newFrameSearchPending(pxConfig *config)
    208333{
    209334    PS_ASSERT_PTR_NON_NULL(config, NULL);
    210335
    211     psArray *new = newFrameSearch(config);
    212     if (!new) {
    213         psError(PS_ERR_UNKNOWN, false, "no newFrames found");
    214         return false;
    215     }
    216 
    217     psArray *raw = rawScienceFrameSearch(config);
    218     if (!raw) {
    219         psError(PS_ERR_UNKNOWN, false, "no rawScienceFrames found");
    220     //    return false;
    221     }
    222 
    223     psArray *rawDetrend = rawDetrendFrameSearch(config);
    224     if (!rawDetrend) {
    225         psError(PS_ERR_UNKNOWN, false, "no rawDetrendFrames found");
    226     //    return false;
    227     }
    228 
    229     // ignore duplicate raw frames
    230     if (raw) {
    231         for (long i = 0; i < new->n; i++) {
    232             newFrame *newFrame = new->data[i];
    233             for (long j = 0; j < raw->n; j++) {
    234                 rawScienceFrame *rawScienceFrame = raw->data[j];
    235                 if (strcmp(newFrame->exposure->exp_id,
    236                            rawScienceFrame->exposure->exp_id) == 0) {
    237                     psArrayRemove(new, newFrame);
    238                     // dec the counter as the array just got shorter
    239                     //and we don't want to skip elemnts
    240                     i--;
    241                     break;
    242                 }
    243             }
    244         }
    245         psFree(raw);
    246     }
    247 
    248     // ignore duplicate rawDetrend frames
    249     if (rawDetrend) {
    250         for (long i = 0; i < new->n; i++) {
    251             newFrame *newFrame = new->data[i];
    252             for (long j = 0; j < rawDetrend->n; j++) {
    253                 rawDetrendFrame *rawDetrendFrame = rawDetrend->data[j];
    254                 if (strcmp(newFrame->exposure->exp_id,
    255                            rawDetrendFrame->exposure->exp_id) == 0) {
    256                     psArrayRemove(new, newFrame);
    257                     // dec the counter as the array just got shorter
    258                     //and we don't want to skip elemnts
    259                     i--;
    260                     break;
    261                 }
    262             }
    263         }
    264         psFree(rawDetrend);
    265     }
     336    char *query = "select newImfile.* from newImfile
     337        LEFT JOIN newExp USING(exp_id)
     338        LEFT JOIN rawScienceExp USING(exp_id)
     339        LEFT JOIN rawDetrendExp USING (exp_id)
     340        WHERE newExp.exp_id is NOT NULL
     341        AND rawScienceExp.exp_id IS NULL
     342        AND rawDetrendExp.exp_id IS NULL";
     343
     344    if (!p_psDBRunQuery(config->dbh, query)) {
     345        psError(PS_ERR_UNKNOWN, false, "database error");
     346        return false;
     347    }
     348
     349    psArray *newExp = p_psDBFetchResult(config->dbh);
     350    if (!output) {
     351        // XXX check psError here
     352        psError(PS_ERR_UNKNOWN, false, "failed to fetch the database result");
     353        return false;
     354    }
     355
     356    for (long i = 0; i < psArrayLength(newExp); i++) {
     357        newExpRow *exp = newExp->data[i];
     358        psMetadata *where = psMetadataAlloc();
     359        if (!psMetadataAddStr(where, PS_LIST_TAIL, "exp_id", 0, NULL, exp->exp_id)) {
     360            psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
     361            psFree(where);
     362            psFree(newExp);
     363            return NULL;
     364        }
     365        new
     366
     367        psFree(where);
     368    }
     369
    266370
    267371    return new;
    268372}
    269373
     374#endif
    270375
    271376static p1PendingExpRow *newToP1PendingExp(newExpRow *newExp)
    … …  
    379484}
    380485
     486#if 0
    381487static rawScienceFrame *newToRawScienceFrame(pxConfig *config, newFrame *newFrame)
    382488{
    … …  
    411517    return rawScienceFrame;
    412518}
     519
     520#endif
    413521
    414522static rawScienceExpRow *newToRawScienceExp(pxConfig *config, newExpRow *exp)
    … …  
    488596}
    489597
    490 
     598static rawDetrendExpRow *newToRawDetrendExp(pxConfig *config, newExpRow *exp)
     599{
     600    PS_ASSERT_PTR_NON_NULL(config, NULL);
     601    PS_ASSERT_PTR_NON_NULL(exp, NULL);
     602
     603    bool status = false;
     604    psString filter = psMetadataLookupStr(&status, config->args, "-filter");
     605    if (!status) {
     606        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -filter");
     607        return false;
     608    }
     609    if (!filter) {
     610        psError(PS_ERR_UNKNOWN, true, "-filter is required");
     611        return false;
     612    }
     613    psF32 airmass = psMetadataLookupF32(&status, config->args, "-airmass");
     614    if (!status) {
     615        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -airmass");
     616        return false;
     617    }
     618    if (isnan(airmass)) {
     619        psError(PS_ERR_UNKNOWN, true, "-airmass is required");
     620        return false;
     621    }
     622    psF64 ra = psMetadataLookupF64(&status, config->args, "-ra");
     623    if (!status) {
     624        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -ra");
     625        return false;
     626    }
     627    if (isnan(ra)) {
     628        psError(PS_ERR_UNKNOWN, true, "-airmass is required");
     629        return false;
     630    }
     631    psF64 decl = psMetadataLookupF64(&status, config->args, "-decl");
     632    if (!status) {
     633        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -decl");
     634        return false;
     635    }
     636    if (isnan(decl)) {
     637        psError(PS_ERR_UNKNOWN, true, "-decl is required");
     638        return false;
     639    }
     640    psF32 exp_time = psMetadataLookupF32(&status, config->args, "-exp_time");
     641    if (isnan(exp_time)) {
     642        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_time");
     643        return false;
     644    }
     645    if (!exp_time) {
     646        psError(PS_ERR_UNKNOWN, true, "-exp_time is required");
     647        return false;
     648    }
     649    psF64 background = psMetadataLookupF64(&status, config->args, "-background");
     650    if (!status) {
     651        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -background");
     652        return false;
     653    }
     654    if (!exp_time) {
     655        psError(PS_ERR_UNKNOWN, true, "-background is required");
     656        return false;
     657    }
     658
     659    return rawDetrendExpRowAlloc(
     660        exp->exp_id,
     661        exp->camera,
     662        exp->telescope,
     663        exp->exp_type,
     664        exp->imfiles,
     665        filter,
     666        airmass,
     667        ra,
     668        decl,
     669        exp_time,
     670        background
     671    );
     672}
     673
     674static rawImfileRow *newToRawImfile(pxConfig *config, newImfileRow *imfile)
     675{
     676    PS_ASSERT_PTR_NON_NULL(config, NULL);
     677    PS_ASSERT_PTR_NON_NULL(exp, NULL);
     678
     679    bool status = false;
     680    psString filter = psMetadataLookupStr(&status, config->args, "-filter");
     681    if (!status) {
     682        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -filter");
     683        return false;
     684    }
     685    if (!filter) {
     686        psError(PS_ERR_UNKNOWN, true, "-filter is required");
     687        return false;
     688    }
     689    psF32 airmass = psMetadataLookupF32(&status, config->args, "-airmass");
     690    if (!status) {
     691        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -airmass");
     692        return false;
     693    }
     694    if (isnan(airmass)) {
     695        psError(PS_ERR_UNKNOWN, true, "-airmass is required");
     696        return false;
     697    }
     698    psF64 ra = psMetadataLookupF64(&status, config->args, "-ra");
     699    if (!status) {
     700        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -ra");
     701        return false;
     702    }
     703    if (isnan(ra)) {
     704        psError(PS_ERR_UNKNOWN, true, "-ra is required");
     705        return false;
     706    }
     707    psF64 decl = psMetadataLookupF64(&status, config->args, "-decl");
     708    if (!status) {
     709        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -decl");
     710        return false;
     711    }
     712    if (isnan(decl)) {
     713        psError(PS_ERR_UNKNOWN, true, "-decl is required");
     714        return false;
     715    }
     716    psF32 exp_time = psMetadataLookupF32(&status, config->args, "-exp_time");
     717    if (isnan(exp_time)) {
     718        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_time");
     719        return false;
     720    }
     721    if (isnan(exp_time)) {
     722        psError(PS_ERR_UNKNOWN, true, "-exp_time is required");
     723        return false;
     724    }
     725    psF64 bg = psMetadataLookupF64(&status, config->args, "-bg");
     726    if (!status) {
     727        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg");
     728        return false;
     729    }
     730    if (isnan(bg)) {
     731        psError(PS_ERR_UNKNOWN, true, "-bg is required");
     732        return false;
     733    }
     734    psF64 bg_stdev = psMetadataLookupF64(&status, config->args, "-bg");
     735    if (!status) {
     736        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg_stdev");
     737        return false;
     738    }
     739    if (isnan(bg_stdev)) {
     740        psError(PS_ERR_UNKNOWN, true, "-bg_stdev is required");
     741        return false;
     742    }
     743    psF64 bg_mean_stdev = psMetadataLookupF64(&status, config->args, "-bg");
     744    if (!status) {
     745        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg_mean_stdev");
     746        return false;
     747    }
     748    if (isnan(bg_mean_stdev)) {
     749        psError(PS_ERR_UNKNOWN, true, "-bg_mean_stdev is required");
     750        return false;
     751    }
     752    psF64 alt = psMetadataLookupF64(&status, config->args, "-bg");
     753    if (!status) {
     754        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -alt");
     755        return false;
     756    }
     757    if (isnan(alt)) {
     758        psError(PS_ERR_UNKNOWN, true, "-alt is required");
     759        return false;
     760    }
     761    psF64 az = psMetadataLookupF64(&status, config->args, "-bg");
     762    if (!status) {
     763        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -az");
     764        return false;
     765    }
     766    if (isnan(az)) {
     767        psError(PS_ERR_UNKNOWN, true, "-az is required");
     768        return false;
     769    }
     770    psF32 ccd_temp = psMetadataLookupF32(&status, config->args, "-bg");
     771    if (!status) {
     772        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -ccd_temp");
     773        return false;
     774    }
     775    if (isnan(ccd_temp)) {
     776        psError(PS_ERR_UNKNOWN, true, "-ccd_temp is required");
     777        return false;
     778    }
     779    psF64 posang = psMetadataLookupF32(&status, config->args, "-bg");
     780    if (!status) {
     781        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -posang");
     782        return false;
     783    }
     784    if (isnan(posang)) {
     785        psError(PS_ERR_UNKNOWN, true, "-posang is required");
     786        return false;
     787    }
     788
     789    return rawImfileRowAlloc(
     790        imfile->exp_id,
     791        imfile->class,
     792        imfile->class_id,
     793        imfile->uri,
     794        filter,
     795        airmass,
     796        ra,
     797        decl,
     798        exp_time,
     799        bg,
     800        bg_stdev,
     801        bg_mean_stdev,
     802        alt,
     803        az,
     804        ccd_temp,
     805        posang
     806    );
     807}
     808

  • trunk/ippTools/src/regtool.h

    r7820 r8250  
    66typedef enum {
    77    P0SEARCH_MODE_NONE      = 0x0,
    8     P0SEARCH_MODE_PENDING,
    9     P0SEARCH_MODE_UPDATE
     8    P0SEARCH_MODE_PENDINGEXP,
     9    P0SEARCH_MODE_PENDINGIMFILE,
     10    P0SEARCH_MODE_UPDATEEXP,
     11    P0SEARCH_MODE_UPDATEIMFILE
    1012} p0searchMode;
    1113

  • trunk/ippTools/src/regtoolConfig.c

    r8187 r8250  
    2222    }
    2323
    24     // -pending
    25     psMetadata *pendingArgs = psMetadataAlloc();
    26     psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-exp_id",  0,
    27         "define exposure ID", NULL);
    28     psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-inst",  0,
    29         "define camera of interest", NULL);
    30     psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-telescope",  0,
    31         "define camera of interest", NULL);
    32     psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-exp_type",  0,
    33         "define class", NULL);
    34     psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-class",  0,
    35         "define class", NULL);
    36     psMetadataAddBool(pendingArgs, PS_LIST_TAIL, "-simple",  0,
     24    // -pendingexp
     25    psMetadata *pendingexpArgs = psMetadataAlloc();
     26    psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-exp_id",  0,
     27        "search by exposure ID", NULL);
     28    psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-inst",  0,
     29        "search by camera", NULL);
     30    psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-telescope",  0,
     31        "search by telescope", NULL);
     32    psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-exp_type",  0,
     33        "search by exposure type", NULL);
     34    psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-imfiles",  0,
     35        "search for exps with N imfiles", NULL);
     36    psMetadataAddBool(pendingexpArgs, PS_LIST_TAIL, "-simple",  0,
    3737        "use the simple output format", false);
    38 
    39 
    40     // -update
    41     psMetadata *updateArgs = psMetadataAlloc();
    42     psMetadataAddStr(updateArgs, PS_LIST_TAIL, "-exp_id",  0,
     38   
     39    // -pendingimfile
     40    psMetadata *pendingimfileArgs = psMetadataAlloc();
     41    psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-exp_id",  0,
     42        "search by exposure ID", NULL);
     43    psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-class",  0,
     44        "search by class", NULL);
     45    psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-class_id",  0,
     46        "search by class ID", NULL);
     47    psMetadataAddBool(pendingimfileArgs, PS_LIST_TAIL, "-simple",  0,
     48        "use the simple output format", false);
     49
     50
     51    // -updateexp
     52    psMetadata *updateexpArgs = psMetadataAlloc();
     53    psMetadataAddStr(updateexpArgs, PS_LIST_TAIL, "-exp_id",  0,
    4354        "exp_id to operate on", NULL);
    44     psMetadataAddStr(updateArgs, PS_LIST_TAIL, "-filter",  0,
     55    psMetadataAddStr(updateexpArgs, PS_LIST_TAIL, "-filter",  0,
    4556        "define filter ", NULL);
    46     psMetadataAddF32(updateArgs, PS_LIST_TAIL, "-airmass",  0,
     57    psMetadataAddF32(updateexpArgs, PS_LIST_TAIL, "-airmass",  0,
    4758        "define airmass", NAN);
    48     psMetadataAddF64(updateArgs, PS_LIST_TAIL, "-ra",  0,
     59    psMetadataAddF64(updateexpArgs, PS_LIST_TAIL, "-ra",  0,
    4960        "define RA", NAN);
    50     psMetadataAddF64(updateArgs, PS_LIST_TAIL, "-decl",  0,
     61    psMetadataAddF64(updateexpArgs, PS_LIST_TAIL, "-decl",  0,
    5162        "define DEC", NAN);
    52     psMetadataAddF32(updateArgs, PS_LIST_TAIL, "-exp_time",  0,
     63    psMetadataAddF32(updateexpArgs, PS_LIST_TAIL, "-exp_time",  0,
    5364        "define exposure time", NAN);
    54     psMetadataAddF64(updateArgs, PS_LIST_TAIL, "-background",  0,
     65    psMetadataAddF64(updateexpArgs, PS_LIST_TAIL, "-background",  0,
    5566        "define exposue background", NAN);
    5667    /*
    … …  
    6071        "define URL", NULL);
    6172    */
    62     psMetadataAddBool(updateArgs, PS_LIST_TAIL, "-detrend",  0,
     73    psMetadataAddBool(updateexpArgs, PS_LIST_TAIL, "-detrend",  0,
    6374        "declare this as detrend data", false);
     75   
     76    // -updateimfile
     77    psMetadata *updateimfileArgs = psMetadataAlloc();
     78    psMetadataAddStr(updateimfileArgs, PS_LIST_TAIL, "-exp_id",  0,
     79        "search by exposure ID", NULL);
     80    psMetadataAddStr(updateimfileArgs, PS_LIST_TAIL, "-class",  0,
     81        "search by class", NULL);
     82    psMetadataAddStr(updateimfileArgs, PS_LIST_TAIL, "-class_id",  0,
     83        "search by class ID", NULL);
     84    psMetadataAddStr(updateimfileArgs, PS_LIST_TAIL, "-filter",  0,
     85        "define filter ", NULL);
     86    psMetadataAddF32(updateimfileArgs, PS_LIST_TAIL, "-airmass",  0,
     87        "define airmass", NAN);
     88    psMetadataAddF64(updateimfileArgs, PS_LIST_TAIL, "-ra",  0,
     89        "define RA", NAN);
     90    psMetadataAddF64(updateimfileArgs, PS_LIST_TAIL, "-decl",  0,
     91        "define DEC", NAN);
     92    psMetadataAddF32(updateimfileArgs, PS_LIST_TAIL, "-exp_time",  0,
     93        "define exposure time", NAN);
     94    psMetadataAddF64(updateimfileArgs, PS_LIST_TAIL, "-bg",  0,
     95        "define exposue background", NAN);
     96    psMetadataAddF64(updateimfileArgs, PS_LIST_TAIL, "-background_stdev",  0,
     97        "define exposue background standard dev.", NAN);
    6498
    6599#define PXTOOL_MODE(option, modeval, argset) \
    … …  
    77111
    78112    // find which mode we're running under
    79     PXTOOL_MODE("-pending",     P0SEARCH_MODE_PENDING,      pendingArgs);
    80     PXTOOL_MODE("-update",      P0SEARCH_MODE_UPDATE,       updateArgs);
     113    PXTOOL_MODE("-pendingexp",   P0SEARCH_MODE_PENDINGEXP,  pendingexpArgs);
     114    PXTOOL_MODE("-pendingimfile",P0SEARCH_MODE_PENDINGIMFILE,pendingimfileArgs);
     115    PXTOOL_MODE("-updateimfile", P0SEARCH_MODE_UPDATEIMFILE, updateimfileArgs);
    81116
    82117    bool argErr = false;
    … …  
    91126    if (argErr) {
    92127        printf("\nPan-STARRS Phase 0 Search Tool\n");
    93         printf("Usage: %s <mode> [-update|-pending]\n\n", argv[0]);
    94         printf(" <mode> : -pending | -update\n\n");
    95         fprintf (stdout, "-pending ");
    96         psArgumentHelp(pendingArgs);
    97         psFree(pendingArgs);
    98         fprintf (stdout, "-update ");
    99         psArgumentHelp(updateArgs);
    100         psFree(updateArgs);
     128        printf("Usage: %s <mode> [<options>]\n\n", argv[0]);
     129        printf(" <mode> : [-pendingexp|-pendingimfile|-updateexp|-updateimfile]\n\n");
     130
     131        fprintf (stdout, "-pendingexp ");
     132        psArgumentHelp(pendingexpArgs);
     133        psFree(pendingexpArgs);
     134
     135        fprintf (stdout, "-pendingimfile ");
     136        psArgumentHelp(pendingimfileArgs);
     137        psFree(pendingimfileArgs);
     138
     139        fprintf (stdout, "-updateexp ");
     140        psArgumentHelp(updateexpArgs);
     141        psFree(updateexpArgs);
     142
     143        fprintf (stdout, "-updateimfile ");
     144        psArgumentHelp(updateimfileArgs);
     145        psFree(updateimfileArgs);
    101146
    102147        goto FAIL;
    103148    }
    104149
    105     psFree(pendingArgs);
    106     psFree(updateArgs);
     150    psFree(pendingexpArgs);
     151    psFree(pendingimfileArgs);
     152    psFree(updateexpArgs);
     153    psFree(updateimfileArgs);
    107154
    108155    // setup search criterion
    … …  
    136183    addWhereStr(telescope);
    137184    addWhereStr(exp_type);
     185    {
     186        int imfiles = 0;
     187        bool status = false;
     188        if ((imfiles = psMetadataLookupS32(&status, config->args, "-imfiles"))) {
     189            if (!psMetadataAddS32(config->where, PS_LIST_TAIL, "imfiles", 0, "==", imfiles)) {
     190                psError(PS_ERR_UNKNOWN, false, "failed to add item imfiles");
     191                goto FAIL;
     192            }
     193        }
     194    }
     195    addWhereStr(class);
    138196    addWhereStr(class_id);
    139197    addWhereStr(filter);
Note: See TracChangeset for help on using the changeset viewer.