Changeset 21269

Timestamp:

Feb 2, 2009, 2:37:06 PM (17 years ago)

Author:

Paul Price

Message:

Reverting to writing covariance matrices per chip/cell. This allows simple visualisation of the covariance matrix, and a simpler system for reading and writing them.

Location:

branches/pap_branch_20090128/psModules/src/camera

Files:

• pmFPARead.c (modified) (6 diffs)
• pmFPARead.h (modified) (4 diffs)
• pmFPAWrite.c (modified) (8 diffs)
• pmHDU.c (modified) (3 diffs)
• pmHDU.h (modified) (3 diffs)
• pmHDUCovariances.c (deleted)
• pmHDUCovariances.h (deleted)
• pmHDUGenerate.c (modified) (9 diffs)

branches/pap_branch_20090128/psModules/src/camera/pmFPARead.c

@@ -9 +9 @@
 #include <pslib.h>
 
+#include "pmConfig.h"
+#include "pmConfigMask.h"
 #include "pmHDU.h"
 #include "pmFPA.h"
@@ -732 +734 @@
             return NULL;
         }
-
-        if (type == FPA_READ_TYPE_VARIANCE && hdu->covariances) {
-            psArray *covariances = hdu->covariances; // Covariances in HDU
-            for (int i = 0; i < covariances->n; i++) {
-                pmHDUCovariances *covar = covariances->data[i]; // Covariance information
-
         psFree(readout);                // Drop reference
     }
@@ -1143 +1139 @@
     PS_ASSERT_FITS_NON_NULL(fits, false);
 
-    return cellRead(cell, fits, config, FPA_READ_TYPE_VARIANCE);
+    if (!cellRead(cell, fits, config, FPA_READ_TYPE_VARIANCE)) {
+        return false;
+    }
+    return pmCellReadCovariance(cell, fits);
 }
 
@@ -1151 +1150 @@
     PS_ASSERT_FITS_NON_NULL(fits, false);
 
-    return chipRead(chip, fits, config, FPA_READ_TYPE_VARIANCE);
+    if (!chipRead(chip, fits, config, FPA_READ_TYPE_VARIANCE)) {
+        return false;
+    }
+    return pmChipReadCovariance(chip, fits);
 }
 
@@ -1159 +1161 @@
     PS_ASSERT_FITS_NON_NULL(fits, false);
 
-    return fpaRead(fpa, fits, config, FPA_READ_TYPE_VARIANCE);
+    if (!fpaRead(fpa, fits, config, FPA_READ_TYPE_VARIANCE)) {
+        return false;
+    }
+    return pmFPAReadCovariance(fpa, fits);
 }
 
@@ -1285 +1290 @@
     return numRead;
 }
