Changeset 6552 for branches/rel10_ifa/psModules/src/astrom/pmFPAConstruct.c

Timestamp:

Mar 8, 2006, 5:08:08 PM (20 years ago)

Author:

Paul Price

Message:

Broad changes to introduce pmHDU, and allow read/write at any level. Modified the camera configuration to use camera config (components of the camera) and format descriptions (FITS file layout).

File:

• branches/rel10_ifa/psModules/src/astrom/pmFPAConstruct.c (modified) (7 diffs)

branches/rel10_ifa/psModules/src/astrom/pmFPAConstruct.c

@@ -11 +11 @@
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-// Read data for a particular cell from the camera configuration
-static psMetadata *getCellData(const psMetadata *camera, // The camera configuration
+// Read data for a particular cell from the camera format description
+static psMetadata *getCellData(const psMetadata *format, // The camera format description
                                const char *cellName // The name of the cell
                               )
 {
     bool status = true;                 // Result of MD lookup
-    psMetadata *cells = psMetadataLookupMD(&status, camera, "CELLS"); // The CELLS
+    psMetadata *cells = psMetadataLookupMD(&status, format, "CELLS"); // The CELLS
     if (! status) {
         psError(PS_ERR_IO, false, "Unable to determine CELLS of camera.\n");
@@ -28 +28 @@
     }
 
-    #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_DATA_METADATA_MULTI || item->type == PS_DATA_METADATA) {
-            psLogMsg(__func__, PS_LOG_WARN, "PS_DATA_METADATA_MULTI and PS_DATA_METADATA are not supported "
-                     "in a cell definition --- %s ignored.\n", item->name);
+    return cellData;
+}
+
+// Find a chip by name
+static pmChip *findChip(pmFPA *fpa, // FPA in which to find the chip
+                        const char *name // Name of the chip
+                       )
+{
+    psArray *chips = fpa->chips;    // Array of chips
+    for (int i = 0; i < chips->n; i++) {
+        pmChip *chip = chips->data[i]; // The chip of interest
+        psString testName = psMetadataLookupStr(NULL, chip->concepts, "CHIP.NAME"); // Name of this chip
+        if (strcmp(name, testName) == 0) {
+            return chip;
+        }
+    }
+
+    psError(PS_ERR_IO, true, "Unable to find chip %s\n", name);
+    return NULL;
+}
+
+// Find a cell by name
+static pmCell *findCell(pmChip *chip, // Chip in which to find the cell
+                        const char *name // Name of the cell
+                       )
+{
+    psArray *cells = chip->cells;    // Array of cells
+    for (int i = 0; i < cells->n; i++) {
+        pmCell *cell = cells->data[i]; // The cell of interest
+        psString testName = psMetadataLookupStr(NULL, cell->concepts, "CELL.NAME"); // Name of this cell
+        if (strcmp(name, testName) == 0) {
+            return cell;
+        }
+    }
+
+    psError(PS_ERR_IO, true, "Unable to find cell %s\n", name);
+    return NULL;
+}
+
+// Parse a list of first:second pairs in a string
+static bool parsePairs(psArray **first, // Array of the first values
+                       psArray **second, // Array of the second values
+                       const char *string // The string to parse
+                      )
+{
+    bool allOK = true;                  // Everything was OK?
+    psList *pairs = psStringSplit(string, " ,;"); // List of the pairs
+    *first = psArrayAlloc(pairs->n);
+    *second = psArrayAlloc(pairs->n);
+    int num = 0;
+    psListIterator *pairsIter = psListIteratorAlloc(pairs, PS_LIST_HEAD, false); // Iterator for pairs
+    psString pair = NULL;               // "first:second" pair string
+    while ((pair = psListGetAndIncrement(pairsIter))) {
+        psList *firstSecond = psStringSplit(pair, ":"); // List containing the first and second
+        if (firstSecond->n != 2) {
+            psLogMsg(__func__, PS_LOG_WARN, "Badly formated first:second pair: %s --- ignored.\n", pair);
+            allOK = false;
             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
-
-}
-
+        psString firstBit = psListGet(firstSecond, PS_LIST_HEAD); // The first bit
+        psString secondBit = psListGet(firstSecond, PS_LIST_TAIL); // The second bit
+        psArraySet(*first, num, firstBit);
+        psArraySet(*second, num, secondBit);
+        num++;
+        psFree(firstSecond);
+    }
+    psFree(pairsIter);
+    psFree(pairs);
+
+    return allOK;
+}
+
+// Get the chip name from a primary header lookup
+static psString chipNameFromHeader(const psMetadata *format, // FORMAT within the camera format description
+                                   const psMetadata *header // Primary header
+                                  )
+{
+    bool mdok = true;                   // Result of MD lookup
+    psString chipNameHeader = psMetadataLookupStr(&mdok, format, "CHIP.NAME");
+    if (!mdok || strlen(chipNameHeader) == 0) {
+        psError(PS_ERR_IO, false, "Unable to find CHIP.NAME in the FORMAT.\n");
+        return false;
+    }
+    psString chipName = psMetadataLookupStr(&mdok, header, chipNameHeader);
+    if (!chipName || strlen(chipName) == 0) {
+        psError(PS_ERR_IO, false, "Unable to find %s in primary header to identify chip name.\n", chipName);
+        return NULL;
+    }
+
+    return chipName;
+}
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -58 +124 @@
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
+// Construct an FPA instance on the basis of a camera configuration
+pmFPA *pmFPAConstruct(const psMetadata *camera // The camera configuration
+                     )
+{
+    pmFPA *fpa = pmFPAAlloc(camera);    // The FPA to fill out
+
+    bool mdok = true;                   // Status from MD lookups
+    psMetadata *components = psMetadataLookupMD(&mdok, camera, "FPA"); // FPA components
+    psMetadataIterator *componentsIter = psMetadataIteratorAlloc(components, PS_LIST_HEAD, NULL);
+    psMetadataItem *componentsItem = NULL; // Item from components
+    while ((componentsItem = psMetadataGetAndIncrement(componentsIter))) {
+        const char *chipName = componentsItem->name; // Name of the chip
+        if (componentsItem->type != PS_DATA_STRING) {
+            psLogMsg(__func__, PS_LOG_WARN, "Element %s in FPA within the camera configuration is not of "
+                     "type STR (type=%x) --- ignored.\n", chipName, componentsItem->type);
+            continue;
+        }
+        pmChip *chip = pmChipAlloc(fpa, chipName); // The chip
+        psList *cellNames = psStringSplit(componentsItem->data.V, " ,;"); // List of cell names
+        psListIterator *cellNamesIter = psListIteratorAlloc(cellNames, PS_LIST_HEAD, false); // Iterator
+        psString cellName = NULL;       // Name of cell
+        while ((cellName = psListGetAndIncrement(cellNamesIter))) {
+            pmCell *cell = pmCellAlloc(chip, cellName); // New cell
+            psFree(cell);               // Drop reference
+        }
+        psFree(chip);                   // Drop reference
+        psFree(cellNamesIter);
+    }
+    psFree(componentsIter);
+
+    return fpa;
+}
+
+
+// Add an input file to the FPA
+bool pmFPAAddSource(pmFPA *fpa,         // FPA to which to add
+                    pmChip *chip,       // Chip to which to add, or NULL
+                    pmCell *cell,       // Cell to which to add, or NULL
+                    psMetadata *phu,    // Primary header of file
+                    const psMetadata *format // Format of file
+                   )
+{
+    // Just in case someone's playing silly billy...
+    if (cell && !chip) {
+        chip = cell->parent;
+    }
+    if (chip && !fpa) {
+        fpa = chip->parent;
+    }
+
+    bool mdok = true;                   // Status from metadata lookups
+    psMetadata *formatSpec = psMetadataLookupMD(&mdok, format, "FORMAT"); // The format specification
+    if (!mdok || !formatSpec) {
+        psError(PS_ERR_IO, false, "Unable to find FORMAT in the camera format configuration.\n");
+        return false;
+    }
+
+    // Where does the PHU go?
+    const char *phuType = psMetadataLookupStr(&mdok, formatSpec, "PHU"); // What is the PHU?
+    if (!mdok || strlen(phuType) == 0) {
+        psError(PS_ERR_IO, false, "Unable to find PHU in the format specification.\n");
+        return false;
+    }
+    pmHDU *phdu = pmHDUAlloc("PHU");    // The primary header data unit
+    phdu->header = psMemIncrRefCounter(phu);
+    if (fpa && !fpa->hdu && strcasecmp(phuType, "FPA") == 0) {
+        fpa->hdu = phdu;
+    } else if (chip && !chip->hdu && strcasecmp(phuType, "CHIP") == 0) {
+        chip->hdu = phdu;
+    } else if (cell && !cell->hdu && strcasecmp(phuType, "CELL") == 0) {
+        // cell->hdu = phdu;
+        psError(PS_ERR_IO, true, "The case of PHU == CELL has not been written yet!\n");
+        return false;
+    }
+
+    // And the individual extensions?
+    const char *extType = psMetadataLookupStr(&mdok, formatSpec, "EXTENSIONS"); // What's in the extns?
+    if (!mdok || strlen(extType) == 0) {
+        psError(PS_ERR_IO, false, "Unable to find EXTENSIONS in the format specification.\n");
+        return false;
+    }
+    psMetadata *contents = psMetadataLookupMD(&mdok, format, "CONTENTS"); // The contents of the FITS file
+    if (!mdok || !contents) {
+        psError(PS_ERR_IO, false, "Unable to find CONTENTS in the camera format configuration.\n");
+        return false;
+    }
+
+    if (strcasecmp(extType, "NONE") == 0) {
+        // No extensions --- it's all in the PHU
+        psString chipType = chipNameFromHeader(formatSpec, phu); // Type of chip
+        psString content = psMetadataLookupStr(&mdok, contents, chipType); // The content line
+
+        // Parse the list of first:second
+        psArray *names = NULL;          // The first bits
+        psArray *values = NULL;         // The second bits
+        parsePairs(&names, &values, content);
+        for (int i = 0; i < names->n; i++) {
+            psString chipName = names->data[i]; // The name of the chip
+            psString cellName = values->data[i]; // The name of the cell
+            pmChip *chip = findChip(fpa, chipName); // The chip we're looking for
+            pmCell *cell = findCell(chip, cellName); // The cell we're looking for
+            psMetadata *cellData = getCellData(format, cellName); // Data for this cell
+            if (! cellData) {
+                psLogMsg(__func__, PS_LOG_WARN, "Unable to find data for %s in CELLS --- ignored.\n",
+                         cellName);
+                continue;
+            }
+
+            // Have already plugged in the PHU
+
+            // Put in the cell data
+            if (cell->config) {
+                psLogMsg(__func__, PS_LOG_WARN, "Overwriting cell data in chip %s, cell %s\n", chipName,
+                         cellName);
+                psFree(cell->config); // Make way!
+            }
+            cell->config = psMemIncrRefCounter(cellData);
+        }
+    }
+
+
+    // Go through the contents
+    psMetadataIterator *contentsIter = psMetadataIteratorAlloc(contents, PS_LIST_HEAD, NULL);
+    psMetadataItem *contentsItem = NULL; // Item from contents
+    while ((contentsItem = psMetadataGetAndIncrement(contentsIter))) {
+        const char *extName = contentsItem->name;
+        if (contentsItem->type != PS_DATA_STRING) {
+            psLogMsg(__func__, PS_LOG_WARN, "CONTENTS item %s is not of type STR --- ignored.\n", extName);
+            continue;
+        }
+
+        pmHDU *hdu = pmHDUAlloc(extName); // The extension
+
+        // Parse the list of first:second
+        psArray *names = NULL;          // The first bits
+        psArray *values = NULL;         // The second bits
+        parsePairs(&names, &values, contentsItem->data.V);
+
+        // XXX Memory problems in here --> leaks and/or double frees???
+        if (strcasecmp(extType, "CHIP") == 0) {
+            // Extensions are chips
+            for (int i = 0; i < names->n; i++) {
+                psString chipName = names->data[i]; // The name of the chip
+                psString cellName = values->data[i]; // The name of the cell
+                pmChip *chip = findChip(fpa, chipName); // The chip we're looking for
+                pmCell *cell = findCell(chip, cellName); // The cell we're looking for
+                psMetadata *cellData = getCellData(format, cellName); // Data for this cell
+                if (! cellData) {
+                    psLogMsg(__func__, PS_LOG_WARN, "Unable to find data for %s in CELLS --- ignored.\n",
+                             cellName);
+                    continue;
+                }
+
+                // Put in the extension
+                if (chip->hdu) {
+                    psLogMsg(__func__, PS_LOG_WARN, "Overwriting HDU in chip %s\n", chipName);
+                    psFree(chip->hdu);  // Make way!
+                }
+                chip->hdu = psMemIncrRefCounter(hdu);
+
+                // Put in the cell data
+                if (cell->config) {
+                    psLogMsg(__func__, PS_LOG_WARN, "Overwriting cell data in chip %s, cell %s\n", chipName,
+                             cellName);
+                    psFree(cell->config); // Make way!
+                }
+                cell->config = psMemIncrRefCounter(cellData);
+            }
+
+        } else if (strcasecmp(extType, "CELL") == 0) {
+            // Extensions are cells
+            psString chipName = NULL;   // Name of chip under consideration
+            pmChip *chip = NULL;        // The chip we're looking for
+            if (! fpa->hdu->phu) {
+                // Need to look up the name of the chip
+                chipName = chipNameFromHeader(formatSpec, phu);
+                chip = findChip(fpa, chipName);
+            }
+            for (int i = 0; i < names->n; i++) {
+                psString cellType = values->data[i]; // The type of the cell
+                psString cellName = NULL; // The name of the cell
+                if (fpa->hdu->phu) {
+                    // We've got chipName:cellType with cellType == cellName
+                    chipName = names->data[i];
+                    cellName = cellType;
+                    chip = findChip(fpa, chipName);
+                } else {
+                    // We've got cellName:cellType and the chipName comes from before
+                    cellName = names->data[i];
+                }
+                psMetadata *cellData = getCellData(format, cellType); // Data for this cell
+                pmCell *cell = findCell(chip, cellName); // The cell we're looking for
+
+                // Put in the extension
+                if (cell->hdu) {
+                    psLogMsg(__func__, PS_LOG_WARN, "Overwriting HDU in chip %s, cell %s\n", chipName,
+                             cellName);
+                    psFree(cell->hdu);
+                }
+                cell->hdu = psMemIncrRefCounter(hdu);
+
+                // Put in the cell data
+                if (cell->config) {
+                    psLogMsg(__func__, PS_LOG_WARN, "Overwriting cell data in chip %s, cell %s\n", chipName,
+                             cellName);
+                    psFree(cell->config);
+                }
+                cell->config = psMemIncrRefCounter(cellData);
+            }
+
+        }
+        psFree(hdu);
+        psFree(names);
+        psFree(values);
+    }
+    psFree(contentsIter);
+
+    return true;
+}
+
+
+
+
+#if 0
 pmFPA *pmFPAConstruct(const psMetadata *camera // The camera configuration
                      )
@@ -270 +560 @@
     return fpa;
 }
