Changeset 5104

Timestamp:

Sep 22, 2005, 4:54:52 PM (21 years ago)

Author:

Paul Price

Message:

Working under pslib-0.7.0, but don't have the inner loop behaving yet.

Location:

trunk/archive/scripts/src/phase2

Files:

• Makefile (modified) (1 diff)
• papPhase2.c (modified) (30 diffs)
• papStuff.c (modified) (3 diffs)
• pmConfig.c (modified) (2 diffs)
• pmFPA.c (modified) (11 diffs)
• pmFPA.h (modified) (8 diffs)
• pmFPAConstruct.c (modified) (14 diffs)
• pmFPAConstruct.h (modified) (1 diff)
• psAdditionals.c (modified) (2 diffs)
• psAdditionals.h (modified) (1 diff)

trunk/archive/scripts/src/phase2/Makefile

@@ -5 +5 @@
 DEVFLAGS += -DTESTING           # Testing version
 
-CFLAGS += -O0 -g -std=c99 -Werror -I/home/mithrandir/price/pan-starrs/jhroot/i686-pc-linux-gnu/include/ -D_GNU_SOURCE $(DEVFLAGS)
-PSLIB += -L/home/mithrandir/price/pan-starrs/jhroot/i686-pc-linux-gnu/lib/ -lpslib -lgsl -lgslcblas -lfftw3f -lsla -lcfitsio -lm -lxml2 -lmysqlclient
-PSMODULE += -L/home/mithrandir/price/pan-starrs/jhroot/i686-pc-linux-gnu/lib/ -lpsmodule
+CFLAGS += -O0 -g -std=c99 -Werror -I$(JHBUILD)/include/ -I$(JHBUILD)/include/libxml2/ -DPS_NO_TRACE -D_GNU_SOURCE $(DEVFLAGS)
+PSLIB += -L$(JHBUILD)/lib/ -lpslib -lgsl -lgslcblas -lfftw3f -lsla -lcfitsio -lm -L$(JHBUILD)/lib/libxml2/ -L$(JHBUILD)/lib/mysql/ -lxml2 -lmysqlclient
+PSMODULE += -L$(JHBUILD)/lib/ -lpsmodule
 LDFLAGS += $(PSLIB)
 
-OBJS = papPhase2.o psAdditionals.o pmConfig.o pmFPA.o pmFPAConstruct.o papStuff.o
+OBJS = papPhase2.o psAdditionals.o pmConfig.o pmFPA.o pmFPAConstruct.o papStuff.o pmFPARead.o                \
+        pmFPAConceptsGet.o pmFPAConceptsSet.o pmFPAWrite.o                                                   \
+        pmFlatField.o pmMaskBadPixels.o pmNonLinear.o pmSubtractBias.o
 TARGET = papPhase2
 

trunk/archive/scripts/src/phase2/papPhase2.c

@@ -4 +4 @@
 #include "pslib.h"
 #include "psAdditionals.h"
-
-#include "pmSubtractBias.h"
 
 #include "pmFPA.h"
 #include "pmConfig.h"
 #include "pmFPAConstruct.h"
+#include "pmFPARead.h"
+#include "pmFPAConceptsGet.h"
+#include "pmFPAWrite.h"
+
+#include "pmFlatField.h"
+#include "pmMaskBadPixels.h"
+#include "pmNonLinear.h"
+#include "pmSubtractBias.h"
 
 // Phase 2 needs to:
@@ -37 +43 @@
 #define RECIPE "PHASE2"                 // Name of the recipe to use
 