+
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Reading covariance matrices
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+bool pmCellReadCovariance(pmCell *cell, psFits *fits)
+{
+    PS_ASSERT_PTR_NON_NULL(cell, false);
+    PS_ASSERT_FITS_NON_NULL(fits, false);
+
+    const char *chipName = psMetadataLookupStr(NULL, cell->parent->concepts, "CHIP.NAME"); // Name of chip
+    const char *cellName = psMetadataLookupStr(NULL, cell->concepts, "CELL.NAME"); // Name of cell
+    psString extname = NULL;            // Extension name
+    psStringAppend(&extname, "COVAR_%s_%s", chipName, cellName);
+
+    if (!psFitsMoveExtName(fits, extname)) {
+        psError(PS_ERR_IO, false, "Unable to move to extension %s\n", extname);
+        psFree(extname);
+        return false;
+    }
+    psFree(extname);
+
+    psMetadata *header = psFitsReadHeader(NULL, fits); // The FITS header
+    if (!header) {
+        psError(PS_ERR_IO, false, "Unable to read header for extension %s\n", extname);
+        psFree(header);
+        return false;
+    }
+
+    bool mdok;                          // Status of MD lookup
+    int x0 = psMetadataLookupS32(&mdok, header, "COVARIANCE.CENTRE.X"); // Centre of matrix in x
+    if (!mdok) {
+        psError(PS_ERR_BAD_PARAMETER_VALUE, true, "Unable to read covariance centre");
+        psFree(header);
+        return false;
+    }
+    int y0 = psMetadataLookupS32(&mdok, header, "COVARIANCE.CENTRE.Y"); // Centre of matrix in y
+    if (!mdok) {
+        psError(PS_ERR_BAD_PARAMETER_VALUE, true, "Unable to read covariance centre");
+        psFree(header);
+        return false;
+    }
+    psFree(header);
+
+    psArray *images = psFitsReadImageCube(fits, psRegionSet(0,0,0,0)); // Covariance matrices
+    if (!images) {
+        psError(PS_ERR_IO, false, "Unable to read covariance matrices for chip %s, cell %s",
+                chipName, cellName);
+        return false;
+    }
+
+    psArray *readouts = cell->readouts; // Readouts of cell
+    if (images->n != readouts->n) {
+        psError(PS_ERR_BAD_PARAMETER_SIZE, true,
+                "Number of covariance matrices (%ld) doesn't match number of readouts (%ld)",
+                images->n, readouts->n);
+        psFree(images);
+        return false;
+    }
+
+    for (int i = 0; i < readouts->n; i++) {
+        pmReadout *ro = readouts->data[i]; // Readout of interest
+        psImage *image = images->data[i]; // Image of interest
+        if (ro->covariance) {
+            psWarning("Clobbering extant covariance matrix in chip %s, cell %s, readout %d",
+                      chipName, cellName, i);
+            psFree(ro->covariance);
+        }
+        ro->covariance = psKernelAllocFromImage(image, x0, y0);
+    }
+    psFree(images);
+
+    return true;
+}
+
+
+bool pmChipReadCovariance(pmChip *chip, psFits *fits)
+{
+    PS_ASSERT_PTR_NON_NULL(chip, false);
+    PS_ASSERT_FITS_NON_NULL(fits, false);
+
+    psArray *cells = chip->cells;       // Array of cells
+    for (int i = 0; i < cells->n; i++) {
+        pmCell *cell = cells->data[i];  // Cell of interest
+        if (!pmCellReadCovariance(cell, fits)) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+
+bool pmFPAReadCovariance(pmFPA *fpa, psFits *fits)
+{
+    PS_ASSERT_PTR_NON_NULL(fpa, false);
+    PS_ASSERT_FITS_NON_NULL(fits, false);
+
+    psArray *chips = fpa->chips;        // Array of chips
+    for (int i = 0; i < chips->n; i++) {
+        pmChip *chip = chips->data[i];  // Chip of interest
+        if (!pmChipReadCovariance(chip, fits)) {
+            return false;
+        }
+    }
+
+    return true;
+}

branches/pap_branch_20090128/psModules/src/camera/pmFPARead.h

@@ -4 +4 @@
  * @author Paul Price, IfA
  *
- * @version $Revision: 1.15.44.1 $ $Name: not supported by cvs2svn $
- * @date $Date: 2009-01-29 00:33:51 $
+ * @version $Revision: 1.15.44.2 $ $Name: not supported by cvs2svn $
+ * @date $Date: 2009-02-03 00:37:06 $
  * Copyright 2005-2006 Institute for Astronomy, University of Hawaii
  */
@@ -226 +226 @@
 /// also read and included in the cell analysis metadata under "name.HEADER".
 int pmCellReadTable(pmCell *cell,       ///< Cell for which to read table
-                    psFits *fits,       ///< FITS file from which the table
+                    psFits *fits,       ///< FITS file from which to read the table
                     const char *name    ///< Specifies the extension name, and target in the analysis metadata
                    );
@@ -233 +233 @@
 ///
 /// Iterates over component cells, calling pmCellReadTable.
-int pmChipReadTable(pmChip *chip,       ///< Cell for which to read table
-                    psFits *fits,       ///< FITS file from which the table
+int pmChipReadTable(pmChip *chip,       ///< Chip for which to read table
+                    psFits *fits,       ///< FITS file from which to read the table
                     const char *name    ///< Specifies the extension name, and target in the analysis metadata
                    );
@@ -241 +241 @@
 ///
 /// Iterates over component chips, calling pmChipReadTable.
-int pmFPAReadTable(pmFPA *fpa,          ///< Cell for which to read table
-                   psFits *fits,        ///< FITS file from which the table
+int pmFPAReadTable(pmFPA *fpa,          ///< FPA for which to read table
+                   psFits *fits,        ///< FITS file from which to read the table
                    const char *name     ///< Specifies the extension name, and target in the analysis metadata
                   );
+
+/// Read covariance matrices for a cell
+bool pmCellReadCovariance(pmCell *cell, ///< Cell for which to read covariance matrices
+                          psFits *fits  ///< FITS file from which to read
+    );
+
+/// Read covariance matrices for a chip
+bool pmChipReadCovariance(pmChip *chip, ///< Chip for which to read covariance matrices
+                          psFits *fits  ///< FITS file from which to read
+    );
+
+/// Read covariance matrices for a cell
+bool pmFPAReadCovariance(pmFPA *fpa,    ///< FPA for which to read covariance matrices
+                         psFits *fits   ///< FITS file from which to read
+    );
+
+
+
 /// @}
 #endif

branches/pap_branch_20090128/psModules/src/camera/pmFPAWrite.c

@@ -9 +9 @@
 
 #include "pmConfig.h"
+#include "pmConfigMask.h"
 #include "pmHDU.h"
 #include "pmFPA.h"
@@ -74 +75 @@
 }
 
-
-
+// Indicate whether a covariance matrix is defined
+static bool readoutSearchCovariances(pmReadout *ro)
+{
+    return ro->covariance ? true : false;
+}
+
+// Search for a covariance matrix
+#define SEARCH_COVARIANCES(NAME, PARENT, CHILD, CHILDREN, TESTFUNC) \
+static bool NAME(PARENT *parent) \
+{ \
+    if (!parent || !parent->CHILDREN) { \
+        return false; \
+    } \
+    psArray *children = parent->CHILDREN; /* Array of children */ \
+    for (int i = 0; i < children->n; i++) { \
+        CHILD *child = children->data[i]; /* Child of interest */ \
+        if (child && TESTFUNC(child)) { \
+            return true; \
+        } \
+    } \
+    return false; \
+}
+
+SEARCH_COVARIANCES(cellSearchCovariances, pmCell, pmReadout, readouts, readoutSearchCovariances);
+SEARCH_COVARIANCES(chipSearchCovariances, pmChip, pmCell,    cells,    cellSearchCovariances);
+SEARCH_COVARIANCES(fpaSearchCovariances,  pmFPA,  pmChip,    chips,    chipSearchCovariances);
 
 // Some type-specific additions to the header
@@ -81 +106 @@
                               pmChip *chip, // Chip of interest, or NULL
                               pmCell *cell, // Cell of interest, or NULL
-                              fpaWriteType type // Type to write
-    )
+                              fpaWriteType type, // Type to write
+                              pmConfig *config // Configuration
+                              )
 {
     switch (type) {
@@ -94 +120 @@
       }
       case FPA_WRITE_TYPE_VARIANCE: {
+          bool covar = false;           // Are covariances present?
+          if ((cell && cellSearchCovariances(cell)) ||
+              (!cell && ((chip && chipSearchCovariances(chip)) ||
+                         (!chip && fpa && fpaSearchCovariances)))) {
+              covar = true;
+          }
+
           pmHDU *hdu = pmHDUGetLowest(fpa, chip, cell); // Header being written
-
+          psMetadataAddBool(hdu->header, PS_LIST_TAIL, PM_HDU_COVARIANCE_KEYWORD, PS_META_REPLACE,
+                            "Is a covariance matrix present?", covar);
+          break;
+      }
+      default:
+        break;
+    }
+
+    return true;
+}
 
 
@@ -137 +179 @@
             return false;
         }
