Index: trunk/ppImage/src/Makefile.am
===================================================================
--- trunk/ppImage/src/Makefile.am	(revision 6064)
+++ trunk/ppImage/src/Makefile.am	(revision 6079)
@@ -12,5 +12,4 @@
 	ppImage.c \
 	ppImageConfig.c \
-	ppImageLoadPixels.c \
 	ppImageLoop.c \
 	ppImageOptions.c \
@@ -20,4 +19,5 @@
 	ppImageOutput.c \
 	ppImagePhot.c
+#	ppImageLoadPixels.c
 #	ppDetrendFlat.c
 #	ppImageOutput.c
Index: trunk/ppImage/src/ppImageDetrendCell.c
===================================================================
--- trunk/ppImage/src/ppImageDetrendCell.c	(revision 6064)
+++ trunk/ppImage/src/ppImageDetrendCell.c	(revision 6079)
@@ -3,5 +3,4 @@
 
 // mask, bias, dark, flat are defined per Cell
-// pedestal is constructed for each readout, which may have different exposure times
 
 pmReadout *ppDetrendSelectFirst(pmCell *cell, char *name, bool doThis)
@@ -23,5 +22,4 @@
 bool ppDetrendCell(ppDetrend *detrend, ppOptions *options, ppConfig *config)
 {
-
     pmCellSetWeights(detrend->input);
 
@@ -30,4 +28,9 @@
     pmReadout *dark = ppDetrendSelectFirst(detrend->dark, "dark", options->doDark);
     pmReadout *flat = ppDetrendSelectFirst(detrend->flat, "flat", options->doFlat);
+
+#if 0
+    printf("Flat type: %x\n", flat->image->type.type);
+    printf("Flat value: %f\n", flat->image->data.F32[flat->image->numRows/2][flat->image->numCols/2]);
+#endif
 
     // Dark time for dark image
Index: trunk/ppImage/src/ppImageLoadPixels.c
===================================================================
--- trunk/ppImage/src/ppImageLoadPixels.c	(revision 6064)
+++ trunk/ppImage/src/ppImageLoadPixels.c	(revision 6079)
@@ -14,4 +14,16 @@
 
     psTrace(__func__, 1, "Loading %d,%d for %s\n", chipNum, cellNum, input->filename);
+
+    pmFPA *fpa = input->fpa;            // The entire focal plane array
+    psArray *chips = fpa->chips;        // The array of chips
+    if (chipNum >= 0 && chipNum < chips->n) {
+        loadCells(chips->data[chipNum]);
+        if (! chip->exists && chip->process) {
+            loadCells(chip, cellNum);
+        }
+    } else {
+        for (int i = 0; i < chips->n; i++) {
+            pmChip *chip = chips->data[i];
+        }
 
     // set input:valid flags according to process and chipNum/cellNum
Index: trunk/ppImage/src/ppImageLoop.c
===================================================================
--- trunk/ppImage/src/ppImageLoop.c	(revision 6064)
+++ trunk/ppImage/src/ppImageLoop.c	(revision 6079)
@@ -1,3 +1,35 @@
 # include "ppImage.h"
+
+// Read the entire FPA
+void readFPA(ppFile *file,              // File to read
+             ppConfig *config           // Configuration, containing the DB handle
+    )
+{
+    if (file->fpa && file->fits) {
+        if (! pmFPARead(file->fpa, file->fits, file->phu, config->database)) {
+            psErrorStackPrint(stderr, "Unable to populate camera from input FITS file\n");
+            exit(EXIT_FAILURE);
+        }
+    }
+}
+
+// Read a specified chip only
+void readChip(ppFile *file,             // File to read
+              ppConfig *config,         // Configuration
+              int chipNum               // Chip number to read
+    )
+{
+    pmFPASelectChip(file->fpa, chipNum);
+    readFPA(file, config);
+}
+
+
+void readCell(ppFile *file, ppConfig *config, int chipNum, int cellNum)
+{
+    pmChip *chip = file->fpa->chips->data[chipNum];
+    pmChipSelectCell(chip, cellNum);
+    readFPA(file, config);
+}
+
 
 bool ppImageLoop(ppData *data, ppOptions *options, ppConfig *config)
@@ -5,33 +37,38 @@
     ppDetrend detrend;
 
-    if (options->imageLoadDepth == PP_LOAD_FPA) {
+    int processChip = psMetadataLookupS32(NULL, config->arguments, "-chip"); // Chip number to process or -1
+
+    // Load at FPA level if requested
+    if (processChip < 0 && options->imageLoadDepth == PP_LOAD_FPA) {
         psTrace(__func__, 1, "Loading pixels for FPA...\n");
-        ppImageLoadPixels(data->input, config->database, -1, -1);
-        ppImageLoadPixels(data->bias,  config->database, -1, -1);
-        ppImageLoadPixels(data->dark,  config->database, -1, -1);
-        ppImageLoadPixels(data->mask,  config->database, -1, -1);
-        ppImageLoadPixels(data->flat,  config->database, -1, -1);
+        readFPA(data->input, config);
+        readFPA(data->bias,  config);
+        readFPA(data->dark,  config);
+        readFPA(data->mask,  config);
+        readFPA(data->flat,  config);
     }
 
-    for (int i = 0; i < data->input->fpa->chips->n; i++) {
-        pmChip *inputChip = data->input->fpa->chips->data[i]; // Chip of interest in input image
-        pmChip *biasChip  = data->bias->fpa->chips->data[i];  // Chip of interest in bias image
-        pmChip *darkChip  = data->dark->fpa->chips->data[i];  // Chip of interest in dark image
-        pmChip *maskChip  = data->mask->fpa->chips->data[i];  // Chip of interest in mask image
-        pmChip *flatChip  = data->flat->fpa->chips->data[i];  // Chip of interest in flat image
-
-        printf("Chip %d: %x %x\n", i, inputChip->exists, inputChip->process);
-        if (! inputChip->process) { continue; }
-
+    psArray *chips = data->input->fpa->chips; // Component chips
+    for (int i = 0; i < chips->n; i++) {
+        if (processChip >= 0 && i != processChip) {
+            continue;
+        }
         if (options->imageLoadDepth == PP_LOAD_CHIP) {
             psTrace(__func__, 1, "Loading pixels for chip %d...\n", i);
-            ppImageLoadPixels(data->input, config->database, i, -1);
-            ppImageLoadPixels(data->bias,  config->database, i, -1);
-            ppImageLoadPixels(data->dark,  config->database, i, -1);
-            ppImageLoadPixels(data->mask,  config->database, i, -1);
-            ppImageLoadPixels(data->flat,  config->database, i, -1);
+            readChip(data->input, config, i);
+            readChip(data->bias,  config, i);
+            readChip(data->dark,  config, i);
+            readChip(data->mask,  config, i);
+            readChip(data->flat,  config, i);
         }
 
-        for (int j = 0; j < inputChip->cells->n; j++) {
+        pmChip *inputChip = chips->data[i];
+        pmChip *biasChip  = data->bias->fpa->chips->data[i];
+        pmChip *darkChip  = data->dark->fpa->chips->data[i];
+        pmChip *maskChip  = data->mask->fpa->chips->data[i];
+        pmChip *flatChip  = data->flat->fpa->chips->data[i];
+
+        psArray *cells = inputChip->cells;
+        for (int j = 0; j < cells->n; j++) {
             detrend.input = inputChip->cells->data[j]; // Cell of interest in input image
             detrend.bias  = biasChip->cells->data[j];  // Cell of interest in bias image
@@ -40,17 +77,16 @@
             detrend.flat  = flatChip->cells->data[j];  // Cell of interest in flat image
 
-            printf ("\tCell %d: %x %x\n", j, detrend.input->exists, detrend.input->process);
             if (! detrend.input->process) { continue; }
 
             if (options->imageLoadDepth == PP_LOAD_CELL) {
                 psTrace(__func__, 1, "Loading pixels for chip %d, cell %d...\n", i, j);
-                ppImageLoadPixels(data->input, config->database, i, j);
-                ppImageLoadPixels(data->bias,  config->database, i, j);
-                ppImageLoadPixels(data->dark,  config->database, i, j);
-                ppImageLoadPixels(data->mask,  config->database, i, j);
-                ppImageLoadPixels(data->flat,  config->database, i, j);
+                readCell(data->input, config, i, j);
+                readCell(data->bias,  config, i, j);
+                readCell(data->dark,  config, i, j);
+                readCell(data->mask,  config, i, j);
+                readCell(data->flat,  config, i, j);
             }
 
-            ppDetrendCell (&detrend, options, config);
+            ppDetrendCell(&detrend, options, config);
         }
     }