Changeset 4386 for trunk/archive/scripts/src/papFocalPlane.c

Timestamp:

Jun 24, 2005, 3:05:59 PM (21 years ago)

Author:

Paul Price

Message:

Retrieval of concepts seems to be working.

File:

• trunk/archive/scripts/src/papFocalPlane.c (modified) (14 diffs)

trunk/archive/scripts/src/papFocalPlane.c

@@ -44 +44 @@
     psMetadataItem *newItem = psMetadataItemAlloc(valueName, value->type, value->comment, value->data.V);
 
-    if (fpa) {
+    if (fpa && strncmp(valueName, "FPA", 3) == 0) {
         psMetadataAddItem(fpa->values, newItem, PS_LIST_TAIL, PS_META_REPLACE);
     }
-    if (chip) {
+    if (chip && strncmp(valueName, "CHIP", 4) == 0) {
         psMetadataAddItem(chip->values, newItem, PS_LIST_TAIL, PS_META_REPLACE);
     }
-    if (cell) {
+    if (cell && strncmp(valueName, "CELL", 4) == 0) {
         psMetadataAddItem(cell->values, newItem, PS_LIST_TAIL, PS_META_REPLACE);
     }
 
-    psFree(newItem);
 }
 
@@ -65 +64 @@
 {
     bool mdStatus = true;               // Status of MD lookup
+    psMetadata *translation = psMetadataLookupMD(&mdStatus, fpa->camera, "TRANSLATION"); // FITS translation
+    if (! mdStatus) {
+        psError(PS_ERR_IO, false, "Unable to find TRANSLATION in camera configuration.\n");
+        return NULL;
+    }
 
     // Look for how to translate the concept into a FITS header name
-    const char *header = psMetadataLookupString(&mdStatus, fpa->fits, valueName);
-    if (strlen(header) > 0) {
+    const char *header = psMetadataLookupString(&mdStatus, translation, valueName);
+    if (mdStatus && strlen(header) > 0) {
         // We have a FITS header to look up --- search each level
         if (cell->header) {
@@ -110 +114 @@
     )
 {
-    psMetadataItem *defItem = psMetadataLookup((psMetadata*)fpa->defaults, valueName);
+    bool mdOK = true;                   // Status of MD lookup
+    psMetadata *defaults = psMetadataLookupMD(&mdOK, fpa->camera, "DEFAULTS");
+    if (! mdOK) {
+        psError(PS_ERR_IO, false, "Unable to find DEFAULTS in camera configuration.\n");
+        return NULL;
+    }
+
+    psMetadataItem *defItem = psMetadataLookup(defaults, valueName);
     if (defItem) {
+        if (defItem->type == PS_META_META) {
+            // A dependent default
+            psTrace(__func__, 7, "Evaluating dependent default....\n");
+            psMetadata *dependents = defItem->data.V; // The list of dependents
+            // Find out what it depends on
+            psString dependName = psStringCopy(valueName);
+            psStringAppend(&dependName, "_DEPEND");
+            psString dependsOn = psMetadataLookupString(&mdOK, defaults, dependName);
+            if (! mdOK) {
+                psError(PS_ERR_IO, false, "Unable to find %s in camera configuration for dependent default"
+                        " --- ignored\n", dependName);
+                // XXX: Need to clean up before returning
+                return NULL;
+            }
+            psFree(dependName);
+            // Find the value of the dependent concept
+            psMetadataItem *depItem = getValueFromCache(fpa, chip, cell, dependsOn);
+            if (! depItem) {
+                depItem = getValueFromHeader(fpa, chip, cell, dependsOn);
+            }
+            if (! depItem) {
+                psError(PS_ERR_IO, true, "Unable to find value for %s (required for %s)\n", dependsOn,
+                        valueName);
+                return NULL;
+            }
+            if (depItem->type != PS_META_STR) {
+                psError(PS_ERR_IO, true, "Value of %s is not of type string, as required for dependency"
+                        " --- ignored.\n", dependsOn);
+            }
+
+            defItem = psMetadataLookup(dependents, depItem->data.V);    // This is now what we were after
+        }
         setValueInCache(fpa, chip, cell, valueName, defItem);
     }
+
+    // XXX: Need to clean up before returning
     return defItem;                     // defItem is either NULL or points to what was desired
 }
@@ -125 +170 @@
     )
 {
-    if (fpa->db) {
-        // The database has been initialised
-        bool mdStatus = true;           // Status of MD lookup
-        psMetadata *dbLookup = psMetadataLookupMD(&mdStatus, fpa->database, valueName);
-        if (dbLookup) {
-            const char *tableName = psMetadataLookupString(&mdStatus, dbLookup, "TABLE"); // Name of the table
-            const char *colName = psMetadataLookupString(&mdStatus, dbLookup, "COLUMN"); // Name of the column
-            const char *givenCols = psMetadataLookupString(&mdStatus, dbLookup, "GIVENDBCOL");  // Name of "where" columns
-            const char *givenPS = psMetadataLookupString(&mdStatus, dbLookup, "GIVENPS"); // Values for "where" columns
-            
-            // Now, need to get the "given"s
-            if (strlen(givenCols) || strlen(givenPS)) {
-                psList *cols = papSplit(givenCols, ",;"); // List of column names
-                psList *values = papSplit(givenPS, ",;"); // List of value names for the columns
-                psMetadata *selection = psMetadataAlloc(); // The stuff to select in the DB
-                if (cols->size != values->size) {
-                    psLogMsg(__func__, PS_LOG_WARN, "The GIVENDBCOL and GIVENPS entries for %s do not have "
-                             "the same number of entries --- ignored.\n", valueName);
+    if (! fpa->db) {
+        // No database initialised
+        return NULL;
+    }
+
+    bool mdStatus = true;               // Status of MD lookup
+    psMetadata *database = psMetadataLookupMD(&mdStatus, fpa->camera, "DATABASE");
+    if (! mdStatus) {
+        // No error, because not everyone needs to use the DB
+        return NULL;
+    }
+
+    psMetadata *dbLookup = psMetadataLookupMD(&mdStatus, database, valueName);
+    if (dbLookup) {
+        const char *tableName = psMetadataLookupString(&mdStatus, dbLookup, "TABLE"); // Name of the table
+        const char *colName = psMetadataLookupString(&mdStatus, dbLookup, "COLUMN"); // Name of the column
+        const char *givenCols = psMetadataLookupString(&mdStatus, dbLookup, "GIVENDBCOL");      // Name of "where" columns
+        const char *givenPS = psMetadataLookupString(&mdStatus, dbLookup, "GIVENPS"); // Values for "where" columns
+        
+        // Now, need to get the "given"s
+        if (strlen(givenCols) || strlen(givenPS)) {
+            psList *cols = papSplit(givenCols, ",;"); // List of column names
+            psList *values = papSplit(givenPS, ",;"); // List of value names for the columns
+            psMetadata *selection = psMetadataAlloc(); // The stuff to select in the DB
+            if (cols->size != values->size) {
+                psLogMsg(__func__, PS_LOG_WARN, "The GIVENDBCOL and GIVENPS entries for %s do not have "
+                         "the same number of entries --- ignored.\n", valueName);
+            } else {
+                // Iterators for the lists
+                psListIterator *colsIter = psListIteratorAlloc(cols, PS_LIST_HEAD, false);
+                psListIterator *valuesIter = psListIteratorAlloc(values, PS_LIST_HEAD, false);
+                char *column = NULL;    // Name of the column
+                while (column = psListGetAndIncrement(colsIter)) {
+                    const char *name = psListGetAndIncrement(valuesIter); // Name for the value
+                    if (!strlen(column) || !strlen(name)) {
+                        psLogMsg(__func__, PS_LOG_WARN, "One of the columns or value names for %s is "
+                                 " empty --- ignored.\n", valueName);
+                    } else {
+                        // Search for the value name
+                        psMetadataItem *item = getValueFromCache(fpa, chip, cell, name);
+                        if (! item) {
+                            item = getValueFromHeader(fpa, chip, cell, name);
+                        }
+                        if (! item) {
+                            item = getValueFromDefault(fpa, chip, cell, name);
+                        }
+                        if (! item) {
+                            psLogMsg(__func__, PS_LOG_ERROR, "Unable to find the value name %s for DB "
+                                     " lookup on %s --- ignored.\n", name, valueName);
+                        } else {
+                            // We need to create a new psMetadataItem.  I don't think we can't simply hack
+                            // the existing one, since that could conceivably cause memory leaks
+                            psMetadataItem *newItem = psMetadataItemAlloc(valueName, item->type,
+                                                                          item->comment, item->data.V);
+                            psMetadataAddItem(selection, newItem, PS_LIST_TAIL, PS_META_REPLACE);
+                            psFree(newItem);
+                        }
+                    }
+                } // Iterating through the columns
+                
+                psArray *dbResult = psDBSelectRows(fpa->db, tableName, selection, 2); // Lookup result
+                // Note that we use limit=2 in order to test if there are multiple rows returned
+                
+                psMetadataItem *result = NULL; // The final result of the DB lookup
+                if (dbResult->n == 0) {
+                    psLogMsg(__func__, PS_LOG_WARN, "Unable to find any rows in DB for %s --- ignored\n", 
+                             valueName);
                 } else {
-                    // Iterators for the lists
-                    psListIterator *colsIter = psListIteratorAlloc(cols, PS_LIST_HEAD, false);
-                    psListIterator *valuesIter = psListIteratorAlloc(values, PS_LIST_HEAD, false);
-                    char *column = NULL;        // Name of the column
-                    while (column = psListGetAndIncrement(colsIter)) {
-                        const char *name = psListGetAndIncrement(valuesIter); // Name for the value
-                        if (!strlen(column) || !strlen(name)) {
-                            psLogMsg(__func__, PS_LOG_WARN, "One of the columns or value names for %s is "
-                                     " empty --- ignored.\n", valueName);
-                        } else {
-                            // Search for the value name
-                            psMetadataItem *item = getValueFromCache(fpa, chip, cell, name);
-                            if (! item) {
-                                item = getValueFromHeader(fpa, chip, cell, name);
-                            }
-                            if (! item) {
-                                item = getValueFromDefault(fpa, chip, cell, name);
-                            }
-                            if (! item) {
-                                psLogMsg(__func__, PS_LOG_ERROR, "Unable to find the value name %s for DB "
-                                         " lookup on %s --- ignored.\n", name, valueName);
-                            } else {
-                                // We need to create a new psMetadataItem.  I don't think we can't simply hack
-                                // the existing one, since that could conceivably cause memory leaks
-                                psMetadataItem *newItem = psMetadataItemAlloc(valueName, item->type,
-                                                                              item->comment, item->data.V);
-                                psMetadataAddItem(selection, newItem, PS_LIST_TAIL, PS_META_REPLACE);
-                                psFree(newItem);
-                            }
-                        }
-                    } // Iterating through the columns
-                    
-                    psArray *dbResult = psDBSelectRows(fpa->db, tableName, selection, 2); // Result of lookup
-                    // Note that we use limit=2 in order to test if there are multiple rows returned
-
-                    psMetadataItem *result = NULL; // The final result of the DB lookup
-                    if (dbResult->n == 0) {
-                        psLogMsg(__func__, PS_LOG_WARN, "Unable to find any rows in DB for %s --- ignored\n", 
-                                 valueName);
-                    } else {
-                        if (dbResult-> n > 1) {
-                            psLogMsg(__func__, PS_LOG_WARN, "Multiple rows returned in DB lookup for %s --- "
-                                     " using the first one only.\n", valueName);
-                        }
-                        result = (psMetadataItem*)dbResult->data[0];
+                    if (dbResult-> n > 1) {
+                        psLogMsg(__func__, PS_LOG_WARN, "Multiple rows returned in DB lookup for %s --- "
+                                 " using the first one only.\n", valueName);
                     }
-                    // XXX: Need to clean up before returning
-                    return result;
+                    result = (psMetadataItem*)dbResult->data[0];
                 }
-            }
-        } // Doing the "given"s.
-    }
-
-    // XXX: Need to clean up before returning
-
-    // If we've fallen through somehow, we didn't get anything.
+                // XXX: Need to clean up before returning
+                return result;
+            }
+        }
+    } // Doing the "given"s.
+
+    // Shouldn't get here
     return NULL;
 }
@@ -209 +260 @@
                                )
 {
+    psTrace(__func__, 3, "Trying to retrieve %s for %s:%s...\n", valueName, chipName, cellName);
+
     bool mdStatus = true;               // Status of MD lookup
     papChip *chip = psMetadataLookupChip(&mdStatus, fpa->chips, chipName); // The chip
+    if (!mdStatus) {
+        psError(PS_ERR_IO, false, "Unable to find chip named %s\n", chipName);
+        return NULL;
+    }
     papCell *cell = psMetadataLookupCell(&mdStatus, chip->cells, cellName); // The cell
+    if (!mdStatus) {
+        psError(PS_ERR_IO, false, "Unable to find cell named %s in chip %s\n", cellName, chipName);
+        return NULL;
+    }
 
     // Try cache, headers, database, defaults in order
+    psTrace(__func__, 5, "Trying caches....\n");
     psMetadataItem *item = getValueFromCache(fpa, chip, cell, valueName);
     if (! item) {
+        psTrace(__func__, 5, "Trying headers....\n");
         item = getValueFromHeader(fpa, chip, cell, valueName);
     }
     if (! item) {
+        psTrace(__func__, 5, "Trying database....\n");
         item = getValueFromDB(fpa, chip, cell, valueName);
     }
     if (! item) {
+        psTrace(__func__, 5, "Trying defaults....\n");
         item = getValueFromDefault(fpa, chip, cell, valueName);
     }
@@ -245 +310 @@
     }
 
-    psFree(item);
     return value;
 }
@@ -266 +330 @@
     }
 
-    psFree(item);
     return value;
 }
@@ -288 +351 @@
     }
 
-    psFree(item);
     return value;
 }