-
-
+        if (!writeUpdateHeader(NULL, NULL, cell, type, config)) {
+            psError(PS_ERR_UNKNOWN, false, "Unable to update header for writing");
+            return false;
+        }
         if (!appropriateWriteFunc(hdu, fits, config, type)) {
             psError(PS_ERR_IO, false, "Unable to write HDU for cell.\n");
@@ -189 +233 @@
                 return false;
             }
+
+            if (!writeUpdateHeader(NULL, chip, NULL, type, config)) {
+                psError(PS_ERR_UNKNOWN, false, "Unable to update header for writing");
+                return false;
+            }
+
             if (!appropriateWriteFunc(hdu, fits, config, type)) {
                 psError(PS_ERR_IO, false, "Unable to write HDU for chip.\n");
@@ -253 +303 @@
                 return false;
             }
+            if (!writeUpdateHeader(fpa, NULL, NULL, type, config)) {
+                psError(PS_ERR_UNKNOWN, false, "Unable to update header for writing");
+                return false;
+            }
             if (!appropriateWriteFunc(hdu, fits, config, type))  {
                 psError(PS_ERR_IO, false, "Unable to write HDU for FPA.\n");
@@ -535 +589 @@
     return numWrite;
 }
+
+bool pmCellWriteCovariance(psFits *fits, const pmCell *cell)
+{
+    PS_ASSERT_PTR_NON_NULL(cell, false);
+    PS_ASSERT_PTR_NON_NULL(fits, false);
+
+    int numCovar = 0;
+    psArray *readouts = cell->readouts; // Array of readouts
+    for (int i = 0; i < readouts->n; i++) {
+        pmReadout *readout = readouts->data[i]; // The readout of interest
+        if (readout && readout->covariance) {
+            numCovar++;
+        }
+    }
+    if (numCovar == 0) {
+        return true;
+    }
+    if (numCovar != readouts->n) {
+        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
+                "Number of covariances (%d) doesn't match number of readouts (%ld)",
+                numCovar, readouts->n);
+        return false;
+    }
+
+    // Check size of covariances
+    int xMinCovar = INT_MAX, xMaxCovar = INT_MIN, yMinCovar = INT_MAX, yMaxCovar = INT_MIN; // Size
+    for (int i = 0; i < readouts->n; i++) {
+        pmReadout *readout = readouts->data[i]; // The readout of interest
+        psAssert(readout, "Should be defined.");
+        psKernel *covar = readout->covariance; // Covariance matrix
+        psAssert(covar, "Should be defined.");
+        xMinCovar = PS_MIN(xMinCovar, covar->xMin);
+        xMaxCovar = PS_MAX(xMaxCovar, covar->xMax);
+        yMinCovar = PS_MIN(yMinCovar, covar->yMin);
+        yMaxCovar = PS_MAX(yMaxCovar, covar->yMax);
+    }
+
+    // Correct covariances to common size
+    psArray *images = psArrayAlloc(numCovar); // Array of images
+    for (int i = 0; i < readouts->n; i++) {
+        pmReadout *readout = readouts->data[i]; // The readout of interest
+        psAssert(readout, "Should be defined.");
+        psKernel *covar = readout->covariance; // Covariance matrix
+        psAssert(covar, "Should be defined.");
+        int xMin = covar->xMin, xMax = covar->xMax, yMin = covar->yMin, yMax = covar->yMax;// Size
+        if (xMin == xMinCovar && xMax == xMaxCovar && yMin == yMinCovar && yMax == yMaxCovar) {
+            images->data[i] = psMemIncrRefCounter(covar->image);
+        } else {
+            psImage *new = psImageAlloc(xMaxCovar - xMinCovar + 1, yMaxCovar - yMinCovar + 1, PS_TYPE_F32);
+            psImageInit(new, 0);
+            psImageOverlaySection(new, covar->image, xMinCovar - xMin, yMinCovar - yMin, "=");
+            images->data[i] = new;
+        }
+    }
+
+    // Determine extension name
+    const char *chipName = psMetadataLookupStr(NULL, cell->parent->concepts, "CHIP.NAME"); // Name of chip
+    const char *cellName = psMetadataLookupStr(NULL, cell->concepts, "CELL.NAME"); // Name of cell
+    psString extname = NULL;            // Extension name
+    psStringAppend(&extname, "COVAR_%s_%s", chipName, cellName);
+
+    // Generate header
+    pmHDU *hdu = pmHDUFromCell(cell);   // HDU for cell
+    psMetadata *header = psMetadataCopy(NULL, hdu->header); // Header to write
+    psMetadataAddS32(header, PS_LIST_TAIL, "COVARIANCE.CENTRE.X", PS_META_REPLACE,
+                     "Centre of covariance matrix in x", -xMinCovar);
+    psMetadataAddS32(header, PS_LIST_TAIL, "COVARIANCE.CENTRE.Y", PS_META_REPLACE,
+                     "Centre of covariance matrix in y", -yMinCovar);
+
+    // Write images
+    if (!psFitsWriteImageCube(fits, header, images, extname)) {
+        psError(PS_ERR_UNKNOWN, false, "Unable to write covariances from chip %s, cell %s to extension %s",
+                chipName, cellName, extname);
+        psFree(extname);
+        psFree(header);
+        psFree(images);
+        return 0;
+    }
+    psFree(extname);
+    psFree(header);
+    psFree(images);
+
+    return true;
+}
+
+
+bool pmChipWriteCovariance(psFits *fits, const pmChip *chip)
+{
+    PS_ASSERT_PTR_NON_NULL(chip, false);
+    PS_ASSERT_PTR_NON_NULL(fits, false);
+
+    psArray *cells = chip->cells;       // Array of cells
+    for (int i = 0; i < cells->n; i++) {
+        pmCell *cell = cells->data[i];  // Cell of interest
+        if (!pmCellWriteCovariance(fits, cell)) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+
+bool pmFPAWriteCovariance(psFits *fits, const pmFPA *fpa)
+{
+    PS_ASSERT_PTR_NON_NULL(fpa, false);
+    PS_ASSERT_PTR_NON_NULL(fits, false);
+
+    psArray *chips = fpa->chips;        // Array of chips
+    for (int i = 0; i < chips->n; i++) {
+        pmChip *chip = chips->data[i];  // Chip of interest
+        if (!pmChipWriteCovariance(fits, chip)) {
+            return false;
+        }
+    }
+
+    return true;
+}

branches/pap_branch_20090128/psModules/src/camera/pmHDU.c

@@ -12 +12 @@
 #include "pmHDU.h"
 #include "pmFPA.h"
-
-#define COVARIANCE_INDICATOR "PS_COVAR" // FITS keyword to indicate if covariance matrices are present
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -162 +160 @@
     PS_ASSERT_PTR_NON_NULL(fits, false);
 
-    if (!hduRead(hdu, &hdu->variances, fits)) {
-        return false;
-    }
-
-    return true;
+    return hduRead(hdu, &hdu->variances, fits);
 }
 
@@ -246 +240 @@
     PS_ASSERT_PTR_NON_NULL(fits, false);
 
-    pmHDUCovariancesWriteHeader(hdu);
-
     psImageMaskType maskVal = pmConfigMaskGet("MASK.VALUE", config); // Value to mask
-    if (!hduWrite(hdu, hdu->variances, hdu->masks, maskVal, fits)) {
-        return false;
-    }
-    pmHDUCovarianceClearHeader(hdu);
-
-    if (!pmHDUCovarianceWrite(hdu, fits)) {
-        psError(PS_ERR_UNKNOWN, false, "Unable to write covariance");
-        return false;
-    }
-
-    return true;
-}
+    return hduWrite(hdu, hdu->variances, hdu->masks, maskVal, fits);
+}