-static psMemoryId memPrintAlloc(const psMemBlock *mb)
+static psMemId memPrintAlloc(const psMemBlock *mb)
 {
     printf("Allocated memory block %lld (%lld):\n"
@@ -46 +52 @@
     return 0;
 }
-static psMemoryId memPrintFree(const psMemBlock *mb)
+static psMemId memPrintFree(const psMemBlock *mb)
 {
     printf("Freed memory block %lld (%lld):\n"
@@ -69 +75 @@
 #if 0
     // Hunting memory leaks
-    psMemAllocateCallbackSetID(3539);
-    psMemFreeCallbackSetID(3539);
+    psMemAllocateCallbackSetID(23289);
+    psMemFreeCallbackSetID(23289);
     psMemAllocateCallbackSet(memPrintAlloc);
     psMemFreeCallbackSet(memPrintFree);
 #endif
 
-//    psTraceSetLevel(".", 10);
+    psTraceSetLevel("pmConfigCameraFromHeader", 10);
 
     // Parse the configurations
@@ -88 +94 @@
     // Parse other command-line arguments
     psMetadata *arguments = psMetadataAlloc(); // The arguments, with default values
-    psMetadataAddStr(arguments, PS_LIST_TAIL, "-bias", "Name of the bias image", "");
-    psMetadataAddStr(arguments, PS_LIST_TAIL, "-dark", "Name of the dark image", "");
-    psMetadataAddStr(arguments, PS_LIST_TAIL, "-flat", "Name of the flat-field image", "");
-    psMetadataAddStr(arguments, PS_LIST_TAIL, "-mask", "Name of the mask image", "");
-    psMetadataAddS32(arguments, PS_LIST_TAIL, "-chip", "Chip number to process (if positive)", -1);
+    psMetadataAddStr(arguments, PS_LIST_TAIL, "-bias", 0, "Name of the bias image", "");
+    psMetadataAddStr(arguments, PS_LIST_TAIL, "-dark", 0, "Name of the dark image", "");
+    psMetadataAddStr(arguments, PS_LIST_TAIL, "-flat", 0, "Name of the flat-field image", "");
+    psMetadataAddStr(arguments, PS_LIST_TAIL, "-mask", 0, "Name of the mask image", "");
+    psMetadataAddS32(arguments, PS_LIST_TAIL, "-chip", 0, "Chip number to process (if positive)", -1);
     if (! psArgumentParse(arguments, &argc, argv) || argc != 3) {
         printf("\nPan-STARRS Phase 2 processing\n\n");
@@ -113 +119 @@
     printf("Mask: %s\n", maskName);
     printf("Chip: %d\n", chipNum);
-    psFree(arguments);
 
     // Open the input
@@ -132 +137 @@
 #endif
 
-#if 0
     // Open the output and output mask
     // We do it here so that we don't process the whole lot and then find out we can't open the output file
@@ -144 +148 @@
         exit(EXIT_FAILURE);
     }
+
+#if 0
     psString outputMaskName = psStringCopy(outputName);
     (void)psStringAppend(&outputMaskName, ".mask");
@@ -158 +164 @@
 #endif
 
-        
     // Get camera configuration from header if not already defined
     if (! camera) {
@@ -176 +181 @@
 
     // Construct camera in preparation for reading
-    pmFPA *input = pmFPAConstruct(camera, database);
-    pmFPA *mask = pmFPAConstruct(camera, database);
-    pmFPA *bias = pmFPAConstruct(camera, database);
-    pmFPA *dark = pmFPAConstruct(camera, database);
-    pmFPA *flat = pmFPAConstruct(camera, database);
+    pmFPA *input = pmFPAConstruct(camera);
+    pmFPA *mask = pmFPAConstruct(camera);
+    pmFPA *bias = pmFPAConstruct(camera);
+    pmFPA *dark = pmFPAConstruct(camera);
+    pmFPA *flat = pmFPAConstruct(camera);
 
     // Set various tasks
@@ -198 +203 @@
 
     if (psMetadataLookupBool(NULL, recipe, "MASK")) {
-        if (maskName) {
+        if (strlen(maskName) > 0) {
             doMask = true;
         } else {
@@ -209 +214 @@
     }
     if (psMetadataLookupBool(NULL, recipe, "BIAS")) {
-        if (biasName) {
+        if (strlen(biasName) > 0) {
             doBias = true;
         } else {
@@ -217 +222 @@
     }
     if (psMetadataLookupBool(NULL, recipe, "DARK")) {
-        if (darkName) {
+        if (strlen(darkName) > 0) {
             doDark = true;
         } else {
@@ -260 +265 @@
         }
     }
+
     if (psMetadataLookupBool(NULL, recipe, "FLAT")) {
-        if (flatName) {
+        if (strlen(flatName) > 0) {
             doFlat = true;
         } else {
@@ -269 +275 @@
     }
 
-#if 0
     // Chip selection
     if (chipNum >= 0) {
@@ -282 +287 @@
 
     // Read in the input pixels
-    if (! pmFPARead(input, inputFile)) {
+    if (! pmFPARead(input, inputFile, header, database)) {
         psErrorStackPrint(stderr, "Unable to populate camera from FITS file: %s\n", inputName);
         exit(EXIT_FAILURE);
@@ -292 +297 @@
 #endif
 
+    pmFPAPrint(input);
 
     // Load the calibration frames, if required
-    if (biasName) {
+    if (doBias) {
+#ifdef PRODUCTION
         psFits *biasFile = psFitsOpen(biasName, "r"); // File handle for bias
+#else
+        psFits *biasFile = psFitsAlloc(biasName);
+#endif
         psMetadata *biasHeader = psFitsReadHeader(NULL, biasFile); // FITS header for bias
         if (! pmConfigValidateCamera(camera, biasHeader)) {
-            psError("phase2", true, "Bias (%s) does not seem to be from the same camera.\n", biasName);
+            psError(PS_ERR_IO, true, "Bias (%s) does not seem to be from the same camera.\n", biasName);
             exit(EXIT_FAILURE);
         }
         psFree(biasHeader);
-        if (! pmFPARead(bias, biasFile)) {
+        if (! pmFPARead(bias, biasFile, NULL, database)) {
             psErrorStackPrint(stderr, "Unable to populate bias camera from fits FITS: %s\n", biasName);
             exit(EXIT_FAILURE);
         }
+#ifdef PRODUCTION
         psFitsClose(biasFile);
-    }
-
-    if (darkName) {
+#else
+        psFree(biasFile);
+#endif
+    }
+
+    if (doDark) {
+#ifdef PRODUCTION
         psFits *darkFile = psFitsOpen(darkName, "r"); // File handle for dark
+#else
+        psFits *darkFile = psFitsAlloc(darkName);
+#endif
         psMetadata *darkHeader = psFitsReadHeader(NULL, darkFile); // FITS header for dark
         if (! pmConfigValidateCamera(camera, darkHeader)) {
-            psError("phase2", true, "Dark (%s) does not seem to be from the same camera.\n", darkName);
+            psError(PS_ERR_IO, true, "Dark (%s) does not seem to be from the same camera.\n", darkName);
             exit(EXIT_FAILURE);
         }
         psFree(darkHeader);
-        if (! pmFPARead(dark, darkFile)) {
+        if (! pmFPARead(dark, darkFile, NULL, database)) {
             psErrorStackPrint(stderr, "Unable to populate dark camera from fits FITS: %s\n", darkName);
             exit(EXIT_FAILURE);
         }
+#ifdef PRODUCTION
         psFitsClose(darkFile);
-    }
-
-    if (maskName) {
+#else
+        psFree(darkFile);
+#endif
+    }
+
+    if (doMask) {
+#ifdef PRODUCTION
         psFits *maskFile = psFitsOpen(maskName, "r"); // File handle for mask
+#else
+        psFits *maskFile = psFitsAlloc(maskName);
+#endif
         psMetadata *maskHeader = psFitsReadHeader(NULL, maskFile); // FITS header for mask
         if (! pmConfigValidateCamera(camera, maskHeader)) {
-            psError("phase2", true, "Mask (%s) does not seem to be from the same camera.\n", maskName);
+            psError(PS_ERR_IO, true, "Mask (%s) does not seem to be from the same camera.\n", maskName);
             exit(EXIT_FAILURE);
         }
         psFree(maskHeader);
-        if (! pmFPARead(mask, maskFile)) {
+        if (! pmFPARead(mask, maskFile, NULL, database)) {
             psErrorStackPrint(stderr, "Unable to populate mask camera from fits FITS: %s\n", maskName);
             exit(EXIT_FAILURE);
         }
+#ifdef PRODUCTION
         psFitsClose(maskFile);
+#else
+        psFree(maskFile);
+#endif
     }
     
-    if (flatName) {
+    if (doFlat) {
+#ifdef PRODUCTION
         psFits *flatFile = psFitsOpen(flatName, "r"); // File handle for flat
+#else
+        psFits *flatFile = psFitsAlloc(flatName);
+#endif
         psMetadata *flatHeader = psFitsReadHeader(NULL, flatFile); // FITS header for flat
         if (! pmConfigValidateCamera(camera, flatHeader)) {
-            psError("phase2", true, "Flat (%s) does not seem to be from the same camera.\n", flatName);
+            psError(PS_ERR_IO, true, "Flat (%s) does not seem to be from the same camera.\n", flatName);
             exit(EXIT_FAILURE);
         }
         psFree(flatHeader);
-        if (! pmFPARead(flat, flatFile)) {
+        if (! pmFPARead(flat, flatFile, NULL, database)) {
             psErrorStackPrint(stderr, "Unable to populate flat camera from fits FITS: %s\n", flatName);
             exit(EXIT_FAILURE);
         }
+#ifdef PRODUCTION
         psFitsClose(flatFile);
+#else
+        psFree(flatFile);
+#endif
     }
     
-    psArray *inputChips = inputs->chips; // Array of chips in input image
+    psArray *inputChips = input->chips; // Array of chips in input image
     psArray *biasChips = bias->chips;   // Array of chips in bias image
     psArray *darkChips = dark->chips;   // Array of chips in dark image
@@ -377 +415 @@
 
         for (int j = 0; j < inputCells->n; j++) {
-            pmCell *inputCell = inputCells->data[i]; // Cell of interest in input image
-            pmCell *biasCell = biasCells->data[i]; // Cell of interest in bias image
-            pmCell *darkCell = darkCells->data[i]; // Cell of interest in dark imag
-            pmCell *maskCell = maskCells->data[i]; // Cell of interest in mask image
-            pmCell *flatCell = flatCells->data[i]; // Cell of interest in flat image
+            pmCell *inputCell = inputCells->data[j]; // Cell of interest in input image
+            pmCell *biasCell = biasCells->data[j]; // Cell of interest in bias image
+            pmCell *darkCell = darkCells->data[j]; // Cell of interest in dark imag
+            pmCell *maskCell = maskCells->data[j]; // Cell of interest in mask image
+            pmCell *flatCell = flatCells->data[j]; // Cell of interest in flat image
 
             if (! inputCell->valid) {
@@ -388 +426 @@
 
             psArray *inputReadouts = inputCell->readouts; // Array of readouts in input image
-            if (biasCell->readouts->n != 1) {
+            if (doBias && biasCell->readouts->n > 1) {
                 psLogMsg("phase2", PS_LOG_WARN, "Bias contains multiple readouts: only the first will be"
                          " used.");
             }
-            if (darkCell->readouts->n != 1) {
+            if (doDark && darkCell->readouts->n > 1) {
                 psLogMsg("phase2", PS_LOG_WARN, "Dark contains multiple readouts: only the first will be"
                          " used.");
             }
-            if (maskCell->readouts->n != 1) {
+            if (doMask && maskCell->readouts->n > 1) {
                 psLogMsg("phase2", PS_LOG_WARN, "Mask contains multiple readouts: only the first will be"
                          " used.");
             }
-            if (flatCell->readouts->n != 1) {
+            if (doFlat && flatCell->readouts->n > 1) {
                 psLogMsg("phase2", PS_LOG_WARN, "Flat contains multiple readouts: only the first will be"
                          " used.");
             }
 
+            pmReadout *biasReadout = NULL; // Bias readout
+            pmReadout *maskReadout = NULL; // Mask readout
+            pmReadout *flatReadout = NULL; // Flat readout
             psImage *biasImage = NULL;  // Bias pixels
             psImage *darkImage = NULL;  // Dark pixels
             float darkTime = 1.0;       // Dark time for dark image
-
-            if (biasName) {
-                pmReadout *biasReadout = biasCell->readouts->data[0]; // Readout of interest in bias image
+            psImage *maskImage = NULL;  // Mask pixels
+
+            if (doBias) {
+                biasReadout = biasCell->readouts->data[0]; // Readout of interest in bias image
                 biasImage = biasReadout->image;
             }
-            if (darkName) {
+            if (doDark) {
                 pmReadout *darkReadout = darkCell->readouts->data[0]; // Readout of interest in dark image
                 darkImage = darkReadout->image;
-                darkTime = pmReadoutGetDarkTime(darkReadout);
+                darkTime = psMetadataLookupF32(NULL, darkCell->concepts, "CELL.DARKTIME");
                 if (darkTime <= 0.0) {
                     psErrorStackPrint(stderr, "DARKTIME for dark image (%f) is non-positive.\n", darkTime);
@@ -422 +464 @@
                 }
             }
-            if (maskName) {
-                pmReadout *maskReadout = maskCell->readouts->data[0]; // Readout of interest in mask image
-            }
-            if (flatName) {
-                pmReadout *flatReadout = flatCell->readouts->data[0]; // Readout of interest in mask image
+            if (doMask) {
+                maskReadout = maskCell->readouts->data[0]; // Readout of interest in mask image
+                maskImage = maskReadout->image;
+            }
+            if (doFlat) {
+                flatReadout = flatCell->readouts->data[0]; // Readout of interest in mask image
             }
 
@@ -432 +475 @@
                 pmReadout *inputReadout = inputReadouts->data[k]; // Readout of interest in input image
                 psImage *inputImage = inputReadout->image; // The actual image
-                psList *inputBias = inputReadout->bias; // List of overscan bias regions
+                psList *inputOverscans = inputReadout->overscans; // List of overscan bias regions
 
                 // Mask bad pixels
                 if (doMask) {
+                    float saturation = psMetadataLookupF32(NULL, inputCell->concepts, "CELL.SATURATION");
+
                     // Need to change this later to grow the mask by the size of the convolution kernel
-                    (void)pmMaskBadPixels(inputReadout, maskReadout,
-                                          PS_MASK_TRAP | PS_MASK_BADCOL | PS_MASK_SAT, saturation,
-                                          PS_MASK_TRAP, 0);
+                    (void)pmMaskBadPixels(inputReadout, maskImage,
+                                          PM_MASK_TRAP | PM_MASK_BADCOL | PM_MASK_SAT, saturation,
+                                          PM_MASK_TRAP, 0);
                 }
 
@@ -450 +495 @@
                     } else {
                         switch (dataItem->type) {
-                          case PS_META_VECTOR:
-                            // These are the polynomial coefficients
-                            psVector *coeff = dataItem->data.V; // The coefficient vector
-                            if (coeff->type.type != PS_TYPE_F64) {
-                                psVector *temp = psVectorCopy(NULL, coeff, PS_TYPE_F64); // F64 version
+                          case PS_META_VEC:
+                            {
+                                // These are the polynomial coefficients
+                                psVector *coeff = dataItem->data.V; // The coefficient vector
+                                if (coeff->type.type != PS_TYPE_F64) {
+                                    psVector *temp = psVectorCopy(NULL, coeff, PS_TYPE_F64); // F64 version
+                                    psFree(coeff);
+                                    coeff = temp;
+                                }
+                                psPolynomial1D *correction = psPolynomial1DAlloc(PS_POLYNOMIAL_ORD,
+                                                                                 coeff->n + 1);
+                                for (int i = 0; i < coeff->n; i++) {
+                                    correction->coeff[i] = coeff->data.F64[i];
+                                }
+                                (void)pmNonLinearityPolynomial(inputReadout, correction);
                                 psFree(coeff);
-                                coeff = temp;
+                                psFree(correction);
                             }
-                            psPolynomial1D *correction = psPolynomial1DAlloc(PS_POLYNOMIAL_ORD,
-                                                                             coeff->n + 1);
-                            for (int i = 0; i < coeff->n; i++) {
-                                correction->coeff[i] = coeff->data.F64[i];
-                            }
-                            (void)pmNonLinearityPolynomial(inputReadout, correction);
-                            psFree(coeffCopy);
-                            psFree(coeff);
-                            psFree(correction);
                             break;
                           case PS_META_STR:
-                            // This is a filename
-                            psString name = dataItem->data.V;   // Filename
-                            psLookupTable *table = psLookupTableAlloc(name, "%f %f", 0);
-                            if (psLookupTableRead(table) <= 0) {
-                                psErrorStackPrint(stderr, "Unable to read non-linearity correction file %s "
-                                                  "--- ignored\n", tableName);
-                            } else {
-                                (void)pmNonLinearityLookup(inputReadout, table);
+                            {
+                                // This is a filename
+                                psString name = dataItem->data.V;       // Filename
+                                psLookupTable *table = psLookupTableAlloc(name, "%f %f", 0);
+                                if (psLookupTableRead(table) <= 0) {
+                                    psErrorStackPrint(stderr, "Unable to read non-linearity correction file "
+                                                      "%s --- ignored\n", name);
+                                } else {
+#ifdef PRODUCTION
+                                    (void)pmNonLinearityLookup(inputReadout, table);
+#else
+                                    printf("XXX: Non-linearity with lookup table not yet implemented.\n");
+#endif
+                                }
+                                psFree(table);
                             }
-                            psFree(table);
                             break;
                           case PS_META_META:
-                            // This is a menu
-                            psMetadata *options = dataItem->data.V; // Options with concept values as keys
-                            bool mdok = false; // Success of MD lookup
-                            psString concept = psMetadataLookupStr(&mdok, recipe, "NONLIN.SOURCE");
-                            if (! mdok || ! concept) {
-                                psLogMsg("phase2", PS_LOG_WARN, "Non-linearity correction desired, but "
-                                         "unable to find NONLIN.SOURCE in recipe --- ignored.\n");
-                            } else {
-                                psMetadataItem *conceptValueItem = pmCellGetConcept(inputCell, concept);
-                                if (! conceptValueItem) {
-                                    psLogMsg("phase2", PS_LOG_WARN, "Unable to find value of concept %s "
-                                             "for non-linearity correction --- ignored.\n", concept);
-                                } else if (conceptValueItem->type != PS_META_STR) {
-                                    psLogMsg("phase2", PS_LOG_WARN, "Type for concept %s isn't STRING, as"
-                                             " expected for non-linearity correction --- ignored.\n",
-                                             concept);
+                            {
+                                // This is a menu
+                                psMetadata *options = dataItem->data.V; // Options with concept values as keys
+                                bool mdok = false; // Success of MD lookup
+                                psString concept = psMetadataLookupString(&mdok, recipe, "NONLIN.SOURCE");
+                                if (! mdok || ! concept) {
+                                    psLogMsg("phase2", PS_LOG_WARN, "Non-linearity correction desired, but "
+                                             "unable to find NONLIN.SOURCE in recipe --- ignored.\n");
                                 } else {
-                                    psString conceptValue = conceptValueItem->data.V;
-                                    // Get the value of the concept
-                                    psMetadataItem *optionItem = psMetadataLookup(options, conceptValue);
-                                    if (!optionItem) {
-                                        psLogMsg("phase2", PS_LOG_WARN, "Unable to find %s in NONLIN.DATA"
-                                                 " --- ignored.\n", conceptValue);
-                                    } else if (optionItem->type == PS_META_VECTOR) {
-                                        // These are the polynomial coefficients
-                                        psVector *coeff = optionItem->data.V; // The coefficient vector
-                                        if (coeff->type.type != PS_TYPE_F64) {
-                                            psVector *temp = psVectorCopy(NULL, coeff, PS_TYPE_F64);
+                                    psMetadataItem *conceptValueItem = pmCellGetConcept(inputCell, concept);
+                                    if (! conceptValueItem) {
+                                        psLogMsg("phase2", PS_LOG_WARN, "Unable to find value of concept %s "
+                                                 "for non-linearity correction --- ignored.\n", concept);
+                                    } else if (conceptValueItem->type != PS_META_STR) {
+                                        psLogMsg("phase2", PS_LOG_WARN, "Type for concept %s isn't STRING, as"
+                                                 " expected for non-linearity correction --- ignored.\n",
+                                                 concept);
+                                    } else {
+                                        psString conceptValue = conceptValueItem->data.V;
+                                        // Get the value of the concept
+                                        psMetadataItem *optionItem = psMetadataLookup(options, conceptValue);
+                                        if (!optionItem) {
+                                            psLogMsg("phase2", PS_LOG_WARN, "Unable to find %s in NONLIN.DATA"
+                                                     " --- ignored.\n", conceptValue);
+                                        } else if (optionItem->type == PS_META_VEC) {
+                                            // These are the polynomial coefficients
+                                            psVector *coeff = optionItem->data.V; // The coefficient vector
+                                            if (coeff->type.type != PS_TYPE_F64) {
+                                                psVector *temp = psVectorCopy(NULL, coeff, PS_TYPE_F64);
+                                                psFree(coeff);
+                                                coeff = temp;
+                                            }
+                                            // Polynomial correction
+                                            psPolynomial1D *correction = psPolynomial1DAlloc(PS_POLYNOMIAL_ORD,
+                                                                                             coeff->n + 1);
+                                            for (int i = 0; i < coeff->n; i++) {
+                                                correction->coeff[i] = coeff->data.F64[i];
+                                            }
+                                            (void)pmNonLinearityPolynomial(inputReadout, correction);
                                             psFree(coeff);
-                                            coeff = temp;
+                                            psFree(correction);
+                                        } else if (optionItem->type == PS_META_STR) {
+                                            // This is a filename
+                                            psString tableName = optionItem->data.V; // The filename
+                                            psLookupTable *table = psLookupTableAlloc(tableName, "%f %f", 0);
+                                            int numLines = 0; // Number of lines read from table
+                                            if ((numLines = psLookupTableRead(table)) <= 0) {
+                                                psErrorStackPrint(stderr, "Unable to read non-linearity "
+                                                                  "correction file %s --- ignored\n",
+                                                                  tableName);
+                                            } else {
+#ifdef PRODUCTION
+                                                (void)pmNonLinearityLookup(inputReadout, table);
+#else
+                                                printf("XXX: Non-linearity correction from lookup table not "
+                                                       "yet implemented.\n");
+#endif
+                                            }
+                                            psFree(table);
+                                        } else {
+                                            psLogMsg("phase2", PS_LOG_WARN, "Non-linearity correction "
+                                                     "desired but unable to interpret NONLIN.DATA for %s"
+                                                     " --- ignored\n", conceptValue);
                                         }
-                                        // Polynomial correction
-                                        psPolynomial1D *correction = psPolynomial1DAlloc(PS_POLYNOMIAL_ORD,
-                                                                                         coeff->n + 1);
-                                        for (int i = 0; i < coeff->n; i++) {
-                                            correction->coeff[i] = coeff->data.F64[i];
-                                        }
-                                        (void)pmNonLinearityPolynomial(inputReadout, correction);
-                                        psFree(coeffCopy);
-                                        psFree(coeff);
-                                        psFree(correction);
-                                    } else if (optionItem->type == PS_META_STR) {
-                                        // This is a filename
-                                        psString tableName = optionItem->data.V; // The filename
-                                        psLookupTable *table = psLookupTableAlloc(tableName, "%f %f", 0);
-                                        if ((int numLines = psLookupTableRead(table)) <= 0) {
-                                            psErrorStackPrint(stderr, "Unable to read non-linearity "
-                                                              "correction file %s --- ignored\n", tableName);
-                                        } else {
-                                            (void)pmNonLinearityLookup(inputReadout, table);
-                                        }
-                                        psFree(table);
-                                    } else {
-                                        psLogMsg("phase2", PS_LOG_WARN, "Non-linearity correction "
-                                                 "desired but unable to interpret NONLIN.DATA for %s"
-                                                 " --- ignored\n", conceptValue);
                                     }
                                 }
@@ -553 +613 @@
                 // it's not in there yet.  Once it is, we can get rid of "pedestal".
 
+#ifdef PRODUCTION
                 psImage *pedestal = NULL;       // Pedestal image (bias + scaled dark)
                 if (doDark) {
-                    float inputTime = pmReadoutGetDarkTime(inputReadout); // Dark time for input image
+                    // Dark time for input image
+                    float inputTime = psMetadataLookupF32(NULL, inputCell->concepts, "CELL.DARKTIME");
                     if (inputTime <= 0) {
                         psErrorStackPrint(stderr, "DARKTIME for input image (%f) is non-positive.\n",
@@ -562 +624 @@
                     }
 
-                    pedestal = psBinaryOp(NULL, darkImage, "*",
-                                          psScalarAlloc(inputTime * darkTime, PS_TYPE_F32));
+                    pedestal = (psImage*)psBinaryOp(NULL, darkImage, "*",
+                                                    psScalarAlloc(inputTime * darkTime, PS_TYPE_F32));
                 }
                 if (doBias) {
@@ -569 +631 @@
                         if (biasImage->numRows != darkImage->numRows ||
                             biasImage->numCols != darkImage->numCols) {
-                            psError("phase2", true, "Bias and dark images have different dimensions: "
+                            psError(PS_ERR_IO, true, "Bias and dark images have different dimensions: "
                                     "%dx%d vs %dx%d\n", biasImage->numCols, biasImage->numRows,
                                     darkImage->numCols, darkImage->numRows);
@@ -579 +641 @@
                     }
                 }
-
+#endif
                 if (overscanMode == PM_OVERSCAN_ROWS || overscanMode == PM_OVERSCAN_COLUMNS) {
                     // Need to get the read direction
-                    int readdir = pmCellGetReaddir(inputCell); // Read direction
+                    int readdir = psMetadataLookupS32(NULL, inputCell->concepts, "CELL.READDIR");
                     if (readdir == 1) {
                         overscanMode = PM_OVERSCAN_ROWS;
@@ -594 +656 @@
                 }
 
-                void *overscanResult = NULL; // Result of overscan fit
-                (void)pmSubtractBias(inputImage, overscanResult, inputBias, overscanMode, overscanStat,
-                                     overscanBin, overscanFit, pedestal);
-
-                // Output overscan fit results, if required
-                if (doOverscan) {
-                    switch (overscanFit) {
-                      case PM_FIT_POLYNOMIAL:
-                        psPolynomial1D *poly = (psPolynomial1D*)overscanResult; // The polynomial
-                        psString coeffs = NULL; // String containing the coefficients
-                        for (int i = 0; i < poly->n; i++) {
-                            psStringAppend(&coeffs, "%.2f ", poly->coeffs[i]);
+                printf("mode: %d\n", overscanMode);
+
+                if (doBias || doOverscan || doDark) {
+                    void *overscanResult = NULL; // Result of overscan fit
+#ifdef PRODUCTION
+                    (void)pmSubtractBias(inputReadout, overscanResult, inputOverscans, overscanMode,
+                                         overscanStats, overscanBins, overscanFit, pedestal);
+#else
+                    (void)pmSubtractBias(inputReadout, overscanResult, inputOverscans, overscanMode,
+                                         overscanStats, overscanBins, overscanFit, biasReadout);
+#endif
+                    
+                    // Output overscan fit results, if required
+                    if (doOverscan) {
+                        switch (overscanFit) {
+                          case PM_FIT_POLYNOMIAL:
+                            {
+                                psPolynomial1D *poly = (psPolynomial1D*)overscanResult; // The polynomial
+                                psString coeffs = NULL; // String containing the coefficients
+                                for (int i = 0; i < poly->n; i++) {
+                                    psStringAppend(&coeffs, "%.2f ", poly->coeff[i]);
+                                }
+                                psLogMsg("phase2", PS_LOG_INFO, "Overscan polynomial coefficients:\n%s\n",
+                                         coeffs);
+                                psFree(coeffs);
+                            }
+                            break;
+                          case PM_FIT_SPLINE:
+                            {
+                                psSpline1D *spline = (psSpline1D*)overscanResult; // The spline
+                                psString coeffs = NULL; // String containing the coefficients
+                                for (int i = 0; i < spline->n; i++) {
+                                    psPolynomial1D *poly = spline->spline[i]; // i-th polynomial
+                                    psStringAppend(&coeffs, "%d: ", i);
+                                    for (int j = 0; j < poly->n; j++) {
+                                        psStringAppend(&coeffs, "%.2f ", poly->coeff[i]);
+                                    }
+                                    psStringAppend(&coeffs, "\n");
+                                }
+                                psLogMsg("phase2", PS_LOG_INFO, "Overscan spline coefficients:\n%s\n",
+                                         coeffs);
+                                psFree(coeffs);
+                            }
+                            break;
+                          case PM_FIT_NONE:
+                            break;
+                          default:
+                            psAbort(__func__, "Should never get here!!!\n");
                         }
-                        psLogMsg("phase2", PS_LOG_INFO, "Overscan polynomial coefficients:\n%s\n",
-                                 coeffs);
-                        psFree(coeffs);
-                        break;
-                      case PM_FIT_SPLINE:
-                        psSpline1D *spline = (psSpline1D*)overscanResult; // The spline
-                        psString coeffs = NULL; // String containing the coefficients
-                        for (int i = 0; i < spline->n; i++) {
-                            psPolynomial1D *poly = spline->spline[i]; // i-th polynomial
-                            psStringAppend(&coeffs, "%d: ", i);
-                            for (int j = 0; j < poly->n; j++) {
-                                psStringAppend(&coeffs, "%.2f ", poly->coeffs[i]);
-                            }
-                            psStringAppend(&coeffs, "\n");
-                        }
-                        psLogMsg("phase2", PS_LOG_INFO, "Overscan spline coefficients:\n%s\n", coeffs);
-                        psFree(coeffs);
-                        break;
-                      case PM_FIT_NONE:
-                        break;
-                      default:
-                        psAbort("Should never get here!!!\n");
                     }
                 }
@@ -634 +710 @@
                 // Flat-field correction
                 if (doFlat) {
-                    (void)pmFlatField(inputReadout, maskReadout, flatReadout);
+                    (void)pmFlatField(inputReadout, flatReadout);
                 }
 
@@ -659 +735 @@
 
     // Write the output
-    pmFPAWrite(outputFile, input);
-    pmFPAWriteMask(outputMaskFile, input);
+    pmFPAWrite(outputFile, input, database);
+//    pmFPAWriteMask(outputMaskFile, input);
 #ifdef PRODUCTION
     psFitsClose(outputFile);
-    psFitsClose(outputMaskFile);
+//    psFitsClose(outputMaskFile);
 #else
     psFree(outputFile);
-    psFree(outputMaskFile);
-#endif
-
-#endif
-
+//    psFree(outputMaskFile);
+#endif
+
+    psFree(arguments);
     psFree(site);
     psFree(header);
@@ -681 +756 @@
     psFree(flat);
     psFree(overscanStats);
-    psFree(inputFile);
 
 #if 1

trunk/archive/scripts/src/phase2/papStuff.c

@@ -6 +6 @@
 
 #include "papStuff.h"
+
+
+static void memPrint(const psPtr ptr)
+{
+    psMemBlock *mb = ((psMemBlock*)ptr) - 1;
+    printf("Memory block %lld (%lld):\n"
+           "\tFile %s, line %d, size %d\n"
+           "\tPosts: %x %x %x\n",
+           mb->id, mb->refCounter, mb->file, mb->lineno, mb->userMemorySize, mb->startblock, mb->endblock,
+           *(void**)((int8_t *)(mb + 1) + mb->userMemorySize));
+}
 
 // Split string on given characters
@@ -30 +41 @@
                 (void)psListAdd(values, PS_LIST_TAIL, word);
                 start = i + 1;
+                psFree(word);
             }
         }
@@ -37 +49 @@
         psString word = psStringNCopy(&string[start], length - start);
         (void)psListAdd(values, PS_LIST_TAIL, word);
+        psFree(word);
     }
 

trunk/archive/scripts/src/phase2/pmConfig.c

@@ -133 +133 @@
         }
         psTrace(__func__, 7, "Setting log destination to STDOUT.\n");
-        psLogSetDestination(0);
+        psLogSetDestination(PS_LOG_TO_STDOUT);
     }
 
@@ -147 +147 @@
             }
             psTrace(__func__, 7, "Setting trace level for %s to %d\n", traceItem->name, traceItem->data.S32);
-            (void)psTraceSetLevel(traceItem->name, traceItem->data.S32);
+            psTraceSetLevel(traceItem->name, traceItem->data.S32);
         }
         psFree(traceIter);

trunk/archive/scripts/src/phase2/pmFPA.c

@@ -1 +1 @@
 #include <stdio.h>
 #include <string.h>
+#include <assert.h>
 #include "pslib.h"
 #include "psAdditionals.h"
@@ -6 +7 @@
 #include "pmFPA.h"
 
-
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // Allocators
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-pmFPA *pmFPAAlloc(const psMetadata *camera, // Camera configuration
-                  psDB *db              // Database
+p_pmHDU *p_pmHDUAlloc(const char *extname)
+{
+    p_pmHDU *hdu = psAlloc(sizeof(p_pmHDU));
+    psMemSetDeallocator(hdu, (psFreeFunc)p_pmHDUFree);
+
+    hdu->extname = extname;
+    hdu->pixels = NULL;
+    hdu->header = NULL;
+
+    return hdu;
+}
+
+void p_pmHDUFree(p_pmHDU *hdu)
+{
+    psFree(hdu->pixels);
+    psFree(hdu->header);
+}
+
+pmFPA *pmFPAAlloc(const psMetadata *camera // Camera configuration
     )
 {
     pmFPA *fpa = psAlloc(sizeof(pmFPA));// The FPA
-    psMemSetDeallocator(fpa, (psFreeFcn)p_pmFPAFree);
+    psMemSetDeallocator(fpa, (psFreeFunc)p_pmFPAFree);
 
     // Fill in the components
@@ -23 +40 @@
     fpa->projection = NULL;
 
-    fpa->values = psMetadataAlloc();
-//    fpa->camera = psMemIncrRefCounter((psPtr)camera);
-    fpa->db = db;
+    fpa->concepts = psMetadataAlloc();
+    fpa->camera = psMemIncrRefCounter((psPtr)camera);
     fpa->chips = psArrayAlloc(0);
 
-    fpa->extname = NULL;
-    fpa->pixels = NULL;
-    fpa->header = NULL;
+    fpa->private = NULL;
 
     return fpa;
@@ -41 +55 @@
     psFree(fpa->projection);
 
-    psFree(fpa->values);
+    psFree(fpa->concepts);
     psFree((psPtr)fpa->camera);
-    psFree(fpa->db);
     psFree(fpa->chips);
 
-    psFree(fpa->pixels);
-    psFree(fpa->header);
+    psFree(fpa->private);
 }
 
@@ -55 +67 @@
 {
     pmChip *chip = psAlloc(sizeof(pmChip)); // The chip
-    psMemSetDeallocator(chip, (psFreeFcn)p_pmChipFree);
+    psMemSetDeallocator(chip, (psFreeFunc)p_pmChipFree);
 
     // Push onto the array of chips
@@ -67 +79 @@
     chip->fromFPA = NULL;
 
-    chip->values = psMetadataAlloc();
-//    chip->parent = psMemIncrRefCounter(fpa);
+    chip->concepts = psMetadataAlloc();
     chip->cells = psArrayAlloc(0);
-
-    chip->extname = NULL;
-    chip->pixels = NULL;
-    chip->header = NULL;
-
-    psMetadataAddStr(chip->values, PS_LIST_HEAD, "CHIP.NAME", "Chip name added at pmChipAlloc", name);
+    chip->parent = fpa;                 // We don't increment the reference counter on this --- it's a
+                                        // "hidden" link.  If we increment the reference counter, we get stuck
+                                        // in a circle.
+    chip->valid = true;    
+
+    chip->private = NULL;
+
+    psMetadataAddStr(chip->concepts, PS_LIST_HEAD, "CHIP.NAME", 0, "Chip name added at pmChipAlloc", name);
 
     return chip;
@@ -85 +98 @@
     psFree(chip->fromFPA);
 
-    psFree(chip->values);
+    psFree(chip->concepts);
     psFree(chip->cells);
-//    psFree(chip->parent);
-
-    psFree(chip->pixels);
-    psFree(chip->header);
+
+    psFree(chip->private);
+
+    // We don't free the parent member, since that would generate a circular call.  We don't increment the
+    // reference counter when we add it, anyway, so that's OK.
 }
 
 pmCell *pmCellAlloc(pmChip *chip,       // Chip to which the cell belongs
-                    psMetadata *values, // Initial values for concepts
+                    psMetadata *cameraData, // Camera data
                     psString name       // Name of cell
     )
 {
     pmCell *cell = psAlloc(sizeof(pmCell)); // The cell
-    psMemSetDeallocator(cell, (psFreeFcn)p_pmCellFree);
+    psMemSetDeallocator(cell, (psFreeFunc)p_pmCellFree);
 
     // Push onto the array of chips
@@ -114 +128 @@
     cell->toSky = NULL;
 
-    cell->values = psMemIncrRefCounter(values);
+    cell->concepts = psMetadataAlloc();
+    psMetadataAddStr(cell->concepts, PS_LIST_HEAD, "CELL.NAME", 0, "Cell name added at pmCellAlloc", name);
+    cell->camera = psMemIncrRefCounter(cameraData);
+
     cell->readouts = psArrayAlloc(0);
-//    cell->parent = psMemIncrRefCounter(chip);
-
-    cell->extname = NULL;
-    cell->pixels = NULL;
-    cell->header = NULL;
-
-    psMetadataAddStr(cell->values, PS_LIST_HEAD, "CELL.NAME", "Cell name added at pmCellAlloc", name);
+    cell->parent = chip;                // We don't increment the reference counter on this --- it's a
+                                        // "hidden" link.  If we increment the reference counter, we get stuck
+                                        // in a circle.
+    cell->valid = true;
+
+    cell->private = NULL;
 
     return cell;
@@ -135 +151 @@
     psFree(cell->toSky);
 
-    psFree(cell->values);
+    psFree(cell->concepts);
+    psFree(cell->camera);
     psFree(cell->readouts);
-//    psFree(cell->parent);
-
-    psFree(cell->pixels);
-    psFree(cell->header);
+
+    psFree(cell->private);
+
+    // We don't free the parent member, since that would generate a circular call.  We don't increment the
+    // reference counter when we add it, anyway, so that's OK.
 }
 
 pmReadout *pmReadoutAlloc(pmCell *cell, // Cell to which the readout belongs
-                          int readoutNum, // Number of the readout
                           psImage *image, // The pixels
                           psList *overscans, // The overscan images
@@ -151 +168 @@
 {
     pmReadout *readout = psAlloc(sizeof(pmReadout));
-    psMemSetDeallocator(readout, (psFreeFcn)p_pmReadoutFree);
-    psArray *readouts = cell->readouts;
-    if (readoutNum >= readouts->nalloc) {
-        readouts = psArrayRealloc(readouts, readoutNum);
-        cell->readouts = readouts;
-    }
-    readouts->data[readoutNum] = readout;
+    psMemSetDeallocator(readout, (psFreeFunc)p_pmReadoutFree);
+    cell->readouts = psArrayAdd(cell->readouts, 0, readout);
     
     // Set the components
-    readout->image = image;
-    readout->overscans = overscans;
+    readout->image = psMemIncrRefCounter(image);
+    readout->mask = NULL;
+    readout->overscans = psMemIncrRefCounter(overscans);
     
-    readout->values = psMetadataAlloc();
+    //readout->concepts = psMetadataAlloc();
     
     *(int*)&readout->col0 = col0;
@@ -178 +191 @@
 {
     psFree(readout->image);
+    psFree(readout->mask); 
     psFree(readout->overscans);
-    psFree(readout->values);
-}
+    //psFree(readout->concepts);
+}
+
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Select and Exclude chips
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+bool pmFPASelectChip(pmFPA *fpa, int chipNum)
+{
+    assert(fpa);
+
+    if (chipNum < 0 || chipNum > fpa->chips->n) {
+        return false;
+    }
+    psArray *chips = fpa->chips;        // Component chips
+    for (int i = 0; i < chips->n; i++) {
+        pmChip *chip = chips->data[i];  // The chip of interest
+        if (i == chipNum) {
+            psTrace(__func__, 5, "Marking chip %d valid.\n", i);
+            chip->valid = true;
+            psArray *cells = chip->cells; // Component cells
+            for (int j = 0; j < cells->n; j++) {
+                pmCell *cell = cells->data[j]; // Cell of interest
+                cell->valid = true;
+            }
+        } else {
+            psTrace(__func__, 5, "Marking chip %d invalid.\n", i);
+            chip->valid = false;
+            psArray *cells = chip->cells; // Component cells
+            for (int j = 0; j < cells->n; j++) {
+                pmCell *cell = cells->data[j]; // Cell of interest
+                cell->valid = false;
+            }
+        }
+    }
+    return true;
+}
+
+int pmFPAExcludeChip(pmFPA *fpa, int chipNum)
+{
+    assert(fpa);
+
+    if (chipNum < 0 || chipNum > fpa->chips->n) {
+        psLogMsg(__func__, PS_LOG_WARN, "Invalid chip number: %d\n", chipNum);
+    }
+    int numValid = 0;                   // Number of valid chips
+    psArray *chips = fpa->chips;        // Component chips
+    for (int i = 0; i < chips->n; i++) {
+        pmChip *chip = chips->data[i];  // The chip of interest
+        if (i == chipNum) {
+            psTrace(__func__, 5, "Marking chip %d invalid.\n", i);
+            chip->valid = false;
+            psArray *cells = chip->cells; // Component cells
+            for (int j = 0; j < cells->n; j++) {
+                pmCell *cell = cells->data[j]; // Cell of interest
+                cell->valid = false;
+            }
+        } else if (chip->valid) {
+            numValid++;
+        }
+    }
+
+    psTrace(__func__, 5, "%d valid chips in fpa.\n", numValid);
+    return numValid;
+}

trunk/archive/scripts/src/phase2/pmFPA.h

@@ -10 +10 @@
 
 typedef struct {
+    const char *extname;                // Extension name, if it corresponds to this level
+    psArray *pixels;                    // The pixel data, if it corresponds to this level
+    psMetadata *header;                 // The FITS header, if it corresponds to this level
+} p_pmHDU;
+
+typedef struct {
     // Astrometric transformations
     psPlaneDistort* fromTangentPlane;   // Transformation from tangent plane to focal plane
@@ -15 +21 @@
     psProjection *projection;           // Projection from tangent plane to sky
     // Information
-    psMetadata *values;                 // Important values (cached)
-    const psMetadata *camera;           // Camera configuration
-    psDB *db;                           // Database
+    psMetadata *camera;                 // Camera configuration
+    psMetadata *concepts;               // Values for concepts
+    psMetadata *phu;                    // Primary Header
     psArray *chips;                     // The chips
-    // FITS data
-    const char *extname;                // Extension name, if it corresponds to this level
-    psArray *pixels;                    // The pixel data, if it corresponds to this level
-    psMetadata *header;                 // The FITS header, if it corresponds to this level
+    p_pmHDU *private;                   // FITS data
 } pmFPA;
 
@@ -33 +36 @@
     psPlaneTransform* fromFPA;          // Transformation from FPA to chip coordinates
     // Information
-    psMetadata *values;                 // Important values (cached)
+    psMetadata *concepts;               // Values for concepts
     psArray *cells;                     // The cells (referred to by name)
     pmFPA *parent;                      // Parent FPA
-    // FITS data
-    const char *extname;                // Extension name, if it corresponds to this level
-    psArray *pixels;                    // The pixel data, if it corresponds to this level
-    psMetadata *header;                 // The FITS header, if it corresponds to this level
+    bool valid;                         // Valid for reading in?
+    p_pmHDU *private;                   // FITS data
 } pmChip;
 
@@ -53 +54 @@
     psPlaneTransform* toSky;            // Transformations from cell to tangent plane coordinates
     // Information
-    psMetadata *values;                 // Important values (cached)
+    psMetadata *concepts;               // Values for concepts
+    psMetadata *camera;                 // Camera information
     psArray *readouts;                  // The readouts (referred to by number)
     pmChip *parent;                     // Parent chip
-    // FITS data
-    const char *extname;                // Extension name, if it corresponds to this level
-    psArray *pixels;                    // The pixel data, if it corresponds to this level
-    psMetadata *header;                 // The FITS header, if it corresponds to this level
+    bool valid;                         // Valid for operating on?
+    p_pmHDU *private;                   // FITS data
 } pmCell;
 
@@ -73 +73 @@
     // Information
     psImage *image;                     // The pixels
-    psList *overscans;                  // Array of subimages containing the overscan region(s)
-    psMetadata *values;                 // readout-level metadata
+    psImage *mask;                      // Mask image
+    psList *overscans;                  // List of subimages containing the overscan regions
+    psMetadata *concepts;               // Concepts for readouts
 } pmReadout;
 
 // Allocators and deallocators
-pmFPA *pmFPAAlloc(const psMetadata *camera, // Camera configuration
-                  psDB *db              // Database
+p_pmHDU *p_pmHDUAlloc(const char *extname);
+void p_pmHDUFree(p_pmHDU *hdu);
+pmFPA *pmFPAAlloc(const psMetadata *camera // Camera configuration
     );
 void p_pmFPAFree(pmFPA *fpa);
@@ -89 +91 @@
 
 pmCell *pmCellAlloc(pmChip *chip,       // Chip to which the cell belongs
-                    psMetadata *values, // Initial values for concepts
+                    psMetadata *cameraData, // Camera data
                     psString name       // Name of cell
     );
@@ -95 +97 @@
 
 pmReadout *pmReadoutAlloc(pmCell *cell, // Cell to which the readout belongs
-                          int readoutNum, // Number of the readout
                           psImage *image, // The pixels
                           psList *overscans, // The overscan images
@@ -102 +103 @@
 void p_pmReadoutFree(pmReadout *readout);
 
+// Select and exclude chips
+bool pmFPASelectChip(pmFPA *fpa, int chipNum);
+int pmFPAExcludeChip(pmFPA *fpa, int chipNum);
+
 #endif

trunk/archive/scripts/src/phase2/pmFPAConstruct.c

@@ -30 +30 @@
         psError(PS_ERR_IO, false, "Unable to find specs for cell %s: ignored\n", cellName);
     }
+
+#if 0
+    // Need to create a new instance, so that each cell can work with its own
+    psMetadata *copy = psMetadataAlloc();
+    psMetadataIterator *iter = psMetadataIteratorAlloc(cellData, PS_LIST_HEAD, NULL); // Iterator
+    psMetadataItem *item = NULL;        // Item from iteration
+    while (item = psMetadataGetAndIncrement(iter)) {
+        if (item->type == PS_META_MULTI || item->type == PS_META_META) {
+            psLogMsg(__func__, PS_LOG_WARN, "PS_META_MULTI and PS_META_META are not supported in a cell "
+                     "definition --- %s ignored.\n", item->name);
+            continue;
+        }
+        if (! psMetadataAdd(copy, PS_LIST_TAIL, item->name, item->type, item->comment, item->data.V)) {
+            psAbort(__func__, "Should never reach here!\n");
+        }
+    }
+    psFree(iter);
+
+    return copy;
+#else
     return cellData;
+#endif
+
 }
 
@@ -38 +60 @@
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-pmFPA *pmFPAConstruct(const psMetadata *camera, // The camera configuration
-                      psDB *db          // Database handle
+pmFPA *pmFPAConstruct(const psMetadata *camera // The camera configuration
     )
 {
-    pmFPA *fpa = pmFPAAlloc(camera, db); // The FPA to fill out
+    pmFPA *fpa = pmFPAAlloc(camera); // The FPA to fill out
     bool mdStatus = true;               // Status from metadata lookups
     const char *phuType = psMetadataLookupString(&mdStatus, camera, "PHU"); // What is the PHU?
@@ -67 +88 @@
                 psString extName = contentItem->name; // The name of the extension
                 pmChip *chip = pmChipAlloc(fpa, extName); // The chip
-                chip->extname = extName;// Mark chip to receive FITS data
+                chip->private = p_pmHDUAlloc(extName); // Prepare chip to receive FITS data
                 if (contentItem->type != PS_META_STR) {
                     psLogMsg(__func__, PS_LOG_WARN, "Type of content item (%x) is not string: ignored\n",
@@ -83 +104 @@
                     psMetadata *cellData = getCellData(camera, cellName);
                     pmCell *cell = pmCellAlloc(chip, cellData, cellName); // The cell
+//                  psFree(cellData);
                 }
                 psFree(cellNamesIter);
@@ -102 +124 @@
                 const char *content = contentItem->data.V; // The content of the extension
                 psList *contents = papSplit(content, ": "); // Split the name from the type
-                if (contents->size != 2) {
+                if (contents->n != 2) {
                     psLogMsg(__func__, PS_LOG_WARN, "Unable to read contents of %s: ignored.\n", extName);
                 } else {
@@ -123 +145 @@
                     psMetadata *cellData = getCellData(camera, cellType);
                     pmCell *cell = pmCellAlloc(chip, cellData, extName); // The cell
-                    cell->extname = extName; // Mark cell to receive FITS data
+//                  psFree(cellData);
+                    cell->private = p_pmHDUAlloc(extName); // Prepare cell to receive FITS data
 
                     psFree(chip);
                     psFree(cell);
-                    psFree(chipName);
-                    psFree(cellType);
                 }
                 psFree(contents);
@@ -136 +157 @@
         } else if (strcasecmp(extType, "NONE") == 0) {
             // No extensions; Content contains metadata, each entry is a chip with its component cells
-            fpa->extname = "PHU";
+            fpa->private = p_pmHDUAlloc("PHU"); // Prepare FPA to receive FITS data
             while (contentItem = psMetadataGetAndIncrement(contentsIter)) {
                 psString chipName = contentItem->name; // The name of the chip
@@ -155 +176 @@
                     psMetadata *cellData = getCellData(camera, cellName);
                     pmCell *cell = pmCellAlloc(chip, cellData, cellName); // The cell
+//                  psFree(cellData);
                 }
                 psFree(cellNamesIter);
@@ -174 +196 @@
         if (strcasecmp(extType, "NONE") == 0) {
             // There are no extensions --- only the PHU
-            chip->extname = "PHU";
+            chip->private = p_pmHDUAlloc("PHU");
 
             const char *contents = psMetadataLookupString(&mdStatus, camera, "CONTENTS");
@@ -188 +210 @@
                 psMetadata *cellData = getCellData(camera, cellName);
                 pmCell *cell = pmCellAlloc(chip, cellData, cellName); // The cell
+//              psFree(cellData);
             }
             psFree(cellIter);
@@ -223 +246 @@
                 psMetadata *cellData = getCellData(camera, cellType);
                 pmCell *cell = pmCellAlloc(chip, cellData, extName); // The cell
-                cell->extname = extName; // Mark cell to receive FITS data
+//              psFree(cellData);
+                cell->private = p_pmHDUAlloc(extName); // Prepare cell to receive FITS data
             } // Iterating through contents
             psFree(contentsIter);
@@ -249 +273 @@
 {
     psTrace(__func__, 0, "FPA:\n");
-    if (fpa->extname) {
-        psTrace(__func__, 1, "---> FPA is extension %s.\n", fpa->extname);
-        if (! fpa->pixels) {
-            psTrace(__func__, 1, "---> NO PIXELS for extension %s\n", fpa->extname);
+    if (fpa->private) {
+        psTrace(__func__, 1, "---> FPA is extension %s.\n", fpa->private->extname);
+        if (! fpa->private->pixels) {
+            psTrace(__func__, 1, "---> NO PIXELS for extension %s\n", fpa->private->extname);
         }
     }
@@ -261 +285 @@
         psTrace(__func__, 1, "Chip: %d\n", i);
         pmChip *chip = chips->data[i]; // The chip
-        if (chip->extname) {
-            psTrace(__func__, 2, "---> Chip is extension %s.\n", chip->extname);
-            if (! chip->pixels) {
-                psTrace(__func__, 2, "---> NO PIXELS for extension %s\n", chip->extname);
+        if (chip->private) {
+            psTrace(__func__, 2, "---> Chip is extension %s.\n", chip->private->extname);
+            if (! chip->private->pixels) {
+                psTrace(__func__, 2, "---> NO PIXELS for extension %s\n", chip->private->extname);
             }
         }
@@ -272 +296 @@
             psTrace(__func__, 2, "Cell: %d\n", j);
             pmCell *cell = cells->data[j]; // The cell
-            if (cell->extname) {
-                psTrace(__func__, 3, "---> Cell is extension %s.\n", cell->extname);
-                if (! cell->pixels) {
-                    psTrace(__func__, 3, "---> NO PIXELS for extension %s\n", cell->extname);
-                }
-            }
-            psMetadataPrint(cell->values, 3);
+            if (cell->private) {
+                psTrace(__func__, 3, "---> Cell is extension %s.\n", cell->private->extname);
+                if (! cell->private->pixels) {
+                    psTrace(__func__, 3, "---> NO PIXELS for extension %s\n", cell->private->extname);
+                }
+            }
+            psMetadataPrint(cell->concepts, 3);
             psTrace(__func__, 3, "Readouts:\n");
             psArray *readouts = cell->readouts; // Array of readouts

trunk/archive/scripts/src/phase2/pmFPAConstruct.h

@@ -6 +6 @@
 
 // Read the contents of a FITS file (format specified by the camera configuration) into memory
-pmFPA *pmFPAConstruct(const psMetadata *camera, // The camera configuration
-                      psDB *db          // Database handle
+pmFPA *pmFPAConstruct(const psMetadata *camera // The camera configuration
     );
 

trunk/archive/scripts/src/phase2/psAdditionals.c

@@ -103 +103 @@
             break;
           default:
+            printf("\n");
             psError(PS_ERR_IO, false, "Non-printable metadata type: %x\n", item->type);
         }
@@ -262 +263 @@
                 // Go through the MULTI
                 psList *multi = argItem->data.V; // The list of MULTI psMetadataItems
-                if (*argc < i + multi->size) {
+                if (*argc < i + multi->n) {
                     psError(PS_ERR_IO, true, "Not enough arguments for %s.\n", argItem->name);
                     // Remove the arguments --- they will be ignored

trunk/archive/scripts/src/phase2/psAdditionals.h

@@ -3 +3 @@
 
 #include "pslib.h"
-
-typedef char* psString;
 
 // Get a value from the metadata that we believe should be metadata.