Changeset 23594 for branches/cnb_branches/cnb_branch_20090301/psModules/src/concepts/pmConceptsWrite.c

Timestamp:

Mar 29, 2009, 6:15:31 PM (17 years ago)

Author:

beaumont

Message:

merged with head

Location:

branches/cnb_branches/cnb_branch_20090301

Files:

• . (modified) (1 prop)
• psModules (modified) (1 prop)
• psModules/src/concepts/pmConceptsWrite.c (modified) (14 diffs)

branches/cnb_branches/cnb_branch_20090301/psModules/src/concepts/pmConceptsWrite.c

@@ -62 +62 @@
         while ((cItem = psListGetAndIncrement(cIter))) {
             if (cItem->type != PS_DATA_STRING) {
-                psWarning("psMetadataItem from list is of type %x instead of "
-                         "%x (PS_DATA_STRING) --- can't interpret.\n", cItem->type, PS_DATA_STRING);
+                psWarning("psMetadataItem from list is of type %x instead of %x (PS_DATA_STRING) --- can't interpret.\n", cItem->type, PS_DATA_STRING);
                 psFree(cIter);
                 psFree(sIter);
@@ -183 +182 @@
         }
     default:
-        psWarning("Type of %s is not suitable for a FITS header --- not added.\n",
+      psWarning("Type of %s is not suitable for a FITS header --- not added.\n",
                  item->name);
         return false;
@@ -226 +225 @@
 }
 
+// Return the camera format appropriate for a focal plane hierarchy
+static psMetadata *conceptsCameraFormat(const pmFPA *fpa, const pmChip *chip, const pmCell *cell)
+{
+    pmHDU *hdu = pmHDUGetLowest(fpa, chip, cell); // The HDU at the lowest level
+    if (!hdu) {
+        return NULL;
+    }
+    return hdu->format;
+}
+
+// Return the DATABASE metadata from the format
+static psMetadata *conceptsDatabase(const psMetadata *format)
+{
+    bool mdok;                          // Status of MD lookup
+    return psMetadataLookupMetadata(&mdok, format, "DEFAULTS");
+}
+
+// Return the TRANSLATION metadata from the format
+static psMetadata *conceptsTranslation(const psMetadata *format)
+{
+    bool mdok;                          // Status of MD lookup
+    return psMetadataLookupMetadata(&mdok, format, "TRANSLATION");
+}
+
+// Return the DEFAULTS metadata from the format
+static psMetadata *conceptsDefaults(const psMetadata *format)
+{
+    bool mdok;                          // Status of MD lookup
+    return psMetadataLookupMetadata(&mdok, format, "DEFAULTS");
+}
+
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -231 +261 @@
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-bool p_pmConceptsWriteToCells(const psMetadata *specs, const pmCell *cell, const psMetadata *concepts)
-{
-    PS_ASSERT_PTR_NON_NULL(specs, false);
-    PS_ASSERT_PTR_NON_NULL(concepts, false);
+bool p_pmConceptWriteToCells(const pmCell *cell, const pmConceptSpec *spec,
+                             const psMetadataItem *conceptItem, const psMetadata *format)
+{
     if (!cell) {
         return false;
@@ -242 +271 @@
     }
 
-    pmHDU *hdu = pmHDUGetLowest(NULL, NULL, cell); // The HDU at the lowest level
+    if (!format) {
+        format = conceptsCameraFormat(NULL, NULL, cell);
+        if (!format) {
+            return false;
+        }
+    }
+
+    psMetadataItem *cameraItem = psMetadataLookup(cell->config, conceptItem->name); // Version in the config
+    if (!cameraItem) {
+        return false;
+    }
+
+    psString nameSource = NULL; // String with the concept name and ".SOURCE" added
+    psStringAppend(&nameSource, "%s.SOURCE", conceptItem->name);
+    bool mdok = true;       // Status of MD lookup
+    psString source = psMetadataLookupStr(&mdok, cell->config, nameSource); // The source
+    if (mdok && strlen(source) > 0) {
+        psTrace("psModules.concepts", 8, "%s is %s\n", nameSource, source);
+        if (strcasecmp(source, "HEADER") == 0) {
+            if (cameraItem->type != PS_DATA_STRING) {
+                psWarning("Concept %s is specified by header, but is not of type STR --- ignored.",
+                          conceptItem->name);
+                psFree(nameSource);
+                return false;
+            }
+
+            // Formatted version
+            psMetadataItem *formatted = conceptFormat(spec, conceptItem, PM_CONCEPT_SOURCE_HEADER,
+                                                      format, NULL, NULL, cell);
+            if (!formatted) {
+                psFree(nameSource);
+                return true;
+            }
+
+            psTrace("psModules.concepts", 8, "Writing %s to header %s\n",
+                    conceptItem->name, cameraItem->data.str);
+            pmHDU *hdu = pmHDUGetLowest(NULL, NULL, cell); // Header data unit
+            if (!hdu) {
+                psError(PS_ERR_UNEXPECTED_NULL, false,
+                        "Unable to find HDU to write concept %s", conceptItem->name);
+                return false;
+            }
+            writeHeader(hdu, cameraItem->data.V, formatted);
+            psFree(formatted);
+        } else if (strcasecmp(source, "VALUE") == 0) {
+            // Formatted version
+            psMetadataItem *formatted = conceptFormat(spec, conceptItem, PM_CONCEPT_SOURCE_CELLS,
+                                                      format, NULL, NULL, cell);
+            if (!formatted) {
+                psFree(nameSource);
+                return true;
+            }
+
+            psTrace("psModules.concepts", 8, "Checking %s against camera format.\n", conceptItem->name);
+            if (!compareConcepts(formatted, cameraItem)) {
+                psWarning("Concept %s is specified by value in the camera format, but the values don't match",
+                          conceptItem->name);
+            }
+            psFree(formatted);
+        } else {
+            psWarning("Concept source %s isn't HEADER or VALUE --- can't write", nameSource);
+        }
+    } else {
+        // Assume it's specified by value
+        psMetadataItem *formatted = conceptFormat(spec, conceptItem, PM_CONCEPT_SOURCE_CELLS,
+                                                  format, NULL, NULL, cell);
+        if (!formatted) {
+            psFree(nameSource);
+            return true;
+        }
+
+        if (!compareConcepts(formatted, cameraItem)) {
+            psWarning("Concept %s is specified by value in the camera format, but the values don't match.",
+                      conceptItem->name);
+        }
+        psFree(formatted);
+    }
+    psFree(nameSource);
+
+    return true;
+}
+
+bool p_pmConceptWriteToDefaults(const pmFPA *fpa, const pmChip *chip, const pmCell *cell,
+                                const pmConceptSpec *spec, const psMetadataItem *conceptItem,
+                                const psMetadata *format, const psMetadata *defaults)
+{
+    if (!format) {
+        format = conceptsCameraFormat(fpa, chip, cell);
+        if (!format) {
+            return false;
+        }
+    }
+    if (!defaults) {
+        defaults = conceptsDefaults(format);
+        if (!defaults) {
+            return false;
+        }
+    }
+
+    psMetadataItem *defaultItem = p_pmConceptsReadSingleFromDefaults(conceptItem->name, defaults,
+                                                                     fpa, chip, cell);
+    if (!defaultItem) {
+        return false;
+    }
+    psMetadataItem *formatted = conceptFormat(spec, conceptItem, PM_CONCEPT_SOURCE_DEFAULTS,
+                                              format, fpa, chip, cell);
+    if (!formatted) {
+        return true;
+    }
+
+    if (strcmp(defaultItem->name, conceptItem->name) != 0) {
+        // Correct the name to match the concept name
+        defaultItem = psMetadataItemCopy(defaultItem);
+        psFree(defaultItem->name);
+        defaultItem->name = psStringCopy(conceptItem->name);
+    } else {
+        psMemIncrRefCounter(defaultItem);
+    }
+
+    if (!compareConcepts(formatted, defaultItem)) {
+        psWarning("Concept %s is specified by the DEFAULTS in the camera format, but the values don't match.",
+                  conceptItem->name);
+    }
+    psFree(defaultItem);
+    psFree(formatted);
+
+    return true;
+}
+
+
+bool p_pmConceptWriteToHeader(const pmFPA *fpa, const pmChip *chip, const pmCell *cell,
+                              const pmConceptSpec *spec, const psMetadataItem *conceptItem,
+                              const psMetadata *format, const psMetadata *translation)
+{
+    if (!format) {
+        format = conceptsCameraFormat(fpa, chip, cell);
+        if (!format) {
+            return false;
+        }
+    }
+    if (!translation) {
+        translation = conceptsTranslation(format);
+        if (!translation) {
+            return false;
+        }
+    }
+
+    psMetadataItem *headerItem = psMetadataLookup(translation, conceptItem->name); // How to format for header
+    if (!headerItem) {
+        return false;
+    }
+    if (headerItem->type == PS_DATA_METADATA) {
+        // This is a menu
+        psTrace("psModules.concepts", 5, "%s is of type METADATA.\n", conceptItem->name);
+        headerItem = p_pmConceptsDepend(conceptItem->name, headerItem->data.md, translation, fpa, chip, cell);
+        if (!headerItem) {
+            return false;
+        }
+    }
+    if (headerItem->type != PS_DATA_STRING) {
+        psWarning("TRANSLATION keyword for concept %s isn't of type STR --- ignored.", conceptItem->name);
+        return false;
+    }
+    psTrace("psModules.concepts", 3, "Writing %s to header %s\n", conceptItem->name, headerItem->data.str);
+    psMetadataItem *formatted = conceptFormat(spec, conceptItem, PM_CONCEPT_SOURCE_HEADER,
+                                              format, fpa, chip, cell);
+    if (!formatted) {
+        // Found it, but it doesn't need to be written
+        return true;
+    }
+
+    pmHDU *hdu = pmHDUGetLowest(fpa, chip, cell); // HDU to which to write
     if (!hdu) {
-        return false;
-    }
-    psMetadata *cameraFormat = hdu->format; // The camera format
-    psMetadataIterator *specsIter = psMetadataIteratorAlloc(specs, PS_LIST_HEAD, NULL); // Iterator
-    psMetadataItem *specItem = NULL;    // Item from the specs metadata
-    while ((specItem = psMetadataGetAndIncrement(specsIter))) {
-        pmConceptSpec *spec = specItem->data.V; // The specification
-        psString name = specItem->name; // The concept name
-        psMetadataItem *cameraItem = psMetadataLookup(cell->config, name); // The concept from the camera,
-        // or NULL
-        if (cameraItem) {
-            // Grab the concept
-            psMetadataItem *conceptItem = psMetadataLookup(concepts, name); // The concept
-
-            psString nameSource = NULL; // String with the concept name and ".SOURCE" added
-            psStringAppend(&nameSource, "%s.SOURCE", name);
-            bool mdok = true;       // Status of MD lookup
-            psString source = psMetadataLookupStr(&mdok, cell->config, nameSource); // The source
-            if (mdok && strlen(source) > 0) {
-                psTrace("psModules.concepts", 8, "%s is %s\n", nameSource, source);
-                if (strcasecmp(source, "HEADER") == 0) {
-                    if (cameraItem->type != PS_DATA_STRING) {
-                        psWarning("Concept %s is specified by header, but is not "
-                                 "of type STR --- ignored.\n", conceptItem->name);
-                        continue;
-                    }
-
-                    // Formatted version
-                    psMetadataItem *formatted = conceptFormat(spec, conceptItem, PM_CONCEPT_SOURCE_HEADER,
-                                                              cameraFormat, NULL, NULL, cell);
-                    if (!formatted) {
-                        continue;
-                    }
-
-                    psTrace("psModules.concepts", 8, "Writing %s to header %s\n", name, cameraItem->data.str);
-                    writeHeader(hdu, cameraItem->data.V, formatted);
-                    psFree(formatted);
-                } else if (strcasecmp(source, "VALUE") == 0) {
-                    // Formatted version
-                    psMetadataItem *formatted = conceptFormat(spec, conceptItem, PM_CONCEPT_SOURCE_CELLS,
-                                                              cameraFormat, NULL, NULL, cell);
-                    if (!formatted) {
-                        continue;
-                    }
-
-                    psTrace("psModules.concepts", 8, "Checking %s against camera format.\n", name);
-                    if (! compareConcepts(formatted, cameraItem)) {
-                        psWarning("Concept %s is specified by value in the camera "
-                                 "format, but the values don't match.\n", name);
-                    }
-                    psFree(formatted);
-                } else {
-                    psWarning("Concept source %s isn't HEADER or VALUE --- can't "
-                             "write\n", nameSource);
-                }
-            } else {
-                // Assume it's specified by value
-                psMetadataItem *formatted = conceptFormat(spec, conceptItem, PM_CONCEPT_SOURCE_CELLS,
-                                                          cameraFormat, NULL, NULL, cell);
-                if (!formatted) {
-                    continue;
-                }
-
-                if (! compareConcepts(formatted, cameraItem)) {
-                    psWarning("Concept %s is specified by value in the camera "
-                             "format, but the values don't match.\n", name);
-                }
-                psFree(formatted);
-            }
-            psFree(nameSource);
-        }
-
-    }
-    psFree(specsIter);
+        psError(PS_ERR_UNEXPECTED_NULL, false, "Unable to find HDU to write concept %s", conceptItem->name);
+        return false;
+    }
+    writeHeader(hdu, headerItem->data.V, formatted);
+    psFree(formatted);
+
     return true;
 }
 
-bool p_pmConceptsWriteToDefaults(const psMetadata *specs, const pmFPA *fpa, const pmChip *chip,
-                                 const pmCell *cell, const psMetadata *concepts)
-{
-    PS_ASSERT_PTR_NON_NULL(specs, false);
-    PS_ASSERT_PTR_NON_NULL(concepts, false);
-
-    pmHDU *hdu = pmHDUGetLowest(fpa, chip, cell); // The HDU at the lowest level
-    if (!hdu) {
-        return false;
-    }
-    psMetadata *cameraFormat = hdu->format; // The camera format
-    bool mdok = true;                   // Status of MD lookup
-    psMetadata *defaults = psMetadataLookupMetadata(&mdok, cameraFormat, "DEFAULTS"); // The DEFAULTS spec
-    if (!mdok || !defaults) {
-        return false;
-    }
-
-    psMetadataIterator *specsIter = psMetadataIteratorAlloc(specs, PS_LIST_HEAD, NULL); // Iterator
-    psMetadataItem *specItem = NULL;    // Item from the specs metadata
-    while ((specItem = psMetadataGetAndIncrement(specsIter))) {
-        pmConceptSpec *spec = specItem->data.V; // The specification
-        psString name = specItem->name; // The concept name
-
-        psMetadataItem *defaultItem = p_pmConceptsReadSingleFromDefaults(name, defaults, fpa, chip, cell);
-        if (!defaultItem) {
-            continue;
-        }
-        psMetadataItem *conceptItem = psMetadataLookup(concepts, name); // The item from the concepts
-        psMetadataItem *formatted = conceptFormat(spec, conceptItem, PM_CONCEPT_SOURCE_DEFAULTS,
-                                                  cameraFormat, fpa, chip, cell);
-        if (!formatted) {
-            continue;
-        }
-
-        if (strcmp(defaultItem->name, name) != 0) {
-            // Correct the name to match the concept name
-            defaultItem = psMetadataItemCopy(defaultItem);
-            psFree(defaultItem->name);
-            defaultItem->name = psStringCopy(name);
-        } else {
-            psMemIncrRefCounter(defaultItem);
-        }
-
-        if (!compareConcepts(formatted, defaultItem)) {
-            psWarning("Concept %s is specified by the DEFAULTS in the camera "
-                      "format, but the values don't match.\n", name);
-        }
-        psFree(defaultItem);
-        psFree(formatted);
-    }
-    psFree(specsIter);
+bool p_pmConceptWriteToDatabase(const pmFPA *fpa, const pmChip *chip, const pmCell *cell,
+                                pmConfig *config, const pmConceptSpec *spec,
+                                const psMetadataItem *conceptItem, const psMetadata *format,
+                                const psMetadata *database)
+{
+    PS_ASSERT_PTR_NON_NULL(config, false);
+
+#ifndef HAVE_PSDB
+    return false;
+#else
+
+    if (!format) {
+        format = conceptsCameraFormat(fpa, chip, cell);
+        if (!format) {
+            return false;
+        }
+    }
+    if (!database) {
+        database = conceptsDatabase(format);
+        if (!database) {
+            return false;
+        }
+    }
+
+    psMetadataItem *dbItem = p_pmConceptsReadSingleFromDatabase(conceptItem->name, database, config,
+                                                                fpa, chip, cell); // Database version
+    if (!dbItem) {
+        return false;
+    }
+
+    psMetadataItem *formatted = conceptFormat(spec, conceptItem, PM_CONCEPT_SOURCE_DATABASE,
+                                              format, fpa, chip, cell);
+    if (!formatted) {
+        return false;
+    }
+
+    if (strcmp(dbItem->name, conceptItem->name) != 0) {
+        // Correct the name to match the concept name
+        dbItem = psMetadataItemCopy(dbItem);
+        psFree(dbItem->name);
+        dbItem->name = psStringCopy(conceptItem->name);
+    } else {
+        psMemIncrRefCounter(dbItem);
+    }
+
+    if (!compareConcepts(formatted, dbItem)) {
+        psWarning("Concept %s is specified by the DATABASE in the camera "
+                  "format, but the values don't match.\n", conceptItem->name);
+    }
+    psFree(dbItem);
+    psFree(formatted);
+
     return true;
-}
-
-
-bool p_pmConceptsWriteToHeader(const psMetadata *specs, const pmFPA *fpa, const pmChip *chip,
-                               const pmCell *cell, const psMetadata *concepts)
-{
-    PS_ASSERT_PTR_NON_NULL(specs, false);
-    PS_ASSERT_PTR_NON_NULL(concepts, false);
-
-    pmHDU *hdu = pmHDUGetLowest(fpa, chip, cell); // The HDU at the lowest level
-    if (!hdu) {
-        return false;
-    }
-    psMetadata *cameraFormat = hdu->format; // The camera format
-    bool mdok = true;                   // Status of MD lookup
-    psMetadata *translation = psMetadataLookupMetadata(&mdok, cameraFormat, "TRANSLATION"); // The TRANSLATION spec
-    if (!mdok || !translation) {
-        return false;
-    }
-
-    psMetadataIterator *specsIter = psMetadataIteratorAlloc(specs, PS_LIST_HEAD, NULL); // Iterator
-    psMetadataItem *specItem = NULL;    // Item from the specs metadata
-    while ((specItem = psMetadataGetAndIncrement(specsIter))) {
-        pmConceptSpec *spec = specItem->data.V; // The specification
-        psString name = specItem->name; // The concept name
-        psMetadataItem *headerItem = psMetadataLookup(translation, name); // The item from the TRANSLATION
-        if (!headerItem) {
-            continue;
-        }
-        if (headerItem->type == PS_DATA_METADATA) {
-            // This is a menu
-            psTrace("psModules.concepts", 5, "%s is of type METADATA.\n", name);
-            headerItem = p_pmConceptsDepend(name, headerItem->data.md, translation, fpa, chip, cell);
-            if (!headerItem) {
-                continue;
-            }
-        }
-        if (headerItem->type != PS_DATA_STRING) {
-            psWarning("TRANSLATION keyword for concept %s isn't of type STR --- ignored.", name);
-            continue;
-        }
-        psTrace("psModules.concepts", 3, "Writing %s to header %s\n", name, headerItem->data.str);
-        psMetadataItem *conceptItem = psMetadataLookup(concepts, name); // The item from the concepts
-        psMetadataItem *formatted = conceptFormat(spec, conceptItem, PM_CONCEPT_SOURCE_HEADER,
-                                                  cameraFormat, fpa, chip, cell);
-        if (!formatted) {
-            continue;
-        }
-        writeHeader(hdu, headerItem->data.V, formatted);
-        psFree(formatted);
-    }
-    psFree(specsIter);
+#endif
+}
+
+
+bool pmConceptWriteSingle(const pmFPA *fpa, const pmChip *chip, const pmCell *cell,
+                          pmConfig *config, const psMetadataItem *conceptItem)
+{
+    pmConceptsInit();
+
+    psMetadata *format = conceptsCameraFormat(fpa, chip, cell); // Camera format
+    if (!format) {
+        psError(PS_ERR_UNKNOWN, false, "Unable to retrieve camera format.");
+        return false;
+    }
+
+    const char *name = conceptItem->name; // Name of concept
+
+    psMetadata *conceptsFPA = pmConceptsSpecs(PM_FPA_LEVEL_FPA); // Concept specifications for FPA
+    bool mdok;                          // Status of MD lookup
+    pmConceptSpec *spec = psMetadataLookupPtr(&mdok, conceptsFPA, name); // Concept specification of interest
+    if (!spec) {
+        psMetadata *conceptsChip = pmConceptsSpecs(PM_FPA_LEVEL_CHIP); // Concept specifications for Chip
+        spec = psMetadataLookupPtr(&mdok, conceptsChip, name);
+        if (!spec) {
+            psMetadata *conceptsCell = pmConceptsSpecs(PM_FPA_LEVEL_CELL); // Concept specifications for Cell
+            spec = psMetadataLookupPtr(&mdok, conceptsCell, name);
+            if (!spec) {
+                psError(PS_ERR_UNEXPECTED_NULL, true, "Unable to find specification for concept %s", name);
+                return false;
+            }
+        }
+    }
+
+    if (!p_pmConceptWriteToCells(cell, spec, conceptItem, format) &&
+        !p_pmConceptWriteToDefaults(fpa, chip, cell, spec, conceptItem, format, NULL) &&
+        !p_pmConceptWriteToHeader(fpa, chip, cell, spec, conceptItem, format, NULL) &&
+        !p_pmConceptWriteToDatabase(fpa, chip, cell, config, spec, conceptItem, format, NULL)) {
+        return false;
+    }
     return true;
 }
-
-// XXX Warning: This code has not been tested at all
-bool p_pmConceptsWriteToDatabase(const psMetadata *specs, const pmFPA *fpa, const pmChip *chip,
-                                 const pmCell *cell, pmConfig *config, const psMetadata *concepts)
-{
-    PS_ASSERT_PTR_NON_NULL(specs, false);
-    PS_ASSERT_PTR_NON_NULL(concepts, false);
-    PS_ASSERT_PTR_NON_NULL(config, false);
-
-    #ifndef HAVE_PSDB
-    return false;
-    #else
-
-    pmHDU *hdu = pmHDUGetLowest(fpa, chip, cell); // The HDU at the lowest level
-    if (!hdu) {
-        return false;
-    }
-    psMetadata *cameraFormat = hdu->format; // The camera format
-    bool mdok = true;                   // Status of MD lookup
-    psMetadata *database = psMetadataLookupMetadata(&mdok, cameraFormat, "DATABASE"); // The DATABASE spec
-    if (!mdok || !database) {
-        return false;
-    }
-    psMetadataIterator *specsIter = psMetadataIteratorAlloc(specs, PS_LIST_HEAD, NULL); // Iterator
-    psMetadataItem *specItem = NULL;    // Item from the specs metadata
-    while ((specItem = psMetadataGetAndIncrement(specsIter))) {
-        pmConceptSpec *spec = specItem->data.V; // The specification
-        psString name = specItem->name; // The concept name
-
-        psMetadataItem *dbItem = p_pmConceptsReadSingleFromDatabase(name, database, config, fpa, chip, cell);
-        if (!dbItem) {
-            continue;
-        }
-
-        psMetadataItem *conceptItem = psMetadataLookup(concepts, name); // The item from the concepts
-        psMetadataItem *formatted = conceptFormat(spec, conceptItem, PM_CONCEPT_SOURCE_DATABASE,
-                                                  cameraFormat, fpa, chip, cell);
-        if (!formatted) {
-            continue;
-        }
-
-        if (strcmp(dbItem->name, name) != 0) {
-            // Correct the name to match the concept name
-            dbItem = psMetadataItemCopy(dbItem);
-            psFree(dbItem->name);
-            dbItem->name = psStringCopy(name);
-        } else {
-            psMemIncrRefCounter(dbItem);
-        }
-
-        if (!compareConcepts(formatted, dbItem)) {
-            psWarning("Concept %s is specified by the DATABASE in the camera "
-                      "format, but the values don't match.\n", name);
-        }
-        psFree(dbItem);
-        psFree(formatted);
-    }
-    psFree(specsIter);
-    return true;
-    #endif
-}
-
-
-
 
 
@@ -498 +554 @@
                           const pmChip *chip, // The chip
                           const pmCell *cell, // The cell
-                          pmConceptSource source, // The source of the concepts to write
                           pmConfig *config, // Configuration
                           psMetadata *concepts // The concepts to write out
@@ -508 +563 @@
     pmConceptsInit();
 
-    psTrace("psModules.concepts", 3, "Writing concepts (%p %p %p): %d\n", fpa, chip, cell, source);
-
-    if (source & PM_CONCEPT_SOURCE_CELLS) {
-        p_pmConceptsWriteToCells(*specs, cell, concepts);
-    }
-    if (source & PM_CONCEPT_SOURCE_DEFAULTS) {
-        p_pmConceptsWriteToDefaults(*specs, fpa, chip, cell, concepts);
-    }
-    if (source & (PM_CONCEPT_SOURCE_PHU | PM_CONCEPT_SOURCE_HEADER)) {
-        p_pmConceptsWriteToHeader(*specs, fpa, chip, cell, concepts);
-    }
-    if (source & PM_CONCEPT_SOURCE_DATABASE) {
-        p_pmConceptsWriteToDatabase(*specs, fpa, chip, cell, config, concepts);
-    }
+    psTrace("psModules.concepts", 3, "Writing concepts (%p %p %p)\n", fpa, chip, cell);
+
+    psMetadata *format = conceptsCameraFormat(fpa, chip, cell); // Camera format
+    if (!format) {
+        psError(PS_ERR_UNKNOWN, false, "Unable to retrieve camera format.");
+        return false;
+    }
+
+    psMetadata *defaults = conceptsDefaults(format); // DEFAULTS configuration
+    psMetadata *translation = conceptsTranslation(format); // TRANSLATION configuration
+    psMetadata *database = conceptsDatabase(format); // DATABASE configuration
+
+    psMetadataIterator *iter = psMetadataIteratorAlloc(*specs, PS_LIST_HEAD, NULL); // Iterator
+    psMetadataItem *item = NULL;    // Item from the specs metadata
+    while ((item = psMetadataGetAndIncrement(iter))) {
+        pmConceptSpec *spec = item->data.V; // The specification
+        psString name = item->name; // The concept name
+
+        psMetadataItem *concept = psMetadataLookup(concepts, name); // Concept to write
+
+        if (!p_pmConceptWriteToCells(cell, spec, concept, format) &&
+            !p_pmConceptWriteToDefaults(fpa, chip, cell, spec, concept, format, defaults) &&
+            !p_pmConceptWriteToHeader(fpa, chip, cell, spec, concept, format, translation) &&
+            !p_pmConceptWriteToDatabase(fpa, chip, cell, config, spec, concept, format, database)) {
+            psTrace("psModules.concepts", 1, "Unable to write concept %s to any output", name);
+        }
+    }
+    psFree(iter);
 
     return true;
@@ -527 +596 @@
 
 
-bool pmConceptsWriteFPA(const pmFPA *fpa, pmConceptSource source, bool propagateDown, pmConfig *config)
+bool pmConceptsWriteFPA(const pmFPA *fpa, bool propagateDown, pmConfig *config)
 {
     PS_ASSERT_PTR_NON_NULL(fpa, false);
     psMetadata *conceptsFPA = pmConceptsSpecs(PM_FPA_LEVEL_FPA); // Concept specifications
     psTrace("psModules.concepts", 5, "Writing FPA concepts: %p %p\n", conceptsFPA, fpa->concepts);
-    bool success = conceptsWrite(&conceptsFPA, fpa, NULL, NULL, source, config, fpa->concepts);
+    bool success = conceptsWrite(&conceptsFPA, fpa, NULL, NULL, config, fpa->concepts);
     if (propagateDown) {
         psArray *chips = fpa->chips;        // Array of chips
@@ -538 +607 @@
             pmChip *chip = chips->data[i];  // Chip of interest
             if (chip && !chip->hdu) {
-                success &= pmConceptsWriteChip(chip, source, false, true, config);
+                success &= pmConceptsWriteChip(chip, false, true, config);
             }
         }
@@ -546 +615 @@
 
 
-bool pmConceptsWriteChip(const pmChip *chip, pmConceptSource source, bool propagateUp,
-                         bool propagateDown, pmConfig *config)
+bool pmConceptsWriteChip(const pmChip *chip, bool propagateUp, bool propagateDown, pmConfig *config)
 {
     PS_ASSERT_PTR_NON_NULL(chip, false);
@@ -553 +621 @@
     psTrace("psModules.concepts", 5, "Writing chip concepts: %p %p\n", conceptsChip, chip->concepts);
     pmFPA *fpa = chip->parent;          // FPA to which the chip belongs
-    bool success = conceptsWrite(&conceptsChip, fpa, chip, NULL, source, config, chip->concepts);
+    bool success = conceptsWrite(&conceptsChip, fpa, chip, NULL, config, chip->concepts);
     if (propagateUp && !fpa->hdu) {
         psMetadata *conceptsFPA = pmConceptsSpecs(PM_FPA_LEVEL_FPA); // Concept specifications
-        success &= conceptsWrite(&conceptsFPA, fpa, chip, NULL, source, config, fpa->concepts);
+        success &= conceptsWrite(&conceptsFPA, fpa, chip, NULL, config, fpa->concepts);
     }
     if (propagateDown) {
@@ -563 +631 @@
             pmCell *cell = cells->data[i];  // Cell of interest
             if (cell && !cell->hdu) {
-                success &= pmConceptsWriteCell(cell, source, false, config);
+                success &= pmConceptsWriteCell(cell, false, config);
             }
         }
@@ -571 +639 @@
 
 
-bool pmConceptsWriteCell(const pmCell *cell, pmConceptSource source, bool propagateUp, pmConfig *config)
+bool pmConceptsWriteCell(const pmCell *cell, bool propagateUp, pmConfig *config)
 {
     PS_ASSERT_PTR_NON_NULL(cell, false);
@@ -579 +647 @@
     pmFPA *fpa = chip->parent;          // FPA to which the chip belongs
 
-    bool success = conceptsWrite(&conceptsCell, fpa, chip, cell, source, config, cell->concepts);
+    bool success = conceptsWrite(&conceptsCell, fpa, chip, cell, config, cell->concepts);
     if (propagateUp) {
         if (!chip->hdu) {
             psMetadata *conceptsChip = pmConceptsSpecs(PM_FPA_LEVEL_CHIP); // Concept specifications
-            success &= conceptsWrite(&conceptsChip, fpa, chip, cell, source, config, chip->concepts);
+            success &= conceptsWrite(&conceptsChip, fpa, chip, cell, config, chip->concepts);
             if (!fpa->hdu) {
                 psMetadata *conceptsFPA = pmConceptsSpecs(PM_FPA_LEVEL_FPA); // Concept specifications
-                success &= conceptsWrite(&conceptsFPA, fpa, chip, cell, source, config, fpa->concepts);
+                success &= conceptsWrite(&conceptsFPA, fpa, chip, cell, config, fpa->concepts);
             }
         }