branches/pap_branch_20090128/psModules/src/camera/pmHDU.h

@@ -4 +4 @@
  * @author Paul Price, IfA
  *
- * @version $Revision: 1.9.22.2 $ $Name: not supported by cvs2svn $
- * @date $Date: 2009-02-02 18:05:38 $
+ * @version $Revision: 1.9.22.3 $ $Name: not supported by cvs2svn $
+ * @date $Date: 2009-02-03 00:37:06 $
  * Copyright 2005-2006 Institute for Astronomy, University of Hawaii
  */
@@ -17 +17 @@
 /// @addtogroup Camera Camera Layout
 /// @{
+
+#define PM_HDU_COVARIANCE_KEYWORD "PS_COVAR" // FITS keyword to indicate presence of a covariance matrix
 
 /// An instance of the FITS Header Data Unit
@@ -30 +32 @@
     psArray *variances;                 ///< Variance in the pixel data, or NULL
     psArray *masks;                     ///< Mask for the pixel data, or NULL
-    psArray *covariances;               ///< Covariance matrices (pmHDUCovariance), or NULL
 } pmHDU;
 

branches/pap_branch_20090128/psModules/src/camera/pmHDUGenerate.c

@@ -356 +356 @@
     psElemType maskType = 0;            // Type of readout masks
     psElemType varianceType = 0;        // Type of readout variances