+#endif
+
 
 // Print out the focal plane structure
-void pmFPAPrint(pmFPA *fpa              // FPA to print
+void pmFPAPrint(pmFPA *fpa,             // FPA to print
+                bool concepts           // Print concepts?
                )
 {
@@ -279 +572 @@
         psTrace(__func__, 2, "---> FPA is extension %s.\n", fpa->hdu->extname);
         if (! fpa->hdu->images) {
-            psTrace(__func__, 2, "---> NO PIXELS for extension %s\n", fpa->hdu->extname);
-        }
-    }
-    psMetadataPrint(fpa->concepts, 2);
+            psTrace(__func__, 2, "---> NO PIXELS read in for extension %s\n", fpa->hdu->extname);
+        }
+    }
+    if (concepts) {
+        psMetadataPrint(fpa->concepts, 2);
+    }
 
     psArray *chips = fpa->chips;        // Array of chips
@@ -292 +587 @@
             psTrace(__func__, 4, "---> Chip is extension %s.\n", chip->hdu->extname);
             if (! chip->hdu->images) {
-                psTrace(__func__, 4, "---> NO PIXELS for extension %s\n", chip->hdu->extname);
-            }
-        }
-        psMetadataPrint(chip->concepts, 4);
+                psTrace(__func__, 4, "---> NO PIXELS read in for extension %s\n", chip->hdu->extname);
+            }
+        }
+        if (concepts) {
+            psMetadataPrint(chip->concepts, 4);
+        }
 
         // Iterate over the chip
@@ -305 +602 @@
                 psTrace(__func__, 6, "---> Cell is extension %s.\n", cell->hdu->extname);
                 if (! cell->hdu->images) {
-                    psTrace(__func__, 6, "---> NO PIXELS for extension %s\n", cell->hdu->extname);
-                }
-            }
-            psMetadataPrint(cell->concepts, 6);
+                    psTrace(__func__, 6, "---> NO PIXELS read in for extension %s\n", cell->hdu->extname);
+                }
+            }
+            if (concepts) {
+                psMetadataPrint(cell->concepts, 6);
+            }
 
             psTrace(__func__, 7, "Readouts:\n");