Index: /trunk/ippTools/src/chiptool.c =================================================================== --- /trunk/ippTools/src/chiptool.c (revision 6059) +++ /trunk/ippTools/src/chiptool.c (revision 6060) @@ -3,34 +3,36 @@ int main (int argc, char **argv) { - psArray *rawFrames; - psArray *doneFrames; - psArray *pendingFrames; + psArray *rawFrames = NULL; + psArray *doneFrames = NULL; + psArray *pendingFrames = NULL; + + p2Config config; p2searchConfig (&config, argc, argv); - if (config->mode == P2_MODE_QUICK) { - rawFrames = p2searchRawFrames (config); - pendingFrames = p2rawToPending (config, rawFrames); - p2writePendingFrames (config, pendingFrames); + if (config.mode == P2_MODE_QUICK) { + rawFrames = p2searchRawFrames (&config); + pendingFrames = p2rawToPending (&config, rawFrames); + p2writePendingFrames (&config, pendingFrames); } - if (config->mode == P2_MODE_DEFINE) { - rawFrames = p2searchRawFrames (config); - p2insertPendingFrames (config, rawFrames); + if (config.mode == P2_MODE_DEFINE) { + rawFrames = p2searchRawFrames (&config); + p2insertPendingFrames (&config, rawFrames); } - if (config->mode == P2_MODE_PENDING) { - pendingFrames = p2searchPendingFrames (config, FALSE); - p2writePendingImages (config, pendingFrames); + if (config.mode == P2_MODE_PENDING) { + pendingFrames = p2searchPendingFrames (&config); + p2writePendingFrames (&config, pendingFrames); } - if (config->mode == P2_MODE_UPDATE) { - p2updatePendingFrames (config, pendingFrames); + if (config.mode == P2_MODE_UPDATE) { + p2updatePendingFrames (&config, pendingFrames); } - if (config->mode == P2_MODE_DONE) { - pendingFrames = p2searchPendingFrames (config, TRUE); - doneFrames = p2pendingToDone (config); - p2insertDoneFrames (config, doneFrames); + if (config.mode == P2_MODE_DONE) { + pendingFrames = p2searchPendingFrames (&config); + doneFrames = p2pendingToDone (&config, pendingFrames); + p2insertDoneFrames (&config, doneFrames); } Index: /trunk/ippTools/src/chiptool.h =================================================================== --- /trunk/ippTools/src/chiptool.h (revision 6059) +++ /trunk/ippTools/src/chiptool.h (revision 6060) @@ -7,8 +7,11 @@ # include # include +# include // load these values from the db in the init stage # define P2_TYPE_OBJECT 1 # define P2_STATE_READY 2 +# define RECIPE "foo" +# define MAX_ROWS 10e9 typedef enum { @@ -25,98 +28,59 @@ typedef struct { p2mode mode; - psTime start; - psTime stop; + psTime *start; + psTime *stop; psSphere r1; psSphere r2; - char *camera; + psMetadata *camera; + char *camera_name; char *filter; psDB *database; -} p2config; - -// this structure should be defined using the mddb api tools -typedef struct { - char expID[32]; // free-form exposure ID string - char class; // class of file: fpa (0), chip (1), cell (2), readout (3)? - int Nclass; // number of files of this class - char camera[32]; // free-form camera ID string - char filter[32]; // free-form filter ID string - psTime time_start; // exposure start time - psTime time_stop; // exposure stop time - psTime exptime; // exposure duration (seconds) - char exptype; // type of exposure: object (0), bias (1), dark (2), flat (3), etc - float sky; // measure sky brightness - float seeing; // measured image quality - float dettemp; // temperature of detector -} ppRawExposure; - -// this structure should be defined using the mddb api tools -typedef struct { - char expID[32]; // free-form exposure ID string - char class; // class of file: fpa (0), chip (1), cell (2), readout (3)? - char classID[32]; // identifier for class (chip00, cell00, etc) - char url[128]; // locator for file (neb / file) - char state; // current load state -} ppRawImfile; - -// this structure should be defined using the mddb api tools -typedef struct { - char expID[32]; // free-form exposure ID string - psU8 P2version; - char class; // class of file: fpa (0), chip (1), cell (2), readout (3)? - int Nclass; // number of files of this class - psU8 P1version; -} p2PendingExposure; - -// this structure should be defined using the mddb api tools -typedef struct { - char expID[32]; // free-form exposure ID string - char P2version; - char class; // class of file: fpa (0), chip (1), cell (2), readout (3)? - char classID[32]; // identifier for class (chip00, cell00, etc) - char urlroot[128]; // locator for file (neb / file) - char input[16]; // extension for input image - char output[16]; // extension for output image - char log[16]; // extension for log file - char smf[16]; // extension for object table -} p2PendingImfile; - -// this structure should be defined using the mddb api tools -typedef struct { - char expID[32]; // free-form exposure ID string - char class; // class of file: fpa (0), chip (1), cell (2), readout (3)? - int Nclass; // number of files of this class - int Ndone; // number of files of this class - char P1version; - char P2version; - char state; -} p2DoneExposure; - -// this structure should be defined using the mddb api tools -typedef struct { - char expID[32]; // free-form exposure ID string - char P2version; - char class; // class of file: fpa (0), chip (1), cell (2), readout (3)? - char classID[32]; // identifier for class (chip00, cell00, etc) - char urlroot[128]; // locator for file (neb / file) - char input[16]; // extension for input image - char output[16]; // extension for output image - char log[16]; // extension for log file - char smf[16]; // extension for object table - char state; // current P2 state -} p2DoneImfile; + psMetadata *site; + psMetadata *recipe; + psMetadata *arguments; +} p2Config; typedef struct { - ppRawExposure *exposure; + rawScienceExpRow *exposure; psArray *images; } ppRawFrame; +ppRawFrame *ppRawFrameAlloc( + rawScienceExpRow *exposure, + psArray *images +); + typedef struct { - ppPendingExposure *exposure; + p2PendingExpRow *exposure; psArray *images; } p2PendingFrame; +p2PendingFrame *p2PendingFrameAlloc( + p2PendingExpRow *exposure, + psArray *images +); + typedef struct { - ppDoneExposure *exposure; + p2DoneExpRow *exposure; psArray *images; } p2DoneFrame; +p2DoneFrame *p2DoneFrameAlloc( + p2DoneExpRow *exposure, + psArray *images +); + +bool p2createTables (p2Config *config); +bool p2deleteTables (p2Config *config); +bool p2adminConfig (p2Config *config, int argc, char **argv); +bool p2searchConfig (p2Config *config, int argc, char **argv); +psArray *p2rawToPending (p2Config *config, psArray *rawFrames); +psArray *p2searchRawFrames (p2Config *config); +bool p2insertPendingFrames (p2Config *config, psArray *rawFrames); +psArray *p2searchPendingFrames (p2Config *config); +bool p2writePendingImages (p2Config *config, psArray *frames); +bool p2updatePendingFrames (p2Config *config, psArray *pendingFrames); +psArray *p2pendingToDone (p2Config *config, psArray *pendingFrames); +bool p2insertDoneFrames (p2Config *config, psArray *doneFrames); +bool psTimeIsZero(psTime *time); +bool p2writePendingFrames (p2Config *config, psArray *frames); Index: /trunk/ippTools/src/chiptoolConfig.c =================================================================== --- /trunk/ippTools/src/chiptoolConfig.c (revision 6059) +++ /trunk/ippTools/src/chiptoolConfig.c (revision 6060) @@ -1,5 +1,7 @@ +#include + # include "p2search.h" -bool p2searchConfig (psConfig *config, int argc, char **argv) { +bool p2searchConfig (p2Config *config, int argc, char **argv) { // Parse the configurations (re-org a la ppImage) @@ -15,29 +17,30 @@ config->arguments = psMetadataAlloc(); // The arguments, with default values + int N; config->mode = P2_MODE_NONE; - if ((N = psArgumentGet (*argc, argv, "-quick"))) { - psArgumentRemove (N, argc, argv); - if (config->mode) psAbort ("p2search", "only one mode selection is allowed"); - config->mode = P2_MODE_QUICK; + if ((N = psArgumentGet (argc, argv, "-quick"))) { + psArgumentRemove (N, &argc, argv); + if (config->mode) psAbort ("p2search", "only one mode selection is allowed"); + config->mode = P2_MODE_QUICK; } - if ((N = psArgumentGet (*argc, argv, "-define"))) { - psArgumentRemove (N, argc, argv); - if (config->mode) psAbort ("p2search", "only one mode selection is allowed"); - config->mode = P2_MODE_DEFINE; + if ((N = psArgumentGet (argc, argv, "-define"))) { + psArgumentRemove (N, &argc, argv); + if (config->mode) psAbort ("p2search", "only one mode selection is allowed"); + config->mode = P2_MODE_DEFINE; } - if ((N = psArgumentGet (*argc, argv, "-pending"))) { - psArgumentRemove (N, argc, argv); - if (config->mode) psAbort ("p2search", "only one mode selection is allowed"); - config->mode = P2_MODE_PENDING; + if ((N = psArgumentGet (argc, argv, "-pending"))) { + psArgumentRemove (N, &argc, argv); + if (config->mode) psAbort ("p2search", "only one mode selection is allowed"); + config->mode = P2_MODE_PENDING; } - if ((N = psArgumentGet (*argc, argv, "-update"))) { - psArgumentRemove (N, argc, argv); - if (config->mode) psAbort ("p2search", "only one mode selection is allowed"); - config->mode = P2_MODE_UPDATE; + if ((N = psArgumentGet (argc, argv, "-update"))) { + psArgumentRemove (N, &argc, argv); + if (config->mode) psAbort ("p2search", "only one mode selection is allowed"); + config->mode = P2_MODE_UPDATE; } - if ((N = psArgumentGet (*argc, argv, "-done"))) { - psArgumentRemove (N, argc, argv); - if (config->mode) psAbort ("p2search", "only one mode selection is allowed"); - config->mode = P2_MODE_UPDATE; + if ((N = psArgumentGet (argc, argv, "-done"))) { + psArgumentRemove (N, &argc, argv); + if (config->mode) psAbort ("p2search", "only one mode selection is allowed"); + config->mode = P2_MODE_UPDATE; } @@ -47,7 +50,7 @@ psMetadataAddStr(config->arguments, PS_LIST_TAIL, "-pending", 0, "examine pending image table, write ppImage output", ""); psMetadataAddStr(config->arguments, PS_LIST_TAIL, "-update", 0, "update pending image table", ""); - psMetadataAddS32(config->arguments, PS_LIST_TAIL, "-time", 0, "define time range of interest", ""); - psMetadataAddS32(config->arguments, PS_LIST_TAIL, "-camera", 0, "define camera of interest", ""); - psMetadataAddS32(config->arguments, PS_LIST_TAIL, "-filter", 0, "define filter of interest", ""); + psMetadataAddS32(config->arguments, PS_LIST_TAIL, "-time", 0, "define time range of interest", 0); + psMetadataAddS32(config->arguments, PS_LIST_TAIL, "-camera", 0, "define camera of interest", 0); + psMetadataAddS32(config->arguments, PS_LIST_TAIL, "-filter", 0, "define filter of interest", 0); if (! psArgumentParse(config->arguments, &argc, argv) || argc != 2) { Index: /trunk/ippTools/src/p2insertDoneFrames.c =================================================================== --- /trunk/ippTools/src/p2insertDoneFrames.c (revision 6059) +++ /trunk/ippTools/src/p2insertDoneFrames.c (revision 6060) @@ -1,15 +1,19 @@ +# include # include "p2search.h" // select pending frames (exposure+images) which are done/not done -bool p2insertDoneFrames (p2SearchConfig *config, psArray *doneFrames) { +bool p2insertDoneFrames (p2Config *config, psArray *doneFrames) { for (int i = 0; i < doneFrames->n; i++) { - p2DoneFrame *doneFrame = doneFrames->data[i]; - p2DoneExposure *doneExposure = doneFrame->exposure; - - psArray *doneImages = doneFrame->images; - - p2DoneExposureInsertOneRow (config->database, doneExposure); - p2DoneImageInsertRows (config->database, doneImages); + p2DoneFrame *doneFrame = doneFrames->data[i]; + p2DoneExpRow *doneExposure = doneFrame->exposure; + + psArray *doneImages = doneFrame->images; + + p2DoneExpInsertObject(config->database, doneExposure); + + for (int i = 0; i < doneImages->n; i++) { + p2DoneImfileInsertObject(config->database, doneImages->data[i]); + } } return true; Index: /trunk/ippTools/src/p2insertPendingFrames.c =================================================================== --- /trunk/ippTools/src/p2insertPendingFrames.c (revision 6059) +++ /trunk/ippTools/src/p2insertPendingFrames.c (revision 6060) @@ -1,2 +1,3 @@ +#include # include "p2search.h" @@ -4,5 +5,5 @@ // NOTE this function converts the rawFrames to pendingFrames AND inserts them // this is useful since the table must be locked the whole time, to get the versions -bool p2insertPendingFrames (p2SearchConfig *config, psArray *rawFrames) { +bool p2insertPendingFrames (p2Config *config, psArray *rawFrames) { psMetadata *where = psMetadataAlloc (); @@ -12,46 +13,48 @@ // find the next available version numbers - psMetadataAddStr (where, PS_LIST_TAIL, "EXP_ID", PS_META_REPLACE, "==", rawFrame->exposure->expID); - psArray *exposures = p2PendingExposureSelectRows (config->database, where, MAX_ROWS); + psMetadataAddStr (where, PS_LIST_TAIL, "EXP_ID", PS_META_REPLACE, "==", rawFrame->exposure->exp_id); + psArray *exposures = p2PendingExpSelectRowObjects(config->database, where, MAX_ROWS); int version = -1; for (int j = 0; j < exposures->n; j++) { - p2PendingExposure *exposure = exposures->data[j]; - version = PS_MAX (version, exposure->P2version); + p2PendingExpRow *exposure = exposures->data[j]; + version = PS_MAX (version, exposure->p2_version); } version ++; - p2PendingExposureRow *pendingExposure = p2PendingExposureAlloc (); - strcpy (pendingExposure->expID, rawFrame->exposure->expID); - pendingExposure->class = rawFrame->exposure->class; - pendingExposure->Nclass = rawFrame->exposure->Nclass; - pendingExposure->Ndone = 0; - pendingExposure->P1version = 0xff; - pendingExposure->P2version = version; - pendingExposure->state = P2_STATE_PENDING; + p2PendingExpRow *pendingExposure = p2PendingExpRowAlloc( + rawFrame->exposure->exp_id, + rawFrame->exposure->class, + rawFrame->exposure->nclass, + 0xff, + version + // pendingExposure->Ndone = 0; + // pendingExposure->state = P2_STATE_PENDING; + ); psArray *pendingImages = psArrayAlloc (rawFrame->images->n); pendingImages->n = 0; for (int j = 0; j < rawFrame->images->n; j++) { - ppRawImage *rawImage = rawFrame->images->data[j]; - p2PendingImage *pendingImage = p2PendingImageAlloc (); - - strcpy (pendingImage->expID, rawImage->expID); - pendingImage->P2version = version; - pendingImage->class = rawImage->class; - strcpy (pendingImage->classID, rawImage->classID); - - // XXX cleanup the url somehow - strcpy (pendingImage->urlroot = rawImage->url); - strcpy (pendingImage->input, "raw.fits"); - strcpy (pendingImage->output, "flt.fits"); - strcpy (pendingImage->log, "log"); - strcpy (pendingImage->smf, "smf"); - pendingImage->state = P2_STATE_PENDING; + rawImfileRow *rawImage = rawFrame->images->data[j]; + p2PendingImfileRow *pendingImage = p2PendingImfileRowAlloc( + rawImage->exp_id, + rawImage->class, + rawImage->class_id, + version, // p1 + version, // p2 + "", + "", + // XXX cleanup the url somehow + rawImage->url + ); psArrayAdd (pendingImages, 100, pendingImage); } - p2PendingExposureInsertObject (config->database, pendingExposure); - p2PendingImageInsertObjects (config->database, pendingImages); + p2PendingExpInsertObject (config->database, pendingExposure); + + for (int i = 0; i < pendingImages->n; i++) { + p2PendingImfileInsertObject(config->database, pendingImages->data[i]); + } + } return true; Index: /trunk/ippTools/src/p2pendingToDone.c =================================================================== --- /trunk/ippTools/src/p2pendingToDone.c (revision 6059) +++ /trunk/ippTools/src/p2pendingToDone.c (revision 6060) @@ -2,46 +2,51 @@ // select pending frames (exposure+images) which are done/not done -psArray *p2pendingToDone (p2SearchConfig *config, psArray *pendingFrames) { +psArray *p2pendingToDone (p2Config *config, psArray *pendingFrames) { - psArray *doneFrames = psArrayAlloc (frames->n); + psArray *doneFrames = psArrayAlloc(pendingFrames->n); doneFrames->n = 0; for (int i = 0; i < pendingFrames->n; i++) { - ppPendingFrame *pendingFrame = pendingFrames->data[i]; - if (pendingFrame->exposure->state != P2_STATE_DONE) continue; + p2PendingFrame *pendingFrame = pendingFrames->data[i]; +// if (pendingFrame->exposure->state != P2_STATE_DONE) continue; - p2DoneExposure *doneExposure = p2DoneExposureAlloc (); - strcpy (doneExposure->expID, pendingFrame->exposure->expID); - doneExposure->class = pendingFrame->exposure->class; - doneExposure->Nclass = pendingFrame->exposure->Nclass; - doneExposure->Ndone = pendingFrame->exposure->Nclass; - doneExposure->P1version = pendingFrame->exposure->P1version; - doneExposure->P2version = pendingFrame->exposure->P2version; - doneExposure->state = P2_STATE_DONE; + p2DoneExpRow *doneExposure = p2DoneExpRowAlloc( + pendingFrame->exposure->exp_id, + pendingFrame->exposure->class, + pendingFrame->exposure->nclass, + pendingFrame->exposure->nclass, // XXX ndone is uneeded? + pendingFrame->exposure->p1_version, + pendingFrame->exposure->p2_version + //doneExposure->state = P2_STATE_DONE; + ); psArray *doneImages = psArrayAlloc (pendingFrame->images->n); doneImages->n = 0; for (int j = 0; j < pendingFrame->images->n; j++) { - ppPendingImage *pendingImage = pendingFrame->images->data[j]; + p2PendingImfileRow *pendingImage = pendingFrame->images->data[j]; + + /* if (pendingImage->state != P2_STATE_DONE) { psAbort ("p2search", "programming error!"); } + */ - p2DoneImage *doneImage = p2DoneImageAlloc (); + p2DoneImfileRow *doneImage = p2DoneImfileRowAlloc( + pendingImage->exp_id, + pendingImage->class, + pendingImage->class_id, + pendingImage->p1_version, + pendingImage->p2_version, + "", // recipe + "", // stats + pendingImage->url + ); - strcpy (doneImage->expID, pendingImage->expID); - doneImage->P2version = pendingImage->P2version; - doneImage->class = pendingImage->class; - strcpy (doneImage->classID, pendingImage->classID); - strcpy (doneImage->urlroot, pendingImage->urlroot); - strcpy (doneImage->input, pendingImage->input); - strcpy (doneImage->output, pendingImage->output); - strcpy (doneImage->log, pendingImage->log); - strcpy (doneImage->smf, pendingImage->smf); - doneImage->state = P2_STATE_DONE; psArrayAdd (doneImages, 100, doneImage); } - p2DoneFrame *doneFrame = p2DoneFrameAlloc (doneExposure, doneImages); + // XXX FIXME + p2DoneFrame *doneFrame = p2DoneFrameAlloc(doneExposure, doneImages); + psArrayAdd (doneFrames, 100, doneFrame); } Index: /trunk/ippTools/src/p2rawToPending.c =================================================================== --- /trunk/ippTools/src/p2rawToPending.c (revision 6059) +++ /trunk/ippTools/src/p2rawToPending.c (revision 6060) @@ -2,7 +2,7 @@ // select pending frames (exposure+images) which are done/not done -psArray *p2rawToPending (p2SearchConfig *config, psArray *rawFrames) { +psArray *p2rawToPending (p2Config *config, psArray *rawFrames) { - psArray *pendingFrames = psArrayAlloc (frames->n); + psArray *pendingFrames = psArrayAlloc (rawFrames->n); pendingFrames->n = 0; @@ -10,30 +10,26 @@ ppRawFrame *rawFrame = rawFrames->data[i]; - p2PendingExposure *pendingExposure = p2PendingExposureAlloc (); - strcpy (pendingExposure->expID, rawFrame->exposure->expID); - pendingExposure->class = rawFrame->exposure->class; - pendingExposure->Nclass = rawFrame->exposure->Nclass; - pendingExposure->Ndone = 0; - pendingExposure->P1version = 0xff; - pendingExposure->P2version = 0xff; - pendingExposure->state = P2_STATE_PENDING; + p2PendingExpRow *pendingExposure = p2PendingExpRowAlloc( + rawFrame->exposure->exp_id, + rawFrame->exposure->class, + rawFrame->exposure->nclass, + 0xff, // p1 + 0xff // p2 + ); psArray *pendingImages = psArrayAlloc (rawFrame->images->n); pendingImages->n = 0; for (int j = 0; j < rawFrame->images->n; j++) { - ppRawImage *rawImage = rawFrame->images->data[j]; - p2PendingImage *pendingImage = p2PendingImageAlloc (); - - strcpy (pendingImage->expID, rawImage->expID); - pendingImage->P2version = 0xff; - pendingImage->class = rawImage->; - strcpy (pendingImage->classID, rawImage->classID); - - pendingImage->urlroot = rawImage->; - strcpy (pendingImage->input, "raw.fits"); - strcpy (pendingImage->output, "flt.fits"); - strcpy (pendingImage->log, "log"); - strcpy (pendingImage->smf, "smf"); - pendingImage->state = P2_STATE_PENDING; + rawImfileRow *rawImage = rawFrame->images->data[j]; + p2PendingImfileRow *pendingImage = p2PendingImfileRowAlloc( + rawImage->exp_id, + rawImage->class, + rawImage->class_id, + 0xff, // p1 + 0xff, // p2 + "", // recipe + "", // stats + rawImage->url + ); psArrayAdd (pendingImages, 100, pendingImage); Index: /trunk/ippTools/src/p2searchPendingFrames.c =================================================================== --- /trunk/ippTools/src/p2searchPendingFrames.c (revision 6059) +++ /trunk/ippTools/src/p2searchPendingFrames.c (revision 6060) @@ -1,6 +1,14 @@ # include "p2search.h" +bool psTimeIsZero(psTime *time) { + if (time->sec == 0 || time->nsec == 0) { + return false; + } + + return true; +} + // select pending frames (exposure+images) which are done/not done -psArray *p2searchPendingFrames (p2SearchConfig *config) { +psArray *p2searchPendingFrames (p2Config *config) { // build 'where' structure @@ -9,15 +17,15 @@ // in order to include these restrictions, we need to define these table columns if (config->camera != NULL) { - psMetadataAddStr (where, PS_LIST_TAIL, "CAMERA", 0, "==", config->camera); + psMetadataAddStr (where, PS_LIST_TAIL, "CAMERA", 0, "==", config->camera_name); } if (config->filter != NULL) { - psMetadataAddStr (where, PS_LIST_TAIL, "FILTER", 0, "==", config->filter); + psMetadataAddStr (where, PS_LIST_TAIL, "FILTER", 0, "==", config->filter); } if (!psTimeIsZero(config->start) && !psTimeIsZero(config->stop)) { - psMetadataAddTime (where, PS_LIST_TAIL, "TIME_START", 0, "<", config->time_stop); - psMetadataAddTime (where, PS_LIST_TAIL, "TIME_STOP", 0, ">", config->time_start); + psMetadataAddTime (where, PS_LIST_TAIL, "TIME_START", 0, "<", config->stop); + psMetadataAddTime (where, PS_LIST_TAIL, "TIME_STOP", 0, ">", config->start); } - psArray *exposures = p2PendingExposureSelectRows (config->database, where, MAX_ROWS); + psArray *exposures = p2PendingExpSelectRowObjects (config->database, where, MAX_ROWS); psFree (where); @@ -26,14 +34,14 @@ // 'where' to select each exposure - psMetadata *where = psMetadataAlloc (); + where = psMetadataAlloc (); for (int i = 0; i < exposures->n; i++) { - p2PendingExposure *exposure = exposures->data[i]; + p2PendingExpRow *exposure = exposures->data[i]; - psMetadataAddStr (where, PS_LIST_TAIL, "EXP_ID", PS_META_REPLACE, "==", exposure->expID); - psMetadataAddStr (where, PS_LIST_TAIL, "P2_VERSION", PS_META_REPLACE, "==", exposure->P2version); + psMetadataAddStr (where, PS_LIST_TAIL, "EXP_ID", PS_META_REPLACE, "==", exposure->exp_id); + psMetadataAddS32 (where, PS_LIST_TAIL, "P2_VERSION", PS_META_REPLACE, "==", exposure->p2_version); - psArray *images = ppPendingImageSelectRows (config->database, where, MAX_ROWS); + psArray *images = p2PendingImfileSelectRowObjects (config->database, where, MAX_ROWS); - ppPendingFrame *frame = ppPendingFrameAlloc (exposure, images); + p2PendingFrame *frame = p2PendingFrameAlloc (exposure, images); psArrayAdd (frames, 100, frame); Index: /trunk/ippTools/src/p2searchRawFrames.c =================================================================== --- /trunk/ippTools/src/p2searchRawFrames.c (revision 6059) +++ /trunk/ippTools/src/p2searchRawFrames.c (revision 6060) @@ -2,13 +2,13 @@ // select raw frames (exposure+images) which match the given config options -psArray p2searchRawImages (p2SearchConfig *config) { +psArray *p2searchRawFrames (p2Config *config) { // build 'where' structure psMetadata *where = psMetadataAlloc (); - psMetadataAddU8 (where, PS_LIST_TAIL, "TYPE", 0, "==", P2_TYPE_OBJECT); + psMetadataAddS32 (where, PS_LIST_TAIL, "TYPE", 0, "==", P2_TYPE_OBJECT); if (config->camera != NULL) { - psMetadataAddStr (where, PS_LIST_TAIL, "CAMERA", 0, "==", config->camera); + psMetadataAddStr (where, PS_LIST_TAIL, "CAMERA", 0, "==", config->camera_name); } if (config->filter != NULL) { @@ -16,9 +16,9 @@ } if (!psTimeIsZero(config->start) && !psTimeIsZero(config->stop)) { - psMetadataAddTime (where, PS_LIST_TAIL, "TIME_START", 0, "<", config->time_stop); - psMetadataAddTime (where, PS_LIST_TAIL, "TIME_STOP", 0, ">", config->time_start); + psMetadataAddTime (where, PS_LIST_TAIL, "TIME_START", 0, "<", config->stop); + psMetadataAddTime (where, PS_LIST_TAIL, "TIME_STOP", 0, ">", config->start); } - psArray *exposures = ppRawExposureSelectRows (config->database, where, MAX_ROWS); + psArray *exposures = rawScienceExpSelectRowObjects (config->database, where, MAX_ROWS); psFree (where); @@ -27,11 +27,11 @@ // 'where' to select each exposure - psMetadata *where = psMetadataAlloc (); + where = psMetadataAlloc (); for (int i = 0; i < exposures->n; i++) { - ppRawExposure *exposure = exposures->data[i]; + rawScienceExpRow *exposure = exposures->data[i]; - psMetadataAddStr (where, PS_LIST_TAIL, "EXP_ID", PS_META_REPLACE, "==", exposure->expID); + psMetadataAddStr (where, PS_LIST_TAIL, "EXP_ID", PS_META_REPLACE, "==", exposure->exp_id); - psArray *images = ppRawImageSelectRows (config->database, where, MAX_ROWS); + psArray *images = rawImfileSelectRowObjects (config->database, where, MAX_ROWS); ppRawFrame *frame = ppRawFrameAlloc (exposure, images); Index: /trunk/ippTools/src/p2updatePending.c =================================================================== --- /trunk/ippTools/src/p2updatePending.c (revision 6059) +++ /trunk/ippTools/src/p2updatePending.c (revision 6060) @@ -2,22 +2,22 @@ // select pending frames (exposure+images) which are not done, select their done images, count, update -bool p2updatePendingFrames (p2SearchConfig *config, psArray *pendingFrames) { +bool p2updatePendingFrames (p2Config *config, psArray *pendingFrames) { psMetadata *where = psMetadataAlloc (); // select all of the exposures which are still pending - psMetadataAddStr (where, PS_LIST_TAIL, "STATE", 0, "==", P2_STATE_PENDING); - psArray *exposures = p2PendingExposureSelectRows (config->database, where, MAX_ROWS); + psMetadataAddS32 (where, PS_LIST_TAIL, "STATE", 0, "==", P2_MODE_PENDING); + psArray *exposures = p2PendingExpSelectRowObjects (config->database, where, MAX_ROWS); // we will now select all of the matching images which are done - psMetadataAddStr (where, PS_LIST_TAIL, "STATE", PS_META_REPLACE, "==", P2_STATE_DONE); + psMetadataAddS32 (where, PS_LIST_TAIL, "STATE", PS_META_REPLACE, "==", P2_MODE_DONE); for (int i = 0; i < exposures->n; i++) { - p2PendingExposure *exposure = exposures->data[i]; + p2PendingExpRow *exposure = exposures->data[i]; // find the next available version numbers - psMetadataAddStr (where, PS_LIST_TAIL, "EXP_ID", PS_META_REPLACE, "==", exposure->expID); - psMetadataAddStr (where, PS_LIST_TAIL, "P2_VERSION", PS_META_REPLACE, "==", exposure->P2version); - psArray *images = p2PendingImageSelectRows (config->database, where, MAX_ROWS); - if (images->n != exposure->Nclass) { + psMetadataAddStr (where, PS_LIST_TAIL, "EXP_ID", PS_META_REPLACE, "==", exposure->exp_id); + psMetadataAddS32 (where, PS_LIST_TAIL, "P2_VERSION", PS_META_REPLACE, "==", exposure->p2_version); + psArray *images = p2PendingImfileSelectRowObjects (config->database, where, MAX_ROWS); + if (images->n != exposure->nclass) { // free things continue; @@ -25,6 +25,6 @@ // frame is complete, set exposure state to done // XXX add P2 stats here? - exposure->state = P2_STATE_DONE; - p2PendingExposureUpdateRows (config->database, exposure); +// exposure->state = P2_MODE_DONE; +// p2PendingExposureUpdateRows (config->database, exposure); } return true; Index: /trunk/ippTools/src/p2writePendingFrames.c =================================================================== --- /trunk/ippTools/src/p2writePendingFrames.c (revision 6059) +++ /trunk/ippTools/src/p2writePendingFrames.c (revision 6060) @@ -2,5 +2,5 @@ // select pending frames (exposure+images) which are done/not done -bool p2writePendingImages (p2SearchConfig *config, psArray *frames) { +bool p2writePendingFrames (p2Config *config, psArray *frames) { for (int i = 0; i < frames->n; i++) { @@ -8,16 +8,11 @@ for (int j = 0; j < frame->images->n; j++) { - p2PendingImage *image = frame->images->data[j]; - fprintf (stdout, "%s %c %c %s %s %s %s %s %s %c\n", - image->expID, - image->P2version, + p2PendingImfileRow *image = frame->images->data[j]; + fprintf (stdout, "%s %d %s %s %s\n", + image->exp_id, + image->p2_version, image->class, - image->classID, - image->urlroot, - image->input, - image->output, - image->log, - image->smf, - image->state); + image->class_id, + image->url); } } Index: /trunk/ippTools/src/pxadmin.c =================================================================== --- /trunk/ippTools/src/pxadmin.c (revision 6059) +++ /trunk/ippTools/src/pxadmin.c (revision 6060) @@ -1,14 +1,17 @@ +# include + # include "p2search.h" int main (int argc, char **argv) { + p2Config config; p2adminConfig (&config, argc, argv); - if (config->mode == P2_MODE_CREATE) { - p2deleteTables (config); + if (config.mode == P2_MODE_CREATE) { + p2deleteTables (&config); } - if (config->mode == P2_MODE_DELETE) { - p2createTables (config); + if (config.mode == P2_MODE_DELETE) { + p2createTables (&config); } Index: /trunk/ippTools/src/pxadminConfig.c =================================================================== --- /trunk/ippTools/src/pxadminConfig.c (revision 6059) +++ /trunk/ippTools/src/pxadminConfig.c (revision 6060) @@ -1,5 +1,6 @@ +# include # include "p2search.h" -bool p2adminConfig (psConfig *config, int argc, char **argv) { +bool p2adminConfig (p2Config *config, int argc, char **argv) { // Parse the configurations (re-org a la ppImage) @@ -15,12 +16,13 @@ config->arguments = psMetadataAlloc(); // The arguments, with default values + int N; config->mode = P2_MODE_NONE; - if ((N = psArgumentGet (*argc, argv, "-create"))) { - psArgumentRemove (N, argc, argv); + if ((N = psArgumentGet (argc, argv, "-create"))) { + psArgumentRemove (N, &argc, argv); if (config->mode) psAbort ("p2search", "only one mode selection is allowed"); config->mode = P2_MODE_CREATE; } - if ((N = psArgumentGet (*argc, argv, "-delete"))) { - psArgumentRemove (N, argc, argv); + if ((N = psArgumentGet (argc, argv, "-delete"))) { + psArgumentRemove (N, &argc, argv); if (config->mode) psAbort ("p2search", "only one mode selection is allowed"); config->mode = P2_MODE_DELETE; @@ -38,5 +40,5 @@ psMetadataAddStr(config->arguments, PS_LIST_TAIL, "-delete", 0, "delete the P2 tables", ""); - if ((N = psArgumentGet (*argc, argv, "-help"))) { + if ((N = psArgumentGet (argc, argv, "-help"))) { psArgumentHelp(config->arguments); psFree(config->arguments); Index: /trunk/ippTools/src/pxalloc.c =================================================================== --- /trunk/ippTools/src/pxalloc.c (revision 6060) +++ /trunk/ippTools/src/pxalloc.c (revision 6060) @@ -0,0 +1,73 @@ +#include + +#include "p2search.h" + +static void ppRawFrameFree(ppRawFrame *ptr); +static void p2PendingFrameFree(p2PendingFrame *ptr); +static void p2DoneFrameFree(p2DoneFrame *ptr); + +ppRawFrame *ppRawFrameAlloc( + rawScienceExpRow *exposure, + psArray *images +) +{ + ppRawFrame *frame; + + frame = psAlloc(sizeof(ppRawFrame)); + psMemSetDeallocator(frame, (psFreeFunc)ppRawFrameFree); + + frame->exposure = exposure; + frame->images = images; + + return frame; +} + +static void ppRawFrameFree(ppRawFrame *ptr) +{ + psFree(ptr->exposure); + psFree(ptr->images); +} + +p2PendingFrame *p2PendingFrameAlloc( + p2PendingExpRow *exposure, + psArray *images +) +{ + p2PendingFrame *frame; + + frame = psAlloc(sizeof(p2PendingFrame)); + psMemSetDeallocator(frame, (psFreeFunc)p2PendingFrameFree); + + frame->exposure = exposure; + frame->images = images; + + return frame; +} + +static void p2PendingFrameFree(p2PendingFrame *ptr) +{ + psFree(ptr->exposure); + psFree(ptr->images); +} + +p2DoneFrame *p2DoneFrameAlloc( + p2DoneExpRow *exposure, + psArray *images +) +{ + p2DoneFrame *frame; + + frame = psAlloc(sizeof(p2DoneFrame)); + psMemSetDeallocator(frame, (psFreeFunc)p2DoneFrameFree); + + frame->exposure = exposure; + frame->images = images; + + return frame; +} + +static void p2DoneFrameFree(p2DoneFrame *ptr) +{ + psFree(ptr->exposure); + psFree(ptr->images); +}