-    psElemType covarianceType = 0;      // Type of readout covariances
     {
         psListIterator *iter = psListIteratorAlloc(cells, PS_LIST_HEAD, false); // Iterator for cells
@@ -385 +384 @@
                     varianceType = checkTypes(varianceType, readout->variance->type.type);
                 }
-                if (!hdu->covariances && readout->covariance) {
-                    covarianceType = checkTypes(covarianceType, PS_TYPE_F32);
-                }
             }
         }
         psFree(iter);
     }
-    if (numReadouts == 0 || (imageType == 0 && maskType == 0 && varianceType == 0 && covarianceType == 0)) {
+    if (numReadouts == 0 || (imageType == 0 && maskType == 0 && varianceType == 0)) {
         // Nothing from which to create an HDU
         psFree(cells);
@@ -432 +428 @@
             hdu->variances->data[i] = variance;
         }
-    }
-    if (covarianceType) {
-        hdu->covariances = psHashAlloc(psListLength(cells));
     }
 
@@ -456 +449 @@
             psArray *readouts = cell->readouts; // Array of readouts
 
-            // Check size of covariances
-            int xMinCovar = INT_MAX, xMaxCovar = INT_MIN, yMinCovar = INT_MAX, yMaxCovar = INT_MIN; // Size
-            if (covarianceType) {
-                for (int i = 0; i < readouts->n; i++) {
-                    pmReadout *readout = readouts->data[i]; // The readout of interest
-                    if (!readout) {
-                        continue;
-                    }
-                    psKernel *covar = readout->covariance; // Covariance matrix
-                    xMinCovar = PS_MIN(xMinCovar, covar->xMin);
-                    xMaxCovar = PS_MAX(xMaxCovar, covar->xMax);
-                    yMinCovar = PS_MIN(yMinCovar, covar->yMin);
-                    yMaxCovar = PS_MAX(yMaxCovar, covar->yMax);
-                }
-            }
-
             psArray *hduImages = hdu->images; // Array of images in the HDU
             psArray *hduMasks = hdu->masks; // Array of masks in the HDU
             psArray *hduVariances = hdu->variances; // Array of variances in the HDU
-            psArray *covariances = (covarianceType ? psArrayAlloc(readouts->n) : NULL; // Covariance images
             for (int i = 0; i < readouts->n; i++) {
                 pmReadout *readout = readouts->data[i]; // The readout of interest
@@ -496 +472 @@
                     psFree(readout->variance);
                     readout->variance = new;
-                }
-                if (readout->covariance) {
-                    psKernel *covar = readout->covariance; // Covariance matrix
-                    int xMin = covar->xMin, xMax = covar->xMax, yMin = covar->yMin, yMax = covar->yMax;// Size
-                    if (xMin == xMinCovar && xMax == xMaxCovar && yMin == yMinCovar && yMax == yMaxCovar) {
-                        variances->data[i] = psMemIncrRefCounter(readout->covariance);
-                    } else {
-                        psKernel *new = psKernelAlloc(xMinCovar, xMaxCovar, yMinCovar, yMaxCovar);// New covar
-                        psImageInit(covar->image, 0);
-                        psImageOverlaySection(new->image, covar->image,
-                                              xMinCovar - xMin, yMinCovar - yMin, "=");
-                        variances->data[i] = new;
-                    }
                 }
 
@@ -533 +496 @@
             }
             psFree(biassecsIter);
-
-            if (covariances) {
-                const char *cellName = psMetadataLookupStr(NULL, cell->concepts, "CELL.NAME"); // Name of cell
-                pmChip *chip = cell->parent; // Parent chip
-                const char *chipName = psMetadataLookupStr(NULL, chip->concepts, "CHIP.NAME"); // Name of chip
-                if (!cellName || !chipName) {
-                    psError(PS_ERR_UNKNOWN, false, "Unable to find cell or chip name.");
-                    return false;
-                }
-                psString name = NULL; // Name for covariance extension
-                psStringAppend(&name, "COVAR_%s_%s", chipName, cellName);
-                if (psHashLookup(hdu->covariances, name)) {
-                    psHashRemove(hash, name);
-                }
-                psHashAdd(hdu->covariances, name, covariance);
-                psFree(name);
-            }
         } // Iterating over cells within the HDU
         psFree(iter);
@@ -636 +582 @@
         return false;
     }
-    if (hdu->images && hdu->masks && hdu->variances && hdu->covariances) {
+    if (hdu->images && hdu->masks && hdu->variances) {
         // It's already here!
         return true;
@@ -686 +632 @@
         return generateForCells(chip);
     }
-    if (hdu->images && hdu->masks && hdu->variances && hdu->covariances) {
+    if (hdu->images && hdu->masks && hdu->variances) {
         // It's already here!
         return true;
@@ -735 +681 @@
         return generateForChips(fpa);
     }
-    if (hdu->images && hdu->masks && hdu->variances && hdu->covariances) {
+    if (hdu->images && hdu->masks && hdu->variances) {
         // It's already here!
         return true;