@@ -310 +372 @@
     }
 
-    psFree(item);
     return value;
 }
@@ -318 +379 @@
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-papFPA *papFPAAlloc(psMetadata *fits, // FITS translation info
-                    psMetadata *database, // Database lookup info
-                    psMetadata *defaults, // Defaults info
-                    psDB *db            // Database handle
+papFPA *papFPAAlloc(const psMetadata *camera, // Camera configuration
+                    psDB *db            // Database
     )
 {
@@ -327 +386 @@
     psMemSetDeallocator(fpa, (psFreeFcn)p_papFPAFree);
 
-    // Fill in the various components
-    fpa->fits = psMemIncrRefCounter(fits);
-    fpa->database = psMemIncrRefCounter(database);
-    fpa->defaults = psMemIncrRefCounter(defaults);
+    // Fill in the components
+    fpa->fromTangentPlane = NULL;
+    fpa->toTangentPlane = NULL;
+    fpa->projection = NULL;
 
     fpa->values = psMetadataAlloc();
+    fpa->camera = psMemIncrRefCounter((psPtr)camera);
+    fpa->db = db;
+    fpa->chips = psMetadataAlloc();
+
+    fpa->pixels = NULL;
     fpa->header = NULL;
-    fpa->db = psMemIncrRefCounter(db);
-
-    fpa->chips = psMetadataAlloc();
-    fpa->images = NULL;
 
     return fpa;
@@ -344 +404 @@
 void p_papFPAFree(papFPA *fpa)
 {
-    psFree((psPtr)fpa->fits);
-    psFree((psPtr)fpa->database);
-    psFree((psPtr)fpa->defaults);
+    psFree(fpa->fromTangentPlane);
+    psFree(fpa->toTangentPlane);
+    psFree(fpa->projection);
 
     psFree(fpa->values);
+    psFree((psPtr)fpa->camera);
+    psFree(fpa->db);
+    psFree(fpa->chips);
+
+    psFree(fpa->pixels);
     psFree(fpa->header);
-    if (fpa->db) {
-        psDBCleanup((psDB*)fpa->db);
-    }
-
-    psFree(fpa->chips);
-    psFree(fpa->images);
-}
-
-papChip *papChipAlloc(papFPA *fpa,              // FPA to which the chip belongs
-                    const char *name    // Name of the chip
+}
+
+papChip *papChipAlloc(papFPA *fpa,      // FPA to which the chip belongs
+                      const char *name  // Name of the chip
     )
 {
     papChip *chip = psAlloc(sizeof(papChip)); // The chip
     psMemSetDeallocator(chip, (psFreeFcn)p_papChipFree);
-    psMetadataAdd(fpa->chips, PS_LIST_TAIL, name, PS_META_CHIP, "Added on allocation of chip", chip);
+
+    // Push onto the FPA
+    psMetadataAdd(fpa->chips, PS_LIST_TAIL, name, PS_META_CHIP, "Chip added on allocation", chip);
+
+    // Fill in the components
+    *(int*)&chip->col0 = 0;             // Good enough for now
+    *(int*)&chip->row0 = 0;             // Good enough for now
+
+    chip->toFPA = NULL;
+    chip->fromFPA = NULL;
 
     chip->values = psMetadataAlloc();
+    chip->cells = psMetadataAlloc();
+
+    chip->pixels = NULL;
     chip->header = NULL;
 
-    chip->cells = psMetadataAlloc();
-    chip->images = NULL;
+    psMetadataAdd(chip->values, PS_LIST_TAIL, "CHIP.NAME", PS_META_STR, "Name of the chip",
+                  psStringCopy(name));
 
     return chip;
@@ -377 +448 @@
 void p_papChipFree(papChip *chip)
 {
+    psFree(chip->toFPA);
+    psFree(chip->fromFPA);
+
     psFree(chip->values);
+    psFree(chip->cells);
+
+    psFree(chip->pixels);
     psFree(chip->header);
-    psFree(chip->cells);
-    psFree(chip->images);
 }
 
 papCell *papCellAlloc(papChip *chip,    // Chip to which the cell belongs
-                    const char *name,   // Name of the cell
-                    int nReadouts       // Number of readouts contained
+                      const char *name, // Name of the cell
+                      int nReadouts     // Number of readouts contained
     )
 {
     papCell *cell = psAlloc(sizeof(papCell)); // The cell
     psMemSetDeallocator(cell, (psFreeFcn)p_papCellFree);
-    psMetadataAdd(chip->cells, PS_LIST_TAIL, name, PS_META_CELL, "Added on allocation of cell", cell);
+
+    // Push onto the chip
+    psMetadataAdd(chip->cells, PS_LIST_TAIL, name, PS_META_CELL, "Cell added on allocation", cell);
+
+    // Fill in components
+    *(int*)&cell->col0 = 0;             // Good enough for now
+    *(int*)&cell->row0 = 0;             // Good enough for now
+
+    cell->toChip = NULL;
+    cell->fromChip = NULL;
+    cell->toFPA = NULL;
+    cell->toTP = NULL;
+    cell->toSky = NULL;
 
     cell->values = psMetadataAlloc();
+    cell->readouts = psArrayAlloc(nReadouts);
+
+    cell->pixels = NULL;
     cell->header = NULL;
 
-    cell->readouts = psArrayAlloc(nReadouts);
-    cell->images = NULL;
+    psMetadataAdd(cell->values, PS_LIST_TAIL, "CELL.NAME", PS_META_STR, "Name of the cell",
+                  psStringCopy(name));
 
     return cell;
@@ -403 +493 @@
 void p_papCellFree(papCell *cell)
 {
+    psFree(cell->toChip);
+    psFree(cell->fromChip);
+    psFree(cell->toFPA);
+    psFree(cell->toTP);
+    psFree(cell->toSky);
+
     psFree(cell->values);
+    psFree(cell->readouts);
+
+    psFree(cell->pixels);
     psFree(cell->header);
-    psFree(cell->readouts);
-    psFree(cell->images);
 }