Changeset 23197 for branches/cnb_branches/cnb_branch_20090215/psModules

branches/cnb_branches/cnb_branch_20090215

Property svn:mergeinfo set to
/trunk merged eligible

branches/cnb_branches/cnb_branch_20090215/psModules/src/camera/pmFPAConstruct.c

r21363	r23197
14	14	#include "pmFPAview.h"
15	15	#include "pmFPAFlags.h"
16		#include "pmConcepts.h"
	16	#include "pmConceptsRead.h"
17	17	#include "pmFPAConstruct.h"
18	18	#include "pmFPAUtils.h"

branches/cnb_branches/cnb_branch_20090215/psModules/src/camera/pmFPACopy.c

-              r21536
+              r23197
 #include "pmFPAUtils.h"
 #include "pmHDUUtils.h"
+#include "pmConceptsCopy.h"
 #include "pmFPACopy.h"
 …
     // Update the concepts
     psMetadataItem *chipName = psMemIncrRefCounter(psMetadataLookup(target->concepts, "CHIP.NAME"));
     psMetadataCopy(target->concepts, source->concepts);
+    pmConceptsCopyChip(target, source, false);
     psMetadataAddItem(target->concepts, chipName, PS_LIST_TAIL, PS_META_REPLACE);
     psFree(chipName);
     psMetadataCopy(target->parent->concepts, source->parent->concepts);
+    pmConceptsCopyFPA(target->parent, source->parent, false, false);
     // Update the astrometric parameters
 …
     if (targetFPA && sourceFPA) {
         if (targetFPA->toSky) {
             psAssert (targetFPA->toSky == sourceFPA->toSky, "chips within FPA have inconsistent astrometry references");
         } else {
             targetFPA->toSky = psMemIncrRefCounter (sourceFPA->toSky);
+        }
         if (targetFPA->toTPA) {
             psAssert (targetFPA->toTPA == sourceFPA->toTPA, "chips within FPA have inconsistent astrometry references");
         } else {
             targetFPA->toTPA = psMemIncrRefCounter (sourceFPA->toTPA);
+        }
         if (targetFPA->fromTPA) {
             psAssert (targetFPA->fromTPA == sourceFPA->fromTPA, "chips within FPA have inconsistent astrometry references");
         } else {
             targetFPA->fromTPA = psMemIncrRefCounter (sourceFPA->fromTPA);
+        }
+        if (targetFPA->toSky) {
+            psAssert (targetFPA->toSky == sourceFPA->toSky, "chips within FPA have inconsistent astrometry references");
+        } else {
+            targetFPA->toSky = psMemIncrRefCounter (sourceFPA->toSky);
+        }
+        if (targetFPA->toTPA) {
+            psAssert (targetFPA->toTPA == sourceFPA->toTPA, "chips within FPA have inconsistent astrometry references");
+        } else {
+            targetFPA->toTPA = psMemIncrRefCounter (sourceFPA->toTPA);
+        }
+        if (targetFPA->fromTPA) {
+            psAssert (targetFPA->fromTPA == sourceFPA->fromTPA, "chips within FPA have inconsistent astrometry references");
+        } else {
+            targetFPA->fromTPA = psMemIncrRefCounter (sourceFPA->fromTPA);
+        }
+    }
 …
     // Update the concepts
     psMetadataCopy(targetChip->concepts, sourceChip->concepts);
+    pmConceptsCopyChip(targetChip, sourceChip, false);
     // update the attributes
 …
     // Update the concepts
     psMetadataCopy(target->concepts, source->concepts);
+    pmConceptsCopyFPA(target, source, false, false);
     return status;

branches/cnb_branches/cnb_branch_20090215/psModules/src/camera/pmFPAHeader.c

r18163	r23197
10	10	#include "pmFPA.h"
11	11	#include "pmFPALevel.h"
12		#include "pmConcepts.h"
	12	#include "pmConceptsRead.h"
13	13	#include "pmFPAHeader.h"
14	14

branches/cnb_branches/cnb_branch_20090215/psModules/src/camera/pmFPARead.c

r21363	r23197
17	17	#include "pmFPAFlags.h"
18	18	#include "pmHDUUtils.h"
19		#include "pmConcepts.h"
	19	#include "pmConceptsRead.h"
20	20	#include "pmFPAHeader.h"
21	21

branches/cnb_branches/cnb_branch_20090215/psModules/src/camera/pmFPAWrite.c

r21363	r23197
18	18	#include "pmHDUUtils.h"
19	19	#include "pmHDUGenerate.h"
20		#include "pmConcepts.h"
	20	#include "pmConceptsWrite.h"
21	21
22	22	#include "pmFPAWrite.h"

branches/cnb_branches/cnb_branch_20090215/psModules/src/camera/pmFPAfile.c

-              r21363
+              r23197
 #include "pmFPAfile.h"
 #include "pmFPACopy.h"
 #include "pmConcepts.h"
+#include "pmConceptsCopy.h"
 static void pmFPAfileFree(pmFPAfile *file)
 …
     // XXX this should be smarter (ie, only copy concepts from the current chips)
     // but such a call is needed, so re-copy stuff rather than no copy
     pmFPACopyConcepts (out, in);
+    pmConceptsCopyFPA(out, in, true, true);
     // pmFPAWrite takes care of all PHUs as needed

branches/cnb_branches/cnb_branch_20090215/psModules/src/camera/pmFPAfileDefine.c

-              r21314
+              r23197
 #include "pmFPAConstruct.h"
 #include "pmConcepts.h"
+#include "pmConceptsCopy.h"
 # define FPA_TEST_ASSERT(A){ \
 …
+        }
         // XXX A TEST: this is a provisional fpa until we read the first header for this pmFPAfile
         // we are going to replace it when we determine the true file.  blow this away here...
         psFree (file->fpa);
         file->fpa = NULL;
+        // XXX A TEST: this is a provisional fpa until we read the first header for this pmFPAfile
+        // we are going to replace it when we determine the true file.  blow this away here...
+        psFree (file->fpa);
+        file->fpa = NULL;
+    }
 …
     // inherit the concepts from the src fpa:
     pmFPACopyConcepts(file->fpa, file->src);
+    pmConceptsCopyFPA(file->fpa, file->src, true, true);
     return file;

branches/cnb_branches/cnb_branch_20090215/psModules/src/camera/pmFPAfileFitsIO.c

r21363	r23197
22	22	#include "pmFPAConstruct.h"
23	23	#include "pmDark.h"
24		#include "pmConcepts.h"
	24	#include "pmConceptsWrite.h"
25	25
26	26	// Get a suitable FPA for the file; generate it if necessary

branches/cnb_branches/cnb_branch_20090215/psModules/src/camera/pmHDUUtils.h

-              r18554
+              r23197
 #ifndef PM_HDU_UTILS_H
 #define PM_HDU_UTILS_H
+#include <pmHDU.h>
+#include <pmFPA.h>
 /// @addtogroup Camera Camera Layout

branches/cnb_branches/cnb_branch_20090215/psModules/src/concepts/Makefile.am

-              r11749
+              r23197
         pmConceptsRead.c \
         pmConceptsWrite.c \
+        pmConceptsCopy.c \
         pmConceptsStandard.c \
         pmConceptsPhotcode.c \
 …
         pmConceptsRead.h \
         pmConceptsWrite.h \
+        pmConceptsCopy.h \
         pmConceptsStandard.h \
         pmConceptsPhotcode.h \

branches/cnb_branches/cnb_branch_20090215/psModules/src/concepts/pmConcepts.c

-              r20951
+              r23197
 #include "pmConceptsWrite.h"
 #include "pmConceptsStandard.h"
-#include "pmConceptsUpdate.h"
 static bool conceptsInitialised = false;// Have concepts been read?
 …
 pmConceptSpec *pmConceptSpecAlloc(psMetadataItem *blank, pmConceptParseFunc parse,
+                                  pmConceptFormatFunc format, bool required)
+                                  pmConceptFormatFunc format, pmConceptCopyFunc copy,
+                                  bool required)
+{
     pmConceptSpec *spec = psAlloc(sizeof(pmConceptSpec));
 …
     spec->parse = parse;
     spec->format = format;
+    spec->copy = copy;
     spec->required = required;
 …
+}
+psMetadata *pmConceptsSpecs(pmFPALevel level)
+{
+    if (!conceptsInitialised) {
+        pmConceptsInit();
+    }
+    // Get the appropriate concepts
+    psMetadata *concepts = conceptsFromLevel(level); // Metadata of concepts specs
+    if (!concepts) {
+        psError(PS_ERR_BAD_PARAMETER_VALUE, true, "Invalid concept level provided: %d\n", level);
+        return NULL;
+    }
+    return concepts;
+}
 bool pmConceptGetRequired(const char *name, pmFPALevel level)
+{
 …
 bool pmConceptRegister(psMetadataItem *blank, pmConceptParseFunc parse,
+                        pmConceptFormatFunc format, bool required, pmFPALevel level)
+                       pmConceptFormatFunc format, pmConceptCopyFunc copy,
+                       bool required, pmFPALevel level)
+{
     PS_ASSERT_PTR_NON_NULL(blank, false);
 …
+    }
     pmConceptSpec *spec = pmConceptSpecAlloc(blank, parse, format, required); // The concept specification
+    pmConceptSpec *spec = pmConceptSpecAlloc(blank, parse, format, copy, required); // Concept specification
     psMetadataAdd(target, PS_LIST_TAIL, blank->name, PS_DATA_UNKNOWN | PS_META_REPLACE,
                   "Concepts specification", spec);
 …
-// Read all registered concepts for the specified level
-static bool conceptsRead(psMetadata **specs, // One of the concepts specifications
-                         pmFPA *fpa,    // The FPA
-                         pmChip *chip,  // The chip
-                         pmCell *cell, // The cell
-                         unsigned int *read,     // What's already been read
-                         pmConceptSource source, // The source of the concepts to read
-                         pmConfig *config, // Configuration
-                         psMetadata *target // Place into which to read the concepts
+                        )
+{
-    assert(specs);
-    assert(read);
-    assert(target);
-    if (!conceptsInitialised) {
-        pmConceptsInit();
+    }
-    // At least one HDU is required for the reading functions
-    pmHDU *hduLow = pmHDUGetLowest(fpa, chip, cell); // Lowest HDU.
-    if (!hduLow) {
-        // Can't do anything --- don't record any success, but don't return an error either
-        return true;
+    }
-    pmHDU *hduHigh = pmHDUGetHighest(fpa, chip, cell); // Highest HDU
-    if (cell && (cell->conceptsRead == PM_CONCEPT_SOURCE_NONE)) {
-        pmConceptsBlankCell(cell);
-        cell->conceptsRead = PM_CONCEPT_SOURCE_BLANK;
+    }
-    if (chip && (chip->conceptsRead == PM_CONCEPT_SOURCE_NONE)) {
-        pmConceptsBlankChip(chip);
-        chip->conceptsRead = PM_CONCEPT_SOURCE_BLANK;
+    }
-    if (fpa && (fpa->conceptsRead == PM_CONCEPT_SOURCE_NONE)) {
-        pmConceptsBlankFPA(fpa);
-        fpa->conceptsRead = PM_CONCEPT_SOURCE_BLANK;
+    }
-    bool success = true;                // Success in reading concepts?
-    if (source & PM_CONCEPT_SOURCE_CELLS && !(*read & PM_CONCEPT_SOURCE_CELLS) && cell) {
-        if (p_pmConceptsReadFromCells(target, *specs, cell)) {
-            *read |= PM_CONCEPT_SOURCE_CELLS;
-        } else {
-            psError(PS_ERR_UNKNOWN, false, "Error reading concepts from camera configuration.\n");
-            success = false;
+        }
+    }
-    if (source & PM_CONCEPT_SOURCE_DEFAULTS && !(*read & PM_CONCEPT_SOURCE_DEFAULTS)) {
-        if (p_pmConceptsReadFromDefaults(target, *specs, fpa, chip, cell)) {
-            *read |= PM_CONCEPT_SOURCE_DEFAULTS;
-        } else {
-            psError(PS_ERR_UNKNOWN, false, "Error reading concepts from defaults.\n");
-            success = false;
+        }
+    }
-    if (source & PM_CONCEPT_SOURCE_PHU && !(*read & PM_CONCEPT_SOURCE_PHU) && hduHigh->header) {
-        if (p_pmConceptsReadFromHeader(target, *specs, fpa, chip, cell)) {
-            *read |= PM_CONCEPT_SOURCE_PHU;
-        } else {
-            psError(PS_ERR_UNKNOWN, false, "Error reading concepts from PHU.\n");
-            success = false;
+        }
+    }
-    // If there are multiple HDUs, then it may be that one of them hasn't been read yet (hdu->header not set)
-    if (source & PM_CONCEPT_SOURCE_HEADER && !(*read & PM_CONCEPT_SOURCE_HEADER) &&
-        hduLow != hduHigh && hduLow->header) {
-        if (p_pmConceptsReadFromHeader(target, *specs, fpa, chip, cell)) {
-            *read |= PM_CONCEPT_SOURCE_HEADER;
-        } else {
-            psError(PS_ERR_UNKNOWN, false, "Error reading concepts from header.\n");
-            success = false;
+        }
+    }
-    #ifdef HAVE_PSDB
-    if (source & PM_CONCEPT_SOURCE_DATABASE && !(*read & PM_CONCEPT_SOURCE_DATABASE)) {
-        if (p_pmConceptsReadFromDatabase(target, *specs, fpa, chip, cell, config)) {
-            *read |= PM_CONCEPT_SOURCE_DATABASE;
-        } else {
-            psError(PS_ERR_UNKNOWN, false, "Error reading concepts from database.\n");
-            success = false;
+        }
+    }
-    #endif
-    pmConceptsUpdate(fpa, chip, cell);
-    return success;
+}
-// Write all registered concepts for the specified level
-static bool conceptsWrite(psMetadata **specs, // One of the concepts specifications
-                          const pmFPA *fpa,   // The FPA
-                          const pmChip *chip, // The chip
-                          const pmCell *cell, // The cell
-                          pmConceptSource source, // The source of the concepts to write
-                          pmConfig *config, // Configuration
-                          const psMetadata *concepts // The concepts to write out
+                         )
+{
-    assert(specs);
-    assert(concepts);
-    if (!conceptsInitialised) {
-        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);
+    }
-    return true;
+}
-bool pmConceptsRead(pmFPA *fpa, pmChip *chip, pmCell *cell, pmConceptSource source, pmConfig *config)
+{
-    PS_ASSERT_PTR_NON_NULL(fpa, false);
-    bool success = conceptsRead(&conceptsFPA, fpa, chip, cell, &fpa->conceptsRead, source,
-                                config, fpa->concepts);
-    if (chip) {
-        success &= conceptsRead(&conceptsChip, fpa, chip, cell, &chip->conceptsRead, source,
-                                config, chip->concepts);
+    }
-    if (cell) {
-        success &= conceptsRead(&conceptsCell, fpa, chip, cell, &cell->conceptsRead, source,
-                                config, cell->concepts);
+    }
-    return success;
+}
 bool pmConceptsBlankFPA(pmFPA *fpa)
+{
 …
+}
-bool pmConceptsReadFPA(pmFPA *fpa, pmConceptSource source, bool propagateDown, pmConfig *config)
+{
-    PS_ASSERT_PTR_NON_NULL(fpa, false);
-    psTrace("psModules.concepts", 5, "Reading FPA concepts: %p %p\n", conceptsFPA, fpa->concepts);
-    bool success = conceptsRead(&conceptsFPA, fpa, NULL, NULL, &fpa->conceptsRead, source,
-                                config, fpa->concepts);
-    if (propagateDown) {
-        psArray *chips = fpa->chips;    // Array of chips
-        for (long i = 0; i < chips->n; i++) {
-            pmChip *chip = chips->data[i]; // Chip of interest
-            if (chip) {
-                success &= pmConceptsReadChip(chip, source, false, true, config);
+            }
+        }
+    }
-    return success;
+}
-bool pmConceptsWriteFPA(const pmFPA *fpa, pmConceptSource source, bool propagateDown, pmConfig *config)
+{
-    PS_ASSERT_PTR_NON_NULL(fpa, false);
-    psTrace("psModules.concepts", 5, "Writing FPA concepts: %p %p\n", conceptsFPA, fpa->concepts);
-    bool success = conceptsWrite(&conceptsFPA, fpa, NULL, NULL, source, config, fpa->concepts);
-    if (propagateDown) {
-        psArray *chips = fpa->chips;        // Array of chips
-        for (long i = 0; i < chips->n; i++) {
-            pmChip *chip = chips->data[i];  // Chip of interest
-            if (chip && !chip->hdu) {
-                success &= pmConceptsWriteChip(chip, source, false, true, config);
+            }
+        }
+    }
-    return success;
+}
 bool pmConceptsBlankChip(pmChip *chip)
+{
 …
+}
-bool pmConceptsReadChip(pmChip *chip, pmConceptSource source, bool propagateUp,
-                        bool propagateDown, pmConfig *config)
+{
-    PS_ASSERT_PTR_NON_NULL(chip, false);
-    psTrace("psModules.concepts", 5, "Reading chip concepts: %p %p\n", conceptsChip, chip->concepts);
-    pmFPA *fpa = chip->parent;          // FPA to which the chip belongs
-    bool success = conceptsRead(&conceptsChip, fpa, chip, NULL, &chip->conceptsRead, source, config,
-                                chip->concepts);
-    if (propagateUp) {
-        success &= conceptsRead(&conceptsFPA, fpa, chip, NULL, &fpa->conceptsRead, source,
-                                config, fpa->concepts);
+    }
-    if (propagateDown) {
-        psArray *cells = chip->cells;        // Array of cells
-        for (long i = 0; i < cells->n; i++) {
-            pmCell *cell = cells->data[i];  // Cell of interest
-            if (cell) {
-                success &= pmConceptsReadCell(cell, source, false, config);
+            }
+        }
+    }
-    return success;
+}
-bool pmConceptsWriteChip(const pmChip *chip, pmConceptSource source, bool propagateUp,
-                         bool propagateDown, pmConfig *config)
+{
-    PS_ASSERT_PTR_NON_NULL(chip, false);
-    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);
-    if (propagateUp && !fpa->hdu) {
-        success &= conceptsWrite(&conceptsFPA, fpa, chip, NULL, source, config, fpa->concepts);
+    }
-    if (propagateDown) {
-        psArray *cells = chip->cells;        // Array of cells
-        for (long i = 0; i < cells->n; i++) {
-            pmCell *cell = cells->data[i];  // Cell of interest
-            if (cell && !cell->hdu) {
-                success &= pmConceptsWriteCell(cell, source, false, config);
+            }
+        }
+    }
-    return success;
+}
 bool pmConceptsBlankCell(pmCell *cell)
+{
 …
     psTrace("psModules.concepts", 5, "Blanking cell concepts: %p %p\n", conceptsCell, cell->concepts);
     return conceptsBlank(&conceptsCell, cell->concepts);
+}
-bool pmConceptsReadCell(pmCell *cell, pmConceptSource source, bool propagateUp, pmConfig *config)
+{
-    PS_ASSERT_PTR_NON_NULL(cell, false);
-    psTrace("psModules.concepts", 5, "Reading cell concepts: %p %p\n", conceptsCell, cell->concepts);
-    pmChip *chip = cell->parent;        // Chip to which the cell belongs
-    pmFPA *fpa = chip->parent;          // FPA to which the chip belongs
-    bool success = conceptsRead(&conceptsCell, fpa, chip, cell, &cell->conceptsRead, source, config,
-                                cell->concepts);
-    if (propagateUp) {
-        success &= conceptsRead(&conceptsChip, fpa, chip, cell, &chip->conceptsRead, source, config,
-                                chip->concepts);
-        success &= conceptsRead(&conceptsFPA, fpa, chip, cell, &fpa->conceptsRead, source, config,
-                                fpa->concepts);
+    }
-    return success;
+}
-bool pmConceptsWriteCell(const pmCell *cell, pmConceptSource source, bool propagateUp, pmConfig *config)
+{
-    PS_ASSERT_PTR_NON_NULL(cell, false);
-    psTrace("psModules.concepts", 5, "Writing cell concepts: %p %p\n", conceptsCell, cell->concepts);
-    pmChip *chip = cell->parent;        // Chip to which the cell belongs
-    pmFPA *fpa = chip->parent;          // FPA to which the chip belongs
-    bool success = conceptsWrite(&conceptsCell, fpa, chip, cell, source, config, cell->concepts);
-    if (propagateUp) {
-        if (!chip->hdu) {
-            success &= conceptsWrite(&conceptsChip, fpa, chip, cell, source, config, chip->concepts);
-            if (!fpa->hdu) {
-                success &= conceptsWrite(&conceptsFPA, fpa, chip, cell, source, config, fpa->concepts);
+            }
+        }
+    }
-    return success;
+}
 …
 static void conceptRegister##SUFFIX(const char *name, /* Name of concept */ \
                                     const char *comment, /* Comment for concept */ \
+                                    pmConceptParseFunc parse, /* Parsing function */ \
+                                    pmConceptFormatFunc format, /* Formatting function */ \
+                                    pmConceptParseFunc parse, /* Parsing function, or NULL */ \
+                                    pmConceptFormatFunc format, /* Formatting function, or NULL */ \
+                                    pmConceptCopyFunc copy, /* Copying function, or NULL */ \
                                     bool required, /* Required concept? */ \
                                     pmFPALevel level /* Level at which concept applies */ \
 …
 { \
     psMetadataItem *item = psMetadataItemAlloc##TYPENAME(name, comment, DEFAULT); /* Item to add */ \
     pmConceptRegister(item, parse, format, required, level); \
+    pmConceptRegister(item, parse, format, copy, required, level); \
     psFree(item); \
     return; \
 …
     psMetadataItem *item = psMetadataItemAlloc(name, PS_DATA_TIME, comment, time);
     psFree(time);
     pmConceptRegister(item, p_pmConceptParse_TIME, p_pmConceptFormat_TIME, required, level);
+    pmConceptRegister(item, p_pmConceptParse_TIME, p_pmConceptFormat_TIME, NULL, required, level);
     psFree(item);
+}
 …
 bool pmConceptsInit(void)
+{
+    if (conceptsInitialised) {
+        return true;
+    }
     conceptsInitialised = true;
 …
     bool init = false;                  // Did we initialise anything?
     if (! conceptsFPA) {
+    if (!conceptsFPA) {
         conceptsFPA = psMetadataAlloc();
         init = true;
         // Install the standard concepts
         conceptRegisterStr("FPA.TELESCOPE", "Telescope of origin", NULL, NULL, false, PM_FPA_LEVEL_FPA);
         conceptRegisterStr("FPA.INSTRUMENT", "Instrument name (according to the instrument)", NULL, NULL, false, PM_FPA_LEVEL_FPA);
         conceptRegisterStr("FPA.DETECTOR", "Detector name", NULL, NULL, false, PM_FPA_LEVEL_FPA);
         conceptRegisterStr("FPA.COMMENT", "Observation comment", NULL, NULL, false, PM_FPA_LEVEL_FPA);
         conceptRegisterStr("FPA.OBS.MODE", "Observation mode (eg, survey id)", NULL, NULL, false, PM_FPA_LEVEL_FPA);
         conceptRegisterStr("FPA.OBS.GROUP", "Observation group (eg, associated images)", NULL, NULL, false, PM_FPA_LEVEL_FPA);
         conceptRegisterF32("FPA.FOCUS", "Telescope focus", NULL, NULL, false, PM_FPA_LEVEL_FPA);
         conceptRegisterF32("FPA.AIRMASS", "Airmass at boresight", NULL, NULL, false, PM_FPA_LEVEL_FPA);
         conceptRegisterStr("FPA.FILTERID", "Filter used (parsed, abstract name)", p_pmConceptParse_FPA_FILTER, p_pmConceptFormat_FPA_FILTER, false, PM_FPA_LEVEL_FPA);
         conceptRegisterStr("FPA.FILTER", "Filter used (instrument name)", false, NULL, NULL, PM_FPA_LEVEL_FPA);
         conceptRegisterF32("FPA.POSANGLE", "Position angle of instrument", NULL, NULL, false, PM_FPA_LEVEL_FPA);
         conceptRegisterF32("FPA.ROTANGLE", "Rotator angle of instrument", NULL, NULL, false, PM_FPA_LEVEL_FPA);
         conceptRegisterStr("FPA.RADECSYS", "Celestial coordinate system", NULL, NULL, false, PM_FPA_LEVEL_FPA);
         conceptRegisterF64("FPA.RA", "Right Ascension of boresight", p_pmConceptParse_FPA_Coords, p_pmConceptFormat_FPA_Coords, false, PM_FPA_LEVEL_FPA);
         conceptRegisterF64("FPA.DEC", "Declination of boresight", p_pmConceptParse_FPA_Coords, p_pmConceptFormat_FPA_Coords, false, PM_FPA_LEVEL_FPA);
         conceptRegisterF64("FPA.LONGITUDE", "West longitude of observatory", p_pmConceptParse_FPA_Coords, p_pmConceptFormat_FPA_Coords, false, PM_FPA_LEVEL_FPA);
         conceptRegisterF64("FPA.LATITUDE", "Latitude of observatory", p_pmConceptParse_FPA_Coords, p_pmConceptFormat_FPA_Coords, false, PM_FPA_LEVEL_FPA);
         conceptRegisterF32("FPA.ELEVATION", "Elevation of observatory (metres)", NULL, NULL, false, PM_FPA_LEVEL_FPA);
         conceptRegisterStr("FPA.OBSTYPE", "Type of observation", NULL, NULL, false, PM_FPA_LEVEL_FPA);
         conceptRegisterStr("FPA.OBJECT", "Object of observation", NULL, NULL, false, PM_FPA_LEVEL_FPA);
         conceptRegisterF64("FPA.ALT", "Altitude of boresight", NULL, NULL, false, PM_FPA_LEVEL_FPA);
         conceptRegisterF64("FPA.AZ", "Azimuth of boresight", NULL, NULL, false, PM_FPA_LEVEL_FPA);
         conceptRegisterEnum("FPA.TIMESYS", "Time system", p_pmConceptParse_TIMESYS, p_pmConceptFormat_TIMESYS, false, PM_FPA_LEVEL_FPA);
+        conceptRegisterStr("FPA.TELESCOPE", "Telescope of origin", NULL, NULL, NULL, false, PM_FPA_LEVEL_FPA);
+        conceptRegisterStr("FPA.INSTRUMENT", "Instrument name (according to the instrument)", NULL, NULL, NULL, false, PM_FPA_LEVEL_FPA);
+        conceptRegisterStr("FPA.DETECTOR", "Detector name", NULL, NULL, NULL, false, PM_FPA_LEVEL_FPA);
+        conceptRegisterStr("FPA.COMMENT", "Observation comment", NULL, NULL, NULL, false, PM_FPA_LEVEL_FPA);
+        conceptRegisterStr("FPA.OBS.MODE", "Observation mode (eg, survey id)", NULL, NULL, NULL, false, PM_FPA_LEVEL_FPA);
+        conceptRegisterStr("FPA.OBS.GROUP", "Observation group (eg, associated images)", NULL, NULL, NULL, false, PM_FPA_LEVEL_FPA);
+        conceptRegisterF32("FPA.FOCUS", "Telescope focus", NULL, NULL, NULL, false, PM_FPA_LEVEL_FPA);
+        conceptRegisterF32("FPA.AIRMASS", "Airmass at boresight", NULL, NULL, NULL, false, PM_FPA_LEVEL_FPA);
+        conceptRegisterStr("FPA.FILTERID", "Filter used (parsed, abstract name)", p_pmConceptParse_FPA_FILTER, p_pmConceptFormat_FPA_FILTER, NULL, false, PM_FPA_LEVEL_FPA);
+        conceptRegisterStr("FPA.FILTER", "Filter used (instrument name)", NULL, NULL, NULL, false, PM_FPA_LEVEL_FPA);
+        conceptRegisterF32("FPA.POSANGLE", "Position angle of instrument", NULL, NULL, NULL, false, PM_FPA_LEVEL_FPA);
+        conceptRegisterF32("FPA.ROTANGLE", "Rotator angle of instrument", NULL, NULL, NULL, false, PM_FPA_LEVEL_FPA);
+        conceptRegisterStr("FPA.RADECSYS", "Celestial coordinate system", NULL, NULL, NULL, false, PM_FPA_LEVEL_FPA);
+        conceptRegisterF64("FPA.RA", "Right Ascension of boresight", p_pmConceptParse_FPA_Coords, p_pmConceptFormat_FPA_Coords, NULL, false, PM_FPA_LEVEL_FPA);
+        conceptRegisterF64("FPA.DEC", "Declination of boresight", p_pmConceptParse_FPA_Coords, p_pmConceptFormat_FPA_Coords, NULL, false, PM_FPA_LEVEL_FPA);
+        conceptRegisterF64("FPA.LONGITUDE", "West longitude of observatory", p_pmConceptParse_FPA_Coords, p_pmConceptFormat_FPA_Coords, NULL, false, PM_FPA_LEVEL_FPA);
+        conceptRegisterF64("FPA.LATITUDE", "Latitude of observatory", p_pmConceptParse_FPA_Coords, p_pmConceptFormat_FPA_Coords, NULL, false, PM_FPA_LEVEL_FPA);
+        conceptRegisterF32("FPA.ELEVATION", "Elevation of observatory (metres)", NULL, NULL, NULL, false, PM_FPA_LEVEL_FPA);
+        conceptRegisterStr("FPA.OBSTYPE", "Type of observation", NULL, NULL, NULL, false, PM_FPA_LEVEL_FPA);
+        conceptRegisterStr("FPA.OBJECT", "Object of observation", NULL, NULL, NULL, false, PM_FPA_LEVEL_FPA);
+        conceptRegisterF64("FPA.ALT", "Altitude of boresight", NULL, NULL, NULL, false, PM_FPA_LEVEL_FPA);
+        conceptRegisterF64("FPA.AZ", "Azimuth of boresight", NULL, NULL, NULL, false, PM_FPA_LEVEL_FPA);
+        conceptRegisterEnum("FPA.TIMESYS", "Time system", p_pmConceptParse_TIMESYS, p_pmConceptFormat_TIMESYS, p_pmConceptCopy_TIMESYS, false, PM_FPA_LEVEL_FPA);
         conceptRegisterTime("FPA.TIME", "Time of exposure", false, PM_FPA_LEVEL_FPA);
         conceptRegisterF32("FPA.TEMP", "Temperature of focal plane", NULL, NULL, false, PM_FPA_LEVEL_FPA);
         conceptRegisterF32("FPA.M1X", "Primary Mirror X Position", NULL, NULL, false, PM_FPA_LEVEL_FPA);
         conceptRegisterF32("FPA.M1Y", "Primary Mirror Y Position", NULL, NULL, false, PM_FPA_LEVEL_FPA);
         conceptRegisterF32("FPA.M1Z", "Primary Mirror Z Position", NULL, NULL, false, PM_FPA_LEVEL_FPA);
         conceptRegisterF32("FPA.M1TIP", "Primary Mirror TIP", NULL, NULL, false, PM_FPA_LEVEL_FPA);
         conceptRegisterF32("FPA.M1TILT", "Primary Mirror TILT", NULL, NULL, false, PM_FPA_LEVEL_FPA);
         conceptRegisterF32("FPA.M2X", "Primary Mirror X Position", NULL, NULL, false, PM_FPA_LEVEL_FPA);
         conceptRegisterF32("FPA.M2Y", "Primary Mirror Y Position", NULL, NULL, false, PM_FPA_LEVEL_FPA);
         conceptRegisterF32("FPA.M2Z", "Primary Mirror Z Position", NULL, NULL, false, PM_FPA_LEVEL_FPA);
         conceptRegisterF32("FPA.M2TIP", "Primary Mirror TIP", NULL, NULL, false, PM_FPA_LEVEL_FPA);
         conceptRegisterF32("FPA.M2TILT", "Primary Mirror TILT", NULL, NULL, false, PM_FPA_LEVEL_FPA);
         conceptRegisterF32("FPA.ENV.TEMP", "Environment: Temperature", NULL, NULL, false, PM_FPA_LEVEL_FPA);
         conceptRegisterF32("FPA.ENV.HUMID", "Environment: Humidity", NULL, NULL, false, PM_FPA_LEVEL_FPA);
         conceptRegisterF32("FPA.ENV.WIND", "Environment: Wind speed", NULL, NULL, false, PM_FPA_LEVEL_FPA);
         conceptRegisterF32("FPA.ENV.DIR", "Environment: Wind direction", NULL, NULL, false, PM_FPA_LEVEL_FPA);
         conceptRegisterF32("FPA.TELTEMP.M1", "Telescope Temperatures: M1", p_pmConceptParse_TELTEMPS, NULL, false, PM_FPA_LEVEL_FPA);
         conceptRegisterF32("FPA.TELTEMP.M1CELL", "Telescope Temperatures: M1 cell", p_pmConceptParse_TELTEMPS, NULL, false, PM_FPA_LEVEL_FPA);
         conceptRegisterF32("FPA.TELTEMP.M2", "Telescope Temperatures: M2", p_pmConceptParse_TELTEMPS, NULL, false, PM_FPA_LEVEL_FPA);
         conceptRegisterF32("FPA.TELTEMP.SPIDER", "Telescope Temperatures: spider", p_pmConceptParse_TELTEMPS, NULL, false, PM_FPA_LEVEL_FPA);
         conceptRegisterF32("FPA.TELTEMP.TRUSS", "Telescope Temperatures: truss", p_pmConceptParse_TELTEMPS, NULL, false, PM_FPA_LEVEL_FPA);
         conceptRegisterF32("FPA.TELTEMP.EXTRA", "Telescope Temperatures: extra", p_pmConceptParse_TELTEMPS, NULL, false, PM_FPA_LEVEL_FPA);
         conceptRegisterF32("FPA.PON.TIME", "Power On Time", NULL, NULL, false, PM_FPA_LEVEL_FPA);
         conceptRegisterF32("FPA.EXPOSURE", "Exposure time (sec)", NULL, NULL, false, PM_FPA_LEVEL_FPA);
+    }
     if (! conceptsChip) {
+        conceptRegisterF32("FPA.TEMP", "Temperature of focal plane", NULL, NULL, NULL, false, PM_FPA_LEVEL_FPA);
+        conceptRegisterF32("FPA.M1X", "Primary Mirror X Position", NULL, NULL, NULL, false, PM_FPA_LEVEL_FPA);
+        conceptRegisterF32("FPA.M1Y", "Primary Mirror Y Position", NULL, NULL, NULL, false, PM_FPA_LEVEL_FPA);
+        conceptRegisterF32("FPA.M1Z", "Primary Mirror Z Position", NULL, NULL, NULL, false, PM_FPA_LEVEL_FPA);
+        conceptRegisterF32("FPA.M1TIP", "Primary Mirror TIP", NULL, NULL, NULL, false, PM_FPA_LEVEL_FPA);
+        conceptRegisterF32("FPA.M1TILT", "Primary Mirror TILT", NULL, NULL, NULL, false, PM_FPA_LEVEL_FPA);
+        conceptRegisterF32("FPA.M2X", "Primary Mirror X Position", NULL, NULL, NULL, false, PM_FPA_LEVEL_FPA);
+        conceptRegisterF32("FPA.M2Y", "Primary Mirror Y Position", NULL, NULL, NULL, false, PM_FPA_LEVEL_FPA);
+        conceptRegisterF32("FPA.M2Z", "Primary Mirror Z Position", NULL, NULL, NULL, false, PM_FPA_LEVEL_FPA);
+        conceptRegisterF32("FPA.M2TIP", "Primary Mirror TIP", NULL, NULL, NULL, false, PM_FPA_LEVEL_FPA);
+        conceptRegisterF32("FPA.M2TILT", "Primary Mirror TILT", NULL, NULL, NULL, false, PM_FPA_LEVEL_FPA);
+        conceptRegisterF32("FPA.ENV.TEMP", "Environment: Temperature", NULL, NULL, NULL, false, PM_FPA_LEVEL_FPA);
+        conceptRegisterF32("FPA.ENV.HUMID", "Environment: Humidity", NULL, NULL, NULL, false, PM_FPA_LEVEL_FPA);
+        conceptRegisterF32("FPA.ENV.WIND", "Environment: Wind speed", NULL, NULL, NULL, false, PM_FPA_LEVEL_FPA);
+        conceptRegisterF32("FPA.ENV.DIR", "Environment: Wind direction", NULL, NULL, NULL, false, PM_FPA_LEVEL_FPA);
+        conceptRegisterF32("FPA.TELTEMP.M1", "Telescope Temperatures: M1", p_pmConceptParse_TELTEMPS, NULL, NULL, false, PM_FPA_LEVEL_FPA);
+        conceptRegisterF32("FPA.TELTEMP.M1CELL", "Telescope Temperatures: M1 cell", p_pmConceptParse_TELTEMPS, NULL, NULL, false, PM_FPA_LEVEL_FPA);
+        conceptRegisterF32("FPA.TELTEMP.M2", "Telescope Temperatures: M2", p_pmConceptParse_TELTEMPS, NULL, NULL, false, PM_FPA_LEVEL_FPA);
+        conceptRegisterF32("FPA.TELTEMP.SPIDER", "Telescope Temperatures: spider", p_pmConceptParse_TELTEMPS, NULL, NULL, false, PM_FPA_LEVEL_FPA);
+        conceptRegisterF32("FPA.TELTEMP.TRUSS", "Telescope Temperatures: truss", p_pmConceptParse_TELTEMPS, NULL, NULL, false, PM_FPA_LEVEL_FPA);
+        conceptRegisterF32("FPA.TELTEMP.EXTRA", "Telescope Temperatures: extra", p_pmConceptParse_TELTEMPS, NULL, NULL, false, PM_FPA_LEVEL_FPA);
+        conceptRegisterF32("FPA.PON.TIME", "Power On Time", NULL, NULL, NULL, false, PM_FPA_LEVEL_FPA);
+        conceptRegisterF32("FPA.EXPOSURE", "Exposure time (sec)", NULL, NULL, NULL, false, PM_FPA_LEVEL_FPA);
+    }
+    if (!conceptsChip) {
         conceptsChip = psMetadataAlloc();
         init = true;
         // Install the standard concepts
         conceptRegisterS32("CHIP.XPARITY", "Orientation in x compared to the rest of the FPA", NULL, NULL, true, PM_FPA_LEVEL_CHIP);
         conceptRegisterS32("CHIP.YPARITY", "Orientation in y compared to the rest of the FPA", NULL, NULL, true, PM_FPA_LEVEL_CHIP);
         conceptRegisterS32("CHIP.X0", "Position of (0,0) on the FPA",p_pmConceptParse_Positions,p_pmConceptFormat_Positions, true, PM_FPA_LEVEL_CHIP);
         conceptRegisterS32("CHIP.Y0", "Position of (0,0) on the FPA",p_pmConceptParse_Positions,p_pmConceptFormat_Positions, true, PM_FPA_LEVEL_CHIP);
         conceptRegisterS32("CHIP.XSIZE", "Size of chip (pixels)", NULL, NULL, true, PM_FPA_LEVEL_CHIP);
         conceptRegisterS32("CHIP.YSIZE", "Size of chip (pixels)", NULL, NULL, true, PM_FPA_LEVEL_CHIP);
         conceptRegisterF32("CHIP.TEMP", "Temperature of chip", NULL, NULL, false, PM_FPA_LEVEL_CHIP);
         conceptRegisterStr("CHIP.ID", "Chip identifier", NULL, NULL, false, PM_FPA_LEVEL_CHIP);
+    }
     if (! conceptsCell) {
+        conceptRegisterS32("CHIP.XPARITY", "Orientation in x compared to the rest of the FPA", NULL, NULL, NULL, true, PM_FPA_LEVEL_CHIP);
+        conceptRegisterS32("CHIP.YPARITY", "Orientation in y compared to the rest of the FPA", NULL, NULL, NULL, true, PM_FPA_LEVEL_CHIP);
+        conceptRegisterS32("CHIP.X0", "Position of (0,0) on the FPA",p_pmConceptParse_Positions,p_pmConceptFormat_Positions, NULL, true, PM_FPA_LEVEL_CHIP);
+        conceptRegisterS32("CHIP.Y0", "Position of (0,0) on the FPA",p_pmConceptParse_Positions,p_pmConceptFormat_Positions, NULL, true, PM_FPA_LEVEL_CHIP);
+        conceptRegisterS32("CHIP.XSIZE", "Size of chip (pixels)", NULL, NULL, NULL, true, PM_FPA_LEVEL_CHIP);
+        conceptRegisterS32("CHIP.YSIZE", "Size of chip (pixels)", NULL, NULL, NULL, true, PM_FPA_LEVEL_CHIP);
+        conceptRegisterF32("CHIP.TEMP", "Temperature of chip", NULL, NULL, NULL, false, PM_FPA_LEVEL_CHIP);
+        conceptRegisterStr("CHIP.ID", "Chip identifier", NULL, NULL, NULL, false, PM_FPA_LEVEL_CHIP);
+    }
+    if (!conceptsCell) {
         conceptsCell = psMetadataAlloc();
         init = true;
         // Install the standard concepts
         conceptRegisterF32("CELL.GAIN", "CCD gain (e/count)", NULL, NULL, true, PM_FPA_LEVEL_CELL);
         conceptRegisterF32("CELL.READNOISE", "CCD read noise (e)", p_pmConceptParse_CELL_READNOISE, p_pmConceptFormat_CELL_READNOISE, true, PM_FPA_LEVEL_CELL);
         conceptRegisterF32("CELL.SATURATION", "Saturation level (counts)", NULL, NULL, true, PM_FPA_LEVEL_CELL);
         conceptRegisterF32("CELL.BAD", "Bad level (counts)", NULL, NULL, true, PM_FPA_LEVEL_CELL);
         conceptRegisterS32("CELL.XPARITY", "Orientation in x compared to the rest of the chip", NULL, NULL, true, PM_FPA_LEVEL_CELL);
         conceptRegisterS32("CELL.YPARITY", "Orientation in y compared to the rest of the chip", NULL, NULL, true, PM_FPA_LEVEL_CELL);
         conceptRegisterS32("CELL.READDIR", "Read direction, rows=1, cols=2", NULL, NULL, true, PM_FPA_LEVEL_CELL);
+        conceptRegisterF32("CELL.GAIN", "CCD gain (e/count)", NULL, NULL, NULL, true, PM_FPA_LEVEL_CELL);
+        conceptRegisterF32("CELL.READNOISE", "CCD read noise (e)", p_pmConceptParse_CELL_READNOISE, p_pmConceptFormat_CELL_READNOISE, NULL, true, PM_FPA_LEVEL_CELL);
+        conceptRegisterF32("CELL.SATURATION", "Saturation level (counts)", NULL, NULL, NULL, true, PM_FPA_LEVEL_CELL);
+        conceptRegisterF32("CELL.BAD", "Bad level (counts)", NULL, NULL, NULL, true, PM_FPA_LEVEL_CELL);
+        conceptRegisterS32("CELL.XPARITY", "Orientation in x compared to the rest of the chip", NULL, NULL, NULL, true, PM_FPA_LEVEL_CELL);
+        conceptRegisterS32("CELL.YPARITY", "Orientation in y compared to the rest of the chip", NULL, NULL, NULL, true, PM_FPA_LEVEL_CELL);
+        conceptRegisterS32("CELL.READDIR", "Read direction, rows=1, cols=2", NULL, NULL, NULL, true, PM_FPA_LEVEL_CELL);
         // These (CELL.EXPOSURE and CELL.DARKTIME) used to be READOUT.EXPOSURE and READOUT.DARKTIME, but that
 …
         // readout is a plane in a 3D image.  We'll have to dream up some additional suffix to specify these,
         // but for now....
         conceptRegisterF32("CELL.EXPOSURE", "Exposure time (sec)", NULL, NULL, false, PM_FPA_LEVEL_CELL);
         conceptRegisterF32("CELL.DARKTIME", "Time since flush (sec)", NULL, NULL, false, PM_FPA_LEVEL_CELL);
         conceptRegisterS32("CELL.XBIN", "Binning in x", p_pmConceptParse_CELL_Binning,p_pmConceptFormat_CELL_XBIN, true, PM_FPA_LEVEL_CELL);
         conceptRegisterS32("CELL.YBIN", "Binning in y",p_pmConceptParse_CELL_Binning,p_pmConceptFormat_CELL_YBIN, true, PM_FPA_LEVEL_CELL);
         conceptRegisterEnum("CELL.TIMESYS", "Time system", p_pmConceptParse_TIMESYS,p_pmConceptFormat_TIMESYS, false, PM_FPA_LEVEL_CELL);
+        conceptRegisterF32("CELL.EXPOSURE", "Exposure time (sec)", NULL, NULL, NULL, false, PM_FPA_LEVEL_CELL);
+        conceptRegisterF32("CELL.DARKTIME", "Time since flush (sec)", NULL, NULL, NULL, false, PM_FPA_LEVEL_CELL);
+        conceptRegisterS32("CELL.XBIN", "Binning in x", p_pmConceptParse_CELL_Binning,p_pmConceptFormat_CELL_XBIN, NULL, true, PM_FPA_LEVEL_CELL);
+        conceptRegisterS32("CELL.YBIN", "Binning in y",p_pmConceptParse_CELL_Binning,p_pmConceptFormat_CELL_YBIN, NULL, true, PM_FPA_LEVEL_CELL);
+        conceptRegisterEnum("CELL.TIMESYS", "Time system", p_pmConceptParse_TIMESYS,p_pmConceptFormat_TIMESYS, p_pmConceptCopy_TIMESYS, false, PM_FPA_LEVEL_CELL);
         conceptRegisterTime("CELL.TIME", "Time of exposure", false, PM_FPA_LEVEL_CELL);
         conceptRegisterS32("CELL.X0", "Position of (0,0) on the chip",p_pmConceptParse_Positions,p_pmConceptFormat_Positions, true, PM_FPA_LEVEL_CELL);
         conceptRegisterS32("CELL.Y0", "Position of (0,0) on the chip",p_pmConceptParse_Positions,p_pmConceptFormat_Positions, true, PM_FPA_LEVEL_CELL);
         conceptRegisterS32("CELL.XSIZE", "Size of cell (pixels)", NULL, NULL, true, PM_FPA_LEVEL_CELL);
         conceptRegisterS32("CELL.YSIZE", "Size of cell (pixels)", NULL, NULL, true, PM_FPA_LEVEL_CELL);
         conceptRegisterS32("CELL.XWINDOW", "Start of cell window (pixels)",p_pmConceptParse_Positions,p_pmConceptFormat_Positions, true, PM_FPA_LEVEL_CELL);
         conceptRegisterS32("CELL.YWINDOW", "Start of cell window (pixels)",p_pmConceptParse_Positions,p_pmConceptFormat_Positions, true, PM_FPA_LEVEL_CELL);
         conceptRegisterF32("CELL.VARFACTOR", "Variance factor for conversion from large to small scales", NULL, NULL, true, PM_FPA_LEVEL_CELL);
+        conceptRegisterS32("CELL.X0", "Position of (0,0) on the chip",p_pmConceptParse_Positions,p_pmConceptFormat_Positions, NULL, true, PM_FPA_LEVEL_CELL);
+        conceptRegisterS32("CELL.Y0", "Position of (0,0) on the chip",p_pmConceptParse_Positions,p_pmConceptFormat_Positions, NULL, true, PM_FPA_LEVEL_CELL);
+        conceptRegisterS32("CELL.XSIZE", "Size of cell (pixels)", NULL, NULL, NULL, true, PM_FPA_LEVEL_CELL);
+        conceptRegisterS32("CELL.YSIZE", "Size of cell (pixels)", NULL, NULL, NULL, true, PM_FPA_LEVEL_CELL);
+        conceptRegisterS32("CELL.XWINDOW", "Start of cell window (pixels)",p_pmConceptParse_Positions,p_pmConceptFormat_Positions, NULL, true, PM_FPA_LEVEL_CELL);
+        conceptRegisterS32("CELL.YWINDOW", "Start of cell window (pixels)",p_pmConceptParse_Positions,p_pmConceptFormat_Positions, NULL, true, PM_FPA_LEVEL_CELL);
+        conceptRegisterF32("CELL.VARFACTOR", "Variance factor for conversion from large to small scales", NULL, NULL, NULL, true, PM_FPA_LEVEL_CELL);
         // CELL.TRIMSEC
 …
                                           "Trim section", trimsec);
             psFree(trimsec);
             pmConceptRegister(cellTrimsec, p_pmConceptParse_CELL_TRIMSEC,p_pmConceptFormat_CELL_TRIMSEC, true, PM_FPA_LEVEL_CELL);
+            pmConceptRegister(cellTrimsec, p_pmConceptParse_CELL_TRIMSEC,p_pmConceptFormat_CELL_TRIMSEC, NULL, true, PM_FPA_LEVEL_CELL);
             psFree(cellTrimsec);
+        }
 …
                                           "Bias sections", biassecs);
             psFree(biassecs);
             pmConceptRegister(cellBiassec, p_pmConceptParse_CELL_BIASSEC, p_pmConceptFormat_CELL_BIASSEC, true, PM_FPA_LEVEL_CELL);
+            pmConceptRegister(cellBiassec, p_pmConceptParse_CELL_BIASSEC, p_pmConceptFormat_CELL_BIASSEC, NULL, true, PM_FPA_LEVEL_CELL);
             psFree(cellBiassec);
+        }
 …
     conceptsInitialised = false;
+}
-// List of concepts not to copy, for each level.
-// Must be NULL-terminated
-static const char *dontCopyConceptsFPA[] = { "FPA.OBS", "FPA.NAME", "FPA.CAMERA", 0 };
-static const char *dontCopyConceptsChip[] = { "CHIP.NAME", 0 };
-static const char *dontCopyConceptsCell[] = { "CELL.NAME", "CELL.TRIMSEC", "CELL.BIASSEC", 0 };
-// Copy concepts from a source container to a target container, avoiding certain entries
-static void copyConcepts(psMetadata *target, // Target metadata container
-                         psMetadata *source, // Source metadata container
-                         const char *dontCopyConcepts[] // Don't copy these concepts
+                         )
+{
-    assert(target);
-    assert(source);
-    assert(dontCopyConcepts);
-    psMetadataIterator *iter = psMetadataIteratorAlloc(source, PS_LIST_HEAD, NULL);
-    psMetadataItem *item;               // Item from iteration
-    while ((item = psMetadataGetAndIncrement(iter))) {
-        const char *name = item->name;  // Name of concept
-        bool copyOK = true;            // OK to copy
-        for (int i = 0; dontCopyConcepts[i] && copyOK; i++) {
-            if (!strcmp(name, dontCopyConcepts[i])) {
-                copyOK = false;
+            }
+        }
-        if (!copyOK) {
-            continue;
+        }
-        psMetadataItem *new = psMetadataItemCopy(item); // New item, a copy of the old
-        psMetadataAddItem(target, new, PS_LIST_TAIL, PS_META_REPLACE);
-        psFree(new);                    // Drop reference
+    }
-    psFree(iter);
-    return;
+}
-bool pmFPACopyConcepts(pmFPA *target, const pmFPA *source)
+{
-    PS_ASSERT_PTR_NON_NULL(target, false);
-    PS_ASSERT_PTR_NON_NULL(source, false);
-    // Copy FPA concepts
-    copyConcepts(target->concepts, source->concepts, dontCopyConceptsFPA);
-    // Copy chip concepts
-    psArray *targetChips = target->chips; // Chips in target
-    psArray *sourceChips = source->chips; // Chips in source
-    if (targetChips->n != sourceChips->n) {
-        psError(PS_ERR_IO, true, "Number of chips in target (%ld) and source (%ld) differ --- unable to copy "
-                "concepts.\n", targetChips->n, sourceChips->n);
-        return false;
+    }
-    for (int i = 0; i < targetChips->n; i++) {
-        pmChip *targetChip = targetChips->data[i]; // Target chip of interest
-        pmChip *sourceChip = sourceChips->data[i]; // Source chip of interest
-        if (! targetChip || ! sourceChip) {
-            continue;
+        }
-        copyConcepts(targetChip->concepts, sourceChip->concepts, dontCopyConceptsChip);
-        // Copy cell concepts
-        psArray *targetCells = targetChip->cells; // Cells in target
-        psArray *sourceCells = sourceChip->cells; // Cells in source
-        if (targetCells->n != sourceCells->n) {
-            psError(PS_ERR_IO, true, "Number of cells in target (%ld) and source (%ld) differ for chip %d ---"
-                    " unable to copy concepts.\n", targetCells->n, sourceCells->n, i);
-            return false;
+        }
-        for (int j = 0; j < targetCells->n; j++) {
-            pmCell *targetCell = targetCells->data[j]; // Target chip of interest
-            pmCell *sourceCell = sourceCells->data[j]; // Source chip of interest
-            if (! targetCell || ! sourceCell) {
-                continue;
+            }
-            copyConcepts(targetCell->concepts, sourceCell->concepts, dontCopyConceptsCell);
+        }
+    }
-    return true;
+}
-bool pmConceptsCopyFPA(pmFPA *target, const pmFPA *source, bool chips, bool cells)
+{
-    PS_ASSERT_PTR_NON_NULL(target, false);
-    PS_ASSERT_PTR_NON_NULL(source, false);
-    // Copy FPA concepts
-    copyConcepts(target->concepts, source->concepts, dontCopyConceptsFPA);
-    // Copy chip concepts
-    bool status = true;                 // Status of chips
-    if (chips) {
-        psArray *targetChips = target->chips; // Chips in target
-        psArray *sourceChips = source->chips; // Chips in source
-        if (targetChips->n != sourceChips->n) {
-            psError(PS_ERR_IO, true,
-                    "Number of chips in target (%ld) and source (%ld) differ --- unable to copy concepts.",
-                    targetChips->n, sourceChips->n);
-            return false;
+        }
-        for (int i = 0; i < targetChips->n; i++) {
-            pmChip *targetChip = targetChips->data[i]; // Target chip of interest
-            pmChip *sourceChip = sourceChips->data[i]; // Source chip of interest
-            if (! targetChip || ! sourceChip) {
-                continue;
+            }
-            status &= pmConceptsCopyChip(targetChip, sourceChip, cells);
+        }
+    }
-    return status;
+}
-bool pmConceptsCopyChip(pmChip *target, const pmChip *source, bool cells)
+{
-    PS_ASSERT_PTR_NON_NULL(target, false);
-    PS_ASSERT_PTR_NON_NULL(source, false);
-    // Copy chip concepts
-    copyConcepts(target->concepts, source->concepts, dontCopyConceptsChip);
-    // Copy cell concepts
-    bool status = true;                 // Status of cells
-    if (cells) {
-        psArray *targetCells = target->cells; // Cells in target
-        psArray *sourceCells = source->cells; // Cells in source
-        if (targetCells->n != sourceCells->n) {
-            psError(PS_ERR_IO, true,
-                    "Number of cells in target (%ld) and source (%ld) differ --- unable to copy concepts.",
-                    targetCells->n, sourceCells->n);
-            return false;
+        }
-        for (int j = 0; j < targetCells->n; j++) {
-            pmCell *targetCell = targetCells->data[j]; // Target chip of interest
-            pmCell *sourceCell = sourceCells->data[j]; // Source chip of interest
-            if (! targetCell || ! sourceCell) {
-                continue;
+            }
-            status &= pmConceptsCopyCell(targetCell, sourceCell);
+        }
+    }
-    return status;
+}
-bool pmConceptsCopyCell(pmCell *target, const pmCell *source)
+{
-    PS_ASSERT_PTR_NON_NULL(target, false);
-    PS_ASSERT_PTR_NON_NULL(source, false);
-    copyConcepts(target->concepts, source->concepts, dontCopyConceptsCell);
-    return true;
+}

branches/cnb_branches/cnb_branch_20090215/psModules/src/concepts/pmConcepts.h

-              r18364
+              r23197
 #define PM_CONCEPTS_H
+#include <pslib.h>
+#include <pmFPALevel.h>
+#include <pmFPA.h>
 #include <pmConfig.h>
 …
 /// Function to call to parse a concept once it has been read
+typedef psMetadataItem* (*pmConceptParseFunc)(const psMetadataItem *concept, ///< Concept to parse
+        const psMetadataItem *pattern, ///< Pattern for parsing
+                                              pmConceptSource source, ///< Source of concept
+        const psMetadata *cameraFormat, ///< Camera format definition
+        const pmFPA *fpa, ///< FPA for concept, or NULL
+        const pmChip *chip, ///< Chip for concept, or NULL
+        const pmCell *cell ///< Cell for concept, or NULL
+                                             );
+typedef psMetadataItem* (*pmConceptParseFunc)(
+    const psMetadataItem *concept, ///< Concept to parse
+    const psMetadataItem *pattern, ///< Pattern for parsing
+    pmConceptSource source, ///< Source of concept
+    const psMetadata *cameraFormat, ///< Camera format definition
+    const pmFPA *fpa, ///< FPA for concept, or NULL
+    const pmChip *chip, ///< Chip for concept, or NULL
+    const pmCell *cell ///< Cell for concept, or NULL
+    );
 /// Function to call to format a concept for writing
+typedef psMetadataItem* (*pmConceptFormatFunc)(const psMetadataItem *concept, ///< Concept to format
+                                               pmConceptSource source, ///< Source of concept
+        const psMetadata *cameraFormat, ///< Camera format definition
+        const pmFPA *fpa, ///< FPA for concept, or NULL
+        const pmChip *chip, ///< Chip for concept, or NULL
+        const pmCell *cell ///< Cell for concept, or NULL
+                                              );
+typedef psMetadataItem* (*pmConceptFormatFunc)(
+    const psMetadataItem *concept, ///< Concept to format
+    pmConceptSource source, ///< Source of concept
+    const psMetadata *cameraFormat, ///< Camera format definition
+    const pmFPA *fpa, ///< FPA for concept, or NULL
+    const pmChip *chip, ///< Chip for concept, or NULL
+    const pmCell *cell ///< Cell for concept, or NULL
+    );
+/// Function to call to copy a concept
+typedef psMetadataItem* (*pmConceptCopyFunc)(
+    const psMetadataItem *target,       ///< Target concept
+    const psMetadataItem *source,       ///< Source concept
+    const psMetadata *cameraFormat,     ///< Camera format definition
+    const pmFPA *fpa,                   ///< Source FPA for concept, or NULL
+    const pmChip *chip,                 ///< Source chip for concept, or NULL
+    const pmCell *cell                  ///< Source cell for concept, or NULL
+    );
 /// A "concept" specification
 …
 /// Defines the name, default comment, blank value, and functions to parse (after reading) and format (before
 /// writing) the concept.
+typedef struct
+{
+typedef struct {
     psMetadataItem *blank;              ///< Blank value of concept; also contains the name and comment
+    pmConceptParseFunc parse;           ///< Function to call to read the concept
+    pmConceptFormatFunc format;         ///< Function to call to write the concept
+    pmConceptParseFunc parse;           ///< Function to call to read the concept, or NULL
+    pmConceptFormatFunc format;         ///< Function to call to write the concept, or NULL
+    pmConceptCopyFunc copy;             ///< Function to call to copy the concept, or NULL
     bool required;                      ///< Is concept required (throw an error on problems)?
+}
 …
 /// Allocator for pmConceptSpec
 pmConceptSpec *pmConceptSpecAlloc(psMetadataItem *blank, ///< Blank value; contains the name
+                                  pmConceptParseFunc parse, ///< Function to call to parse the concept
+                                  pmConceptFormatFunc format, ///< Function to call to format the concept
+                                  pmConceptParseFunc parse, ///< Function to call to parse the concept/NULL
+                                  pmConceptFormatFunc format, ///< Function to call to format the concept/NULL
+                                  pmConceptCopyFunc copy, ///< Function to call to copy the concept, or NULL
                                   bool required ///< Is concept required?
                                  );
 …
                        pmConceptParseFunc parse, ///< Function to call to parse the concept, or NULL
                        pmConceptFormatFunc format, ///< Function to call to format the concept, or NULL
+                       pmConceptCopyFunc copy, ///< Function to call to copy the concept, or NULL
                        bool required,   ///< Is concept required?
                        pmFPALevel level ///< Level at which to store concept in the FPA hierarchy
                       );
 /// Get a list of defined concepts for a particular level.
 psList *pmConceptsList(pmFPALevel level);
+/// Get the specifications for defined concepts of a particular level
+psMetadata *pmConceptsSpecs(pmFPALevel level);
-/// Read the concepts for the given set of fpa, chip, cell
-///
-/// Attempts to read as many concepts as possible from the specified source for the specified FPA, chip and
-/// cell.  That is, it will read chip- and cell-level concepts in addition to fpa-level concepts, if the chip
-/// and cell are provided.
-bool pmConceptsRead(pmFPA *fpa,         ///< FPA for which to read concepts
-                    pmChip *chip,       ///< Chip for which to read concepts, or NULL
-                    pmCell *cell,       ///< Cell for which to read concepts, or NULL
-                    pmConceptSource source, ///< The source of the concepts to read
-                    pmConfig *config    ///< Configuration
-                   );
 /// Set the concepts within the FPA to the blank value
 bool pmConceptsBlankFPA(pmFPA *fpa      ///< FPA for which to set blank concepts
-                       );
-/// Read concepts for an FPA; optionally, read concepts at all lower levels.
-///
-/// Once concepts should be available for reading at the FPA-level, this function attempts to read the
-/// concepts from the specified source.  It also allows concepts to be read at lower levels by iterating over
-/// the components.
-bool pmConceptsReadFPA(pmFPA *fpa,      ///< FPA for which to read concepts
-                       pmConceptSource source, ///< Source for concepts
-                       bool propagateDown, ///< Propagate to lower levels?
-                       pmConfig *config         ///< Configuration
-                      );
-/// Write concepts for an FPA; optionally, write concepts at all lower levels.
-///
-/// This function writes all concepts for the FPA to the specified "source".  It also allows concepts to be
-/// written for all lower levels by iterating over the components.
-bool pmConceptsWriteFPA(const pmFPA *fpa,     ///< FPA for which to write concepts
-                        pmConceptSource source, ///< Source for concepts
-                        bool propagateDown, ///< Propagate to lower levels?
-                        pmConfig *config        ///< Configuration
                        );
 …
                         );
-/// Read concepts for a chip; optionally, read concepts at the FPA and cell levels.
-///
-/// Once concepts should be available for reading at the FPA-level, this function attempts to read the
-/// concepts from the specified source.  It also allows concepts to be read at the fpa level (through the
-/// parent), and the cell level by iterating over the components.
-bool pmConceptsReadChip(pmChip *chip,   ///< Chip for which to read concepts
-                        pmConceptSource source, ///< Source for concepts
-                        bool propagateUp, ///< Propagate to higher levels?
-                        bool propagateDown, ///< Propagate to lower levels?
-                        pmConfig *config        ///< Configuration
-                       );
-/// Write concepts for a chip; optionally, write concepts at the FPA and cell levels.
-///
-/// This function writes all concepts for the chip to the specified "source".  It also allows concepts to be
-/// written for the FPA, and the cell level by iterating over the components.
-bool pmConceptsWriteChip(const pmChip *chip,  ///< Chip for which to write concepts
-                         pmConceptSource source, ///< Source for concepts
-                         bool propagateUp,///< Propagate to higher levels?
-                         bool propagateDown, ///< Propagate to lower levels?
-                         pmConfig *config       ///< Configuration
-                        );
 /// Set the concepts within the cell to the blank value
 bool pmConceptsBlankCell(pmCell *cell   ///< Cell for which to set blank concepts
-                        );
-/// Read concepts for a cell; optionally, read concepts for the parents.
-///
-/// Once concepts should be available for reading at the FPA-level, this function attempts to read the
-/// concepts from the specified source.  It also allows concepts to be read at upper levels through the
-/// parents (note, it would not read concepts for all chips, but only the parent of this cell).
-bool pmConceptsReadCell(pmCell *cell,   ///< Cell for which to read concepts
-                        pmConceptSource source, ///< Source for concepts
-                        bool propagateUp, ///< Propagate to higher levels?
-                        pmConfig *config        ///< Configuration
-                       );
-/// Write concepts for a cell; optionally, write concepts for the parents.
-///
-/// This function writes all concepts for the chip to the specified "source".  It also allows concepts to be
-/// written for the upper levels through the parents (note, it would not write concepts for all chips, but
-/// only the parent of this cell).
-bool pmConceptsWriteCell(const pmCell *cell,  ///< FPA for which to write concepts
-                         pmConceptSource source, ///< Source for concepts
-                         bool propagateUp, ///< Propagate to higher levels?
-                         pmConfig *config ///< Configuration
                         );
 …
 /// Frees the registered concepts so there is no memory leak when the user checks "persistent" memory.
 void pmConceptsDone(void);
-/// Copy all the concepts within an FPA to another FPA
-///
-/// Iterates over all components of the FPA, and copies the concepts metadata from the source to the target.
-bool pmFPACopyConcepts(pmFPA *target,   ///< The target FPA
-                       const pmFPA *source    ///< The source FPA
-                      );
-/// Copy the concepts within an FPA to another FPA; optionally recurse to lower levels
-bool pmConceptsCopyFPA(pmFPA *target,   ///< Target FPA
-                       const pmFPA *source, ///< Source FPA
-                       bool chips,      ///< Recurse to chips level?
-                       bool cells       ///< Recurse to cells level?
-    );
-/// Copy the concepts within a chip to another chip; optionally recurse to lower level
-bool pmConceptsCopyChip(pmChip *target, ///< Target chip
-                        const pmChip *source, ///< Source chip
-                        bool cells      ///< Recurse to cells level?
-    );
-/// Copy the concepts within a cell to another cell
-bool pmConceptsCopyCell(pmCell *target, ///< Target cell
-                        const pmCell *source ///< Source cell
-    );
 /// Interpolate a concept name to the actual value

branches/cnb_branches/cnb_branch_20090215/psModules/src/concepts/pmConceptsAverage.c

-              r20597
+              r23197
         psTime *fpaTime = psMetadataLookupPtr(NULL, fpa->concepts, "FPA.TIME");
+        psTimeConvert(fpaTime, PS_TIME_TAI);
         time       += psTimeToMJD(fpaTime);
         if (num == 1) {
 …
         psMetadataItem *timeItem = psMetadataLookup(target->concepts, "FPA.TIME");
         psFree(timeItem->data.V);
+        timeItem->data.V = psTimeFromMJD(time);
+        psTime *new = psTimeFromMJD(time);
+        psTimeConvert(new, timeSys);
+        timeItem->data.V = new;
+    }
 …
+        }
         float value = psMetadataLookupF32(&status, cell->concepts, name);
         if (!status) continue;
         if (!isfinite(value)) continue;
+        float value = psMetadataLookupF32(&status, cell->concepts, name);
+        if (!status) continue;
+        if (!isfinite(value)) continue;
         sum += value;
 …
         psMetadataItem *timeItem = psMetadataLookup(target->concepts, "CELL.TIME");
         psFree(timeItem->data.V);
+        timeItem->data.V = psTimeFromMJD(time);
+        psTime *new = psTimeFromMJD(time);
+        psTimeConvert(new, timeSys);
+        timeItem->data.V = new;
+    }

branches/cnb_branches/cnb_branch_20090215/psModules/src/concepts/pmConceptsRead.c

-              r20868
+              r23197
 #include "pmHDUUtils.h"
 #include "pmConcepts.h"
+#include "pmConceptsUpdate.h"
 #include "pmConceptsRead.h"
 …
+}
+// Read all registered concepts for the specified level
+static bool conceptsRead(psMetadata **specs, // One of the concepts specifications
+                         pmFPA *fpa,    // The FPA
+                         pmChip *chip,  // The chip
+                         pmCell *cell, // The cell
+                         unsigned int *read,     // What's already been read
+                         pmConceptSource source, // The source of the concepts to read
+                         pmConfig *config, // Configuration
+                         psMetadata *target // Place into which to read the concepts
+                        )
+{
+    assert(specs);
+    assert(read);
+    assert(target);
+    pmConceptsInit();
+    // At least one HDU is required for the reading functions
+    pmHDU *hduLow = pmHDUGetLowest(fpa, chip, cell); // Lowest HDU.
+    if (!hduLow) {
+        // Can't do anything --- don't record any success, but don't return an error either
+        return true;
+    }
+    pmHDU *hduHigh = pmHDUGetHighest(fpa, chip, cell); // Highest HDU
+    if (cell && (cell->conceptsRead == PM_CONCEPT_SOURCE_NONE)) {
+        pmConceptsBlankCell(cell);
+        cell->conceptsRead = PM_CONCEPT_SOURCE_BLANK;
+    }
+    if (chip && (chip->conceptsRead == PM_CONCEPT_SOURCE_NONE)) {
+        pmConceptsBlankChip(chip);
+        chip->conceptsRead = PM_CONCEPT_SOURCE_BLANK;
+    }
+    if (fpa && (fpa->conceptsRead == PM_CONCEPT_SOURCE_NONE)) {
+        pmConceptsBlankFPA(fpa);
+        fpa->conceptsRead = PM_CONCEPT_SOURCE_BLANK;
+    }
+    bool success = true;                // Success in reading concepts?
+    if (source & PM_CONCEPT_SOURCE_CELLS && !(*read & PM_CONCEPT_SOURCE_CELLS) && cell) {
+        if (p_pmConceptsReadFromCells(target, *specs, cell)) {
+            *read |= PM_CONCEPT_SOURCE_CELLS;
+        } else {
+            psError(PS_ERR_UNKNOWN, false, "Error reading concepts from camera configuration.\n");
+            success = false;
+        }
+    }
+    if (source & PM_CONCEPT_SOURCE_DEFAULTS && !(*read & PM_CONCEPT_SOURCE_DEFAULTS)) {
+        if (p_pmConceptsReadFromDefaults(target, *specs, fpa, chip, cell)) {
+            *read |= PM_CONCEPT_SOURCE_DEFAULTS;
+        } else {
+            psError(PS_ERR_UNKNOWN, false, "Error reading concepts from defaults.\n");
+            success = false;
+        }
+    }
+    if (source & PM_CONCEPT_SOURCE_PHU && !(*read & PM_CONCEPT_SOURCE_PHU) && hduHigh->header) {
+        if (p_pmConceptsReadFromHeader(target, *specs, fpa, chip, cell)) {
+            *read |= PM_CONCEPT_SOURCE_PHU;
+        } else {
+            psError(PS_ERR_UNKNOWN, false, "Error reading concepts from PHU.\n");
+            success = false;
+        }
+    }
+    // If there are multiple HDUs, then it may be that one of them hasn't been read yet (hdu->header not set)
+    if (source & PM_CONCEPT_SOURCE_HEADER && !(*read & PM_CONCEPT_SOURCE_HEADER) &&
+        hduLow != hduHigh && hduLow->header) {
+        if (p_pmConceptsReadFromHeader(target, *specs, fpa, chip, cell)) {
+            *read |= PM_CONCEPT_SOURCE_HEADER;
+        } else {
+            psError(PS_ERR_UNKNOWN, false, "Error reading concepts from header.\n");
+            success = false;
+        }
+    }
+#ifdef HAVE_PSDB
+    if (source & PM_CONCEPT_SOURCE_DATABASE && !(*read & PM_CONCEPT_SOURCE_DATABASE)) {
+        if (p_pmConceptsReadFromDatabase(target, *specs, fpa, chip, cell, config)) {
+            *read |= PM_CONCEPT_SOURCE_DATABASE;
+        } else {
+            psError(PS_ERR_UNKNOWN, false, "Error reading concepts from database.\n");
+            success = false;
+        }
+    }
+#endif
+    pmConceptsUpdate(fpa, chip, cell);
+    return success;
+}
+bool pmConceptsRead(pmFPA *fpa, pmChip *chip, pmCell *cell, pmConceptSource source, pmConfig *config)
+{
+    PS_ASSERT_PTR_NON_NULL(fpa, false);
+    psMetadata *conceptsFPA = pmConceptsSpecs(PM_FPA_LEVEL_FPA); // Concept specifications
+    bool success = conceptsRead(&conceptsFPA, fpa, chip, cell, &fpa->conceptsRead, source,
+                                config, fpa->concepts);
+    if (chip) {
+        psMetadata *conceptsChip = pmConceptsSpecs(PM_FPA_LEVEL_CHIP); // Concept specifications
+        success &= conceptsRead(&conceptsChip, fpa, chip, cell, &chip->conceptsRead, source,
+                                config, chip->concepts);
+    }
+    if (cell) {
+        psMetadata *conceptsCell = pmConceptsSpecs(PM_FPA_LEVEL_CELL); // Concept specifications
+        success &= conceptsRead(&conceptsCell, fpa, chip, cell, &cell->conceptsRead, source,
+                                config, cell->concepts);
+    }
+    return success;
+}
+bool pmConceptsReadFPA(pmFPA *fpa, pmConceptSource source, bool propagateDown, pmConfig *config)
+{
+    PS_ASSERT_PTR_NON_NULL(fpa, false);
+    psMetadata *conceptsFPA = pmConceptsSpecs(PM_FPA_LEVEL_FPA); // Concept specifications
+    psTrace("psModules.concepts", 5, "Reading FPA concepts: %p %p\n", conceptsFPA, fpa->concepts);
+    bool success = conceptsRead(&conceptsFPA, fpa, NULL, NULL, &fpa->conceptsRead, source,
+                                config, fpa->concepts);
+    if (propagateDown) {
+        psArray *chips = fpa->chips;    // Array of chips
+        for (long i = 0; i < chips->n; i++) {
+            pmChip *chip = chips->data[i]; // Chip of interest
+            if (chip) {
+                success &= pmConceptsReadChip(chip, source, false, true, config);
+            }
+        }
+    }
+    return success;
+}
+bool pmConceptsReadChip(pmChip *chip, pmConceptSource source, bool propagateUp,
+                        bool propagateDown, pmConfig *config)
+{
+    PS_ASSERT_PTR_NON_NULL(chip, false);
+    psMetadata *conceptsChip = pmConceptsSpecs(PM_FPA_LEVEL_CHIP); // Concept specifications
+    psTrace("psModules.concepts", 5, "Reading chip concepts: %p %p\n", conceptsChip, chip->concepts);
+    pmFPA *fpa = chip->parent;          // FPA to which the chip belongs
+    bool success = conceptsRead(&conceptsChip, fpa, chip, NULL, &chip->conceptsRead, source, config,
+                                chip->concepts);
+    if (propagateUp) {
+        psMetadata *conceptsFPA = pmConceptsSpecs(PM_FPA_LEVEL_FPA); // Concept specifications
+        success &= conceptsRead(&conceptsFPA, fpa, chip, NULL, &fpa->conceptsRead, source,
+                                config, fpa->concepts);
+    }
+    if (propagateDown) {
+        psArray *cells = chip->cells;        // Array of cells
+        for (long i = 0; i < cells->n; i++) {
+            pmCell *cell = cells->data[i];  // Cell of interest
+            if (cell) {
+                success &= pmConceptsReadCell(cell, source, false, config);
+            }
+        }
+    }
+    return success;
+}
+bool pmConceptsReadCell(pmCell *cell, pmConceptSource source, bool propagateUp, pmConfig *config)
+{
+    PS_ASSERT_PTR_NON_NULL(cell, false);
+    psMetadata *conceptsCell = pmConceptsSpecs(PM_FPA_LEVEL_CELL); // Concept specifications
+    psTrace("psModules.concepts", 5, "Reading cell concepts: %p %p\n", conceptsCell, cell->concepts);
+    pmChip *chip = cell->parent;        // Chip to which the cell belongs
+    pmFPA *fpa = chip->parent;          // FPA to which the chip belongs
+    bool success = conceptsRead(&conceptsCell, fpa, chip, cell, &cell->conceptsRead, source, config,
+                                cell->concepts);
+    if (propagateUp) {
+        psMetadata *conceptsChip = pmConceptsSpecs(PM_FPA_LEVEL_CHIP); // Concept specifications
+        success &= conceptsRead(&conceptsChip, fpa, chip, cell, &chip->conceptsRead, source, config,
+                                chip->concepts);
+        psMetadata *conceptsFPA = pmConceptsSpecs(PM_FPA_LEVEL_FPA); // Concept specifications
+        success &= conceptsRead(&conceptsFPA, fpa, chip, cell, &fpa->conceptsRead, source, config,
+                                fpa->concepts);
+    }
+    return success;
+}

branches/cnb_branches/cnb_branch_20090215/psModules/src/concepts/pmConceptsRead.h

-              r18163
+              r23197
 #ifndef PM_CONCEPTS_READ_H
 #define PM_CONCEPTS_READ_H
+#include <pslib.h>
+#include <pmFPA.h>
+#include <pmConfig.h>
+#include <pmConcepts.h>
 /// Read concepts from the camera format file's CELLS.
 …
                                   pmConfig *config // Configuration
                                  );
+/// Read the concepts for the given set of fpa, chip, cell
+///
+/// Attempts to read as many concepts as possible from the specified source for the specified FPA, chip and
+/// cell.  That is, it will read chip- and cell-level concepts in addition to fpa-level concepts, if the chip
+/// and cell are provided.
+bool pmConceptsRead(pmFPA *fpa,         ///< FPA for which to read concepts
+                    pmChip *chip,       ///< Chip for which to read concepts, or NULL
+                    pmCell *cell,       ///< Cell for which to read concepts, or NULL
+                    pmConceptSource source, ///< The source of the concepts to read
+                    pmConfig *config    ///< Configuration
+                   );
+/// Read concepts for an FPA; optionally, read concepts at all lower levels.
+///
+/// Once concepts should be available for reading at the FPA-level, this function attempts to read the
+/// concepts from the specified source.  It also allows concepts to be read at lower levels by iterating over
+/// the components.
+bool pmConceptsReadFPA(pmFPA *fpa,      ///< FPA for which to read concepts
+                       pmConceptSource source, ///< Source for concepts
+                       bool propagateDown, ///< Propagate to lower levels?
+                       pmConfig *config         ///< Configuration
+                      );
+/// Read concepts for a chip; optionally, read concepts at the FPA and cell levels.
+///
+/// Once concepts should be available for reading at the FPA-level, this function attempts to read the
+/// concepts from the specified source.  It also allows concepts to be read at the fpa level (through the
+/// parent), and the cell level by iterating over the components.
+bool pmConceptsReadChip(pmChip *chip,   ///< Chip for which to read concepts
+                        pmConceptSource source, ///< Source for concepts
+                        bool propagateUp, ///< Propagate to higher levels?
+                        bool propagateDown, ///< Propagate to lower levels?
+                        pmConfig *config        ///< Configuration
+                       );
+/// Read concepts for a cell; optionally, read concepts for the parents.
+///
+/// Once concepts should be available for reading at the FPA-level, this function attempts to read the
+/// concepts from the specified source.  It also allows concepts to be read at upper levels through the
+/// parents (note, it would not read concepts for all chips, but only the parent of this cell).
+bool pmConceptsReadCell(pmCell *cell,   ///< Cell for which to read concepts
+                        pmConceptSource source, ///< Source for concepts
+                        bool propagateUp, ///< Propagate to higher levels?
+                        pmConfig *config        ///< Configuration
+                       );
 /// @}
 #endif

branches/cnb_branches/cnb_branch_20090215/psModules/src/concepts/pmConceptsStandard.c

-              r21183
+              r23197
                         if (!isfinite(gain)) {
                             psWarning("CELL.READNOISE is supposed to be in ADU, but CELL.GAIN isn't set -- forcing to 1.0");
                             gain = 1.0;
+                            gain = 1.0;
+                        }
                         rn /= gain;
 …
+}
+// Determine the corresponding TIMESYS for one of the TIME concepts
+static psTimeType conceptGetTimesysForTime(const char *name, // Concept name ("CELL.TIME" or "FPA.TIME")
+                                           const pmFPA *fpa, // FPA of interest
+                                           const pmChip *chip, // Chip of interest, or NULL
+                                           const pmCell *cell // Cell of interest, or NULL
+                                           )
+{
+    assert(name);
+    psString timesysName = psStringCopy(name); // e.g., "CELL.TIME" --> "CELL.TIMESYS"
+    psStringSubstitute(&timesysName, "TIMESYS", "TIME");
+    bool mdok = false;                  // Result of MD lookup
+    psTimeType timeSys = 0xFFFFFFFF;    // The time system
+    if (cell) {
+        timeSys = psMetadataLookupS32(&mdok, cell->concepts, timesysName);
+    }
+    if (!mdok && chip) {
+        timeSys = psMetadataLookupS32(&mdok, chip->concepts, timesysName);
+    }
+    if (!mdok && fpa) {
+        timeSys = psMetadataLookupS32(&mdok, fpa->concepts, timesysName);
+    }
+    if (!mdok || (timeSys == 0xFFFFFFFF)) {
+        psWarning("Unable to find %s in concepts when parsing %s --- assuming UTC.\n",
+                  timesysName, name);
+        timeSys = PS_TIME_UTC;
+    }
+    psFree(timesysName);
+    return timeSys;
+}
 psMetadataItem *p_pmConceptParse_TIME(const psMetadataItem *concept,
                                       const psMetadataItem *pattern,
 …
     assert(cameraFormat);
+    // Need TIMESYS first
+    psString timesysName = psStringCopy(pattern->name); // e.g., "CELL.TIME" --> "CELL.TIMESYS"
+    psStringSubstitute(&timesysName, "TIMESYS", "TIME");
+    bool mdok = false;                  // Result of MD lookup
+    psTimeType timeSys = PS_TIME_UTC; // The time system
+    if (cell) {
+        timeSys = psMetadataLookupS32(&mdok, cell->concepts, timesysName);
+    }
+    if (!mdok && chip) {
+        timeSys = psMetadataLookupS32(&mdok, chip->concepts, timesysName);
+    }
+    if (!mdok && fpa) {
+        timeSys = psMetadataLookupS32(&mdok, fpa->concepts, timesysName);
+    }
+    if (!mdok || (timeSys == 0xffffffff)) {
+        psWarning("Unable to find %s in concepts when parsing %s --- assuming UTC.\n",
+                  timesysName, pattern->name);
+        timeSys = PS_TIME_UTC;
+    }
+    psFree(timesysName);
+    psTimeType timeSys = conceptGetTimesysForTime(pattern->name, fpa, chip, cell); // Time system
     // Work out how the time is represented
 …
     // Get format
+    bool mdok;                          // Status of MD lookup
     psMetadata *formats = psMetadataLookupMetadata(&mdok, cameraFormat, "FORMATS");
     if (!mdok || !formats) {
 …
+    }
+    time->type = timeSys;
     psMetadataItem *item = psMetadataItemAllocPtr(pattern->name, PS_DATA_TIME, pattern->comment, time);
     psFree(time);                       // Drop reference
 …
+{
     psTime *time = concept->data.V;     // The time
+    psTimeType timeSys = conceptGetTimesysForTime(concept->name, fpa, chip, cell); // Time system
+    psTimeConvert(time, timeSys);
     // Work out the format
 …
+psMetadataItem *p_pmConceptCopy_TIMESYS(const psMetadataItem *target,
+                                        const psMetadataItem *source,
+                                        const psMetadata *cameraFormat,
+                                        const pmFPA *fpa,
+                                        const pmChip *chip,
+                                        const pmCell *cell)
+{
+    if (!target || target->data.S32 == -1) {
+        // Replace
+        return psMetadataItemCopy(source);
+    }
+    // Keep what we've got --- it's been mandated by use of the DEFAULTS
+    return psMemIncrRefCounter((psMetadataItem*)target);
+}

branches/cnb_branches/cnb_branch_20090215/psModules/src/concepts/pmConceptsStandard.h

-              r20095
+              r23197
 /// Parse the CELL.READNOISE concept to do ADU->e correction if required
+psMetadataItem *p_pmConceptParse_CELL_READNOISE(const psMetadataItem *concept,
+                                                const psMetadataItem *pattern,
+                                                pmConceptSource source,
+                                                const psMetadata *cameraFormat,
+                                                const pmFPA *fpa,
+                                                const pmChip *chip,
+                                                const pmCell *cell);
+psMetadataItem *p_pmConceptParse_CELL_READNOISE(
+    const psMetadataItem *concept,
+    const psMetadataItem *pattern,
+    pmConceptSource source,
+    const psMetadata *cameraFormat,
+    const pmFPA *fpa,
+    const pmChip *chip,
+    const pmCell *cell
+);
 /// Format the CELL.READNOISE concept to do e->ADU correction if required
+psMetadataItem *p_pmConceptFormat_CELL_READNOISE(const psMetadataItem *concept,
+                                                 pmConceptSource source,
+                                                 const psMetadata *cameraFormat,
+                                                 const pmFPA *fpa,
+                                                 const pmChip *chip,
+                                                 const pmCell *cell);
+psMetadataItem *p_pmConceptFormat_CELL_READNOISE(
+    const psMetadataItem *concept,
+    pmConceptSource source,
+    const psMetadata *cameraFormat,
+    const pmFPA *fpa,
+    const pmChip *chip,
+    const pmCell *cell
+    );
 // Parse the TELTEMPS concept : parse a list of the form 'X1 X2 X3 X4 X5 ...' : for now use median
+psMetadataItem *p_pmConceptParse_TELTEMPS(const psMetadataItem *concept,
+                                          const psMetadataItem *pattern,
+                                          pmConceptSource source,
+                                          const psMetadata *cameraFormat,
+                                          const pmFPA *fpa,
+                                          const pmChip *chip,
+                                          const pmCell *cell);
+psMetadataItem *p_pmConceptParse_TELTEMPS(
+    const psMetadataItem *concept,
+    const psMetadataItem *pattern,
+    pmConceptSource source,
+    const psMetadata *cameraFormat,
+    const pmFPA *fpa,
+    const pmChip *chip,
+    const pmCell *cell
+    );
 /// Parse the FPA.FILTER concept to apply a lookup table
+psMetadataItem *p_pmConceptParse_FPA_FILTER(const psMetadataItem *concept, ///< Concept to parse
+        const psMetadataItem *pattern, ///< Pattern to use in parsing
+                                            pmConceptSource source, ///< Source for concept
+        const psMetadata *cameraFormat, ///< Camera format definition
+        const pmFPA *fpa, ///< FPA for concept, or NULL
+        const pmChip *chip, ///< Chip for concept, or NULL
+        const pmCell *cell ///< Cell for concept, or NULL
+                                           );
+psMetadataItem *p_pmConceptParse_FPA_FILTER(
+    const psMetadataItem *concept, ///< Concept to parse
+    const psMetadataItem *pattern, ///< Pattern to use in parsing
+    pmConceptSource source, ///< Source for concept
+    const psMetadata *cameraFormat, ///< Camera format definition
+    const pmFPA *fpa, ///< FPA for concept, or NULL
+    const pmChip *chip, ///< Chip for concept, or NULL
+    const pmCell *cell ///< Cell for concept, or NULL
+    );
 /// Format the FPA.FILTER concept to (reverse-)apply a lookup table
+psMetadataItem *p_pmConceptFormat_FPA_FILTER(const psMetadataItem *concept, ///< Concept to format
+                                            pmConceptSource source, ///< Source for concept
+        const psMetadata *cameraFormat, ///< Camera format definition
+        const pmFPA *fpa, ///< FPA for concept, or NULL
+        const pmChip *chip, ///< Chip for concept, or NULL
+        const pmCell *cell ///< Cell for concept, or NULL
+                                            );
+psMetadataItem *p_pmConceptFormat_FPA_FILTER(
+    const psMetadataItem *concept, ///< Concept to format
+    pmConceptSource source, ///< Source for concept
+    const psMetadata *cameraFormat, ///< Camera format definition
+    const pmFPA *fpa, ///< FPA for concept, or NULL
+    const pmChip *chip, ///< Chip for concept, or NULL
+    const pmCell *cell ///< Cell for concept, or NULL
+    );
 /// Parse the coordinates concepts: FPA.RA and FPA.DEC
+psMetadataItem *p_pmConceptParse_FPA_Coords(const psMetadataItem *concept, ///< Concept to parse
+        const psMetadataItem *pattern, ///< Pattern to use in parsing
+                                            pmConceptSource source, ///< Source for concept
+        const psMetadata *cameraFormat, ///< Camera format definition
+        const pmFPA *fpa, ///< FPA for concept, or NULL
+        const pmChip *chip, ///< Chip for concept, or NULL
+        const pmCell *cell ///< Cell for concept, or NULL
+                                           );
+psMetadataItem *p_pmConceptParse_FPA_Coords(
+    const psMetadataItem *concept, ///< Concept to parse
+    const psMetadataItem *pattern, ///< Pattern to use in parsing
+    pmConceptSource source, ///< Source for concept
+    const psMetadata *cameraFormat, ///< Camera format definition
+    const pmFPA *fpa, ///< FPA for concept, or NULL
+    const pmChip *chip, ///< Chip for concept, or NULL
+    const pmCell *cell ///< Cell for concept, or NULL
+    );
 /// Format the coordinates concepts: FPA.RA and FPA.DEC
+psMetadataItem *p_pmConceptFormat_FPA_Coords(const psMetadataItem *concept, ///< Concept to format
+                                            pmConceptSource source, ///< Source for concept
+        const psMetadata *cameraFormat, ///< Camera format definition
+        const pmFPA *fpa, ///< FPA for concept, or NULL
+        const pmChip *chip, ///< Chip for concept, or NULL
+        const pmCell *cell ///< Cell for concept, or NULL
+                                            );
+psMetadataItem *p_pmConceptFormat_FPA_Coords(
+    const psMetadataItem *concept, ///< Concept to format
+    pmConceptSource source, ///< Source for concept
+    const psMetadata *cameraFormat, ///< Camera format definition
+    const pmFPA *fpa, ///< FPA for concept, or NULL
+    const pmChip *chip, ///< Chip for concept, or NULL
+    const pmCell *cell ///< Cell for concept, or NULL
+    );
 /// Parse the CELL.TRIMSEC concept
+psMetadataItem *p_pmConceptParse_CELL_TRIMSEC(const psMetadataItem *concept, ///< Concept to parse
+        const psMetadataItem *pattern, ///< Pattern to use in parsing
+                                            pmConceptSource source, ///< Source for concept
+        const psMetadata *cameraFormat, ///< Camera format definition
+        const pmFPA *fpa, ///< FPA for concept, or NULL
+        const pmChip *chip, ///< Chip for concept, or NULL
+        const pmCell *cell ///< Cell for concept, or NULL
+                                             );
+psMetadataItem *p_pmConceptParse_CELL_TRIMSEC(
+    const psMetadataItem *concept, ///< Concept to parse
+    const psMetadataItem *pattern, ///< Pattern to use in parsing
+    pmConceptSource source, ///< Source for concept
+    const psMetadata *cameraFormat, ///< Camera format definition
+    const pmFPA *fpa, ///< FPA for concept, or NULL
+    const pmChip *chip, ///< Chip for concept, or NULL
+    const pmCell *cell ///< Cell for concept, or NULL
+    );
 /// Parse the CELL.BIASSEC concept
+psMetadataItem *p_pmConceptParse_CELL_BIASSEC(const psMetadataItem *concept, ///< Concept to parse
+        const psMetadataItem *pattern, ///< Pattern to use in parsing
+                                            pmConceptSource source, ///< Source for concept
+        const psMetadata *cameraFormat, ///< Camera format definition
+        const pmFPA *fpa, ///< FPA for concept, or NULL
+        const pmChip *chip, ///< Chip for concept, or NULL
+        const pmCell *cell ///< Cell for concept, or NULL
+                                             );
+psMetadataItem *p_pmConceptParse_CELL_BIASSEC(
+    const psMetadataItem *concept, ///< Concept to parse
+    const psMetadataItem *pattern, ///< Pattern to use in parsing
+    pmConceptSource source, ///< Source for concept
+    const psMetadata *cameraFormat, ///< Camera format definition
+    const pmFPA *fpa, ///< FPA for concept, or NULL
+    const pmChip *chip, ///< Chip for concept, or NULL
+    const pmCell *cell ///< Cell for concept, or NULL
+    );
 /// Parse the cell binning concepts: CELL.XBIN, CELL.YBIN
+psMetadataItem *p_pmConceptParse_CELL_Binning(const psMetadataItem *concept, ///< Concept to parse
+        const psMetadataItem *pattern, ///< Pattern to use in parsing
+                                            pmConceptSource source, ///< Source for concept
+        const psMetadata *cameraFormat, ///< Camera format definition
+        const pmFPA *fpa, ///< FPA for concept, or NULL
+        const pmChip *chip, ///< Chip for concept, or NULL
+        const pmCell *cell ///< Cell for concept, or NULL
+                                             );
+psMetadataItem *p_pmConceptParse_CELL_Binning(
+    const psMetadataItem *concept, ///< Concept to parse
+    const psMetadataItem *pattern, ///< Pattern to use in parsing
+    pmConceptSource source, ///< Source for concept
+    const psMetadata *cameraFormat, ///< Camera format definition
+    const pmFPA *fpa, ///< FPA for concept, or NULL
+    const pmChip *chip, ///< Chip for concept, or NULL
+    const pmCell *cell ///< Cell for concept, or NULL
+    );
 /// Parse the time system concepts: FPA.TIMESYS and CELL.TIMESYS
+psMetadataItem *p_pmConceptParse_TIMESYS(const psMetadataItem *concept, ///< Concept to parse
+        const psMetadataItem *pattern, ///< Pattern to use in parsing
+                                            pmConceptSource source, ///< Source for concept
+        const psMetadata *cameraFormat, ///< Camera format definition
+        const pmFPA *fpa, ///< FPA for concept, or NULL
+        const pmChip *chip, ///< Chip for concept, or NULL
+        const pmCell *cell ///< Cell for concept, or NULL
+                                        );
+psMetadataItem *p_pmConceptParse_TIMESYS(
+    const psMetadataItem *concept, ///< Concept to parse
+    const psMetadataItem *pattern, ///< Pattern to use in parsing
+    pmConceptSource source, ///< Source for concept
+    const psMetadata *cameraFormat, ///< Camera format definition
+    const pmFPA *fpa, ///< FPA for concept, or NULL
+    const pmChip *chip, ///< Chip for concept, or NULL
+    const pmCell *cell ///< Cell for concept, or NULL
+    );
 /// Parse the time concepts: FPA.TIME and CELL.TIME
+psMetadataItem *p_pmConceptParse_TIME(const psMetadataItem *concept, ///< Concept to parse
+                                      const psMetadataItem *pattern, ///< Pattern to use in parsing
+                                            pmConceptSource source, ///< Source for concept
+                                      const psMetadata *cameraFormat, ///< Camera format definition
+                                      const pmFPA *fpa, ///< FPA for concept, or NULL
+                                      const pmChip *chip, ///< Chip for concept, or NULL
+                                      const pmCell *cell ///< Cell for concept, or NULL
+                                     );
+psMetadataItem *p_pmConceptParse_TIME(
+    const psMetadataItem *concept, ///< Concept to parse
+    const psMetadataItem *pattern, ///< Pattern to use in parsing
+    pmConceptSource source, ///< Source for concept
+    const psMetadata *cameraFormat, ///< Camera format definition
+    const pmFPA *fpa, ///< FPA for concept, or NULL
+    const pmChip *chip, ///< Chip for concept, or NULL
+    const pmCell *cell ///< Cell for concept, or NULL
+    );
 /// Parse a cell position concept, e.g., CELL.X0
+psMetadataItem *p_pmConceptParse_Positions(const psMetadataItem *concept, ///< Concept to parse
+        const psMetadataItem *pattern, ///< Pattern to use in parsing
+                                            pmConceptSource source, ///< Source for concept
+       const psMetadata *cameraFormat, ///< Camera format definition
+        const pmFPA *fpa, ///< FPA for concept, or NULL
+        const pmChip *chip, ///< Chip for concept, or NULL
+        const pmCell *cell ///< Cell for concept, or NULL
+                                          );
+psMetadataItem *p_pmConceptParse_Positions(
+    const psMetadataItem *concept, ///< Concept to parse
+    const psMetadataItem *pattern, ///< Pattern to use in parsing
+    pmConceptSource source, ///< Source for concept
+    const psMetadata *cameraFormat, ///< Camera format definition
+    const pmFPA *fpa, ///< FPA for concept, or NULL
+    const pmChip *chip, ///< Chip for concept, or NULL
+    const pmCell *cell ///< Cell for concept, or NULL
+    );
 /// Format the CELL.TRIMSEC concept
+psMetadataItem *p_pmConceptFormat_CELL_TRIMSEC(const psMetadataItem *concept, ///< Concept to format
+                                            pmConceptSource source, ///< Source for concept
+        const psMetadata *cameraFormat, ///< Camera format definition
+        const pmFPA *fpa, ///< FPA for concept, or NULL
+        const pmChip *chip, ///< Chip for concept, or NULL
+        const pmCell *cell ///< Cell for concept, or NULL
+                                              );
+psMetadataItem *p_pmConceptFormat_CELL_TRIMSEC(
+    const psMetadataItem *concept, ///< Concept to format
+    pmConceptSource source, ///< Source for concept
+    const psMetadata *cameraFormat, ///< Camera format definition
+    const pmFPA *fpa, ///< FPA for concept, or NULL
+    const pmChip *chip, ///< Chip for concept, or NULL
+    const pmCell *cell ///< Cell for concept, or NULL
+    );
 /// Format the CELL.BIASSEC concept
+psMetadataItem *p_pmConceptFormat_CELL_BIASSEC(const psMetadataItem *concept, ///< Concept to format
+                                            pmConceptSource source, ///< Source for concept
+        const psMetadata *cameraFormat, ///< Camera format definition
+        const pmFPA *fpa, ///< FPA for concept, or NULL
+        const pmChip *chip, ///< Chip for concept, or NULL
+        const pmCell *cell ///< Cell for concept, or NULL
+                                              );
+psMetadataItem *p_pmConceptFormat_CELL_BIASSEC(
+    const psMetadataItem *concept, ///< Concept to format
+    pmConceptSource source, ///< Source for concept
+    const psMetadata *cameraFormat, ///< Camera format definition
+    const pmFPA *fpa, ///< FPA for concept, or NULL
+    const pmChip *chip, ///< Chip for concept, or NULL
+    const pmCell *cell ///< Cell for concept, or NULL
+    );
 /// Format the CELL.XBIN concept
+psMetadataItem *p_pmConceptFormat_CELL_XBIN(const psMetadataItem *concept, ///< Concept to format
+                                            pmConceptSource source, ///< Source for concept
+        const psMetadata *cameraFormat, ///< Camera format definition
+        const pmFPA *fpa, ///< FPA for concept, or NULL
+        const pmChip *chip, ///< Chip for concept, or NULL
+        const pmCell *cell ///< Cell for concept, or NULL
+                                           );
+psMetadataItem *p_pmConceptFormat_CELL_XBIN(
+    const psMetadataItem *concept, ///< Concept to format
+    pmConceptSource source, ///< Source for concept
+    const psMetadata *cameraFormat, ///< Camera format definition
+    const pmFPA *fpa, ///< FPA for concept, or NULL
+    const pmChip *chip, ///< Chip for concept, or NULL
+    const pmCell *cell ///< Cell for concept, or NULL
+    );
 /// Format the CELL.YBIN concept
+psMetadataItem *p_pmConceptFormat_CELL_YBIN(const psMetadataItem *concept, ///< Concept to format
+                                            pmConceptSource source, ///< Source for concept
+        const psMetadata *cameraFormat, ///< Camera format definition
+        const pmFPA *fpa, ///< FPA for concept, or NULL
+        const pmChip *chip, ///< Chip for concept, or NULL
+        const pmCell *cell ///< Cell for concept, or NULL
+                                           );
+psMetadataItem *p_pmConceptFormat_CELL_YBIN(
+    const psMetadataItem *concept, ///< Concept to format
+    pmConceptSource source, ///< Source for concept
+    const psMetadata *cameraFormat, ///< Camera format definition
+    const pmFPA *fpa, ///< FPA for concept, or NULL
+    const pmChip *chip, ///< Chip for concept, or NULL
+    const pmCell *cell ///< Cell for concept, or NULL
+    );
 /// Format the time system concepts: FPA.TIMESYS and CELL.TIMESYS
+psMetadataItem *p_pmConceptFormat_TIMESYS(const psMetadataItem *concept, ///< Concept to format
+                                            pmConceptSource source, ///< Source for concept
+        const psMetadata *cameraFormat, ///< Camera format definition
+        const pmFPA *fpa, ///< FPA for concept, or NULL
+        const pmChip *chip, ///< Chip for concept, or NULL
+        const pmCell *cell ///< Cell for concept, or NULL
+                                         );
+psMetadataItem *p_pmConceptFormat_TIMESYS(
+    const psMetadataItem *concept, ///< Concept to format
+    pmConceptSource source, ///< Source for concept
+    const psMetadata *cameraFormat, ///< Camera format definition
+    const pmFPA *fpa, ///< FPA for concept, or NULL
+    const pmChip *chip, ///< Chip for concept, or NULL
+    const pmCell *cell ///< Cell for concept, or NULL
+    );
 /// Format the time concepts: FPA.TIME and CELL.TIME
+psMetadataItem *p_pmConceptFormat_TIME(const psMetadataItem *concept, ///< Concept to format
+                                            pmConceptSource source, ///< Source for concept
+                                       const psMetadata *cameraFormat, ///< Camera format definition
+                                       const pmFPA *fpa, ///< FPA for concept, or NULL
+                                       const pmChip *chip, ///< Chip for concept, or NULL
+                                       const pmCell *cell ///< Cell for concept, or NULL
+                                      );
+psMetadataItem *p_pmConceptFormat_TIME(
+    const psMetadataItem *concept, ///< Concept to format
+    pmConceptSource source, ///< Source for concept
+    const psMetadata *cameraFormat, ///< Camera format definition
+    const pmFPA *fpa, ///< FPA for concept, or NULL
+    const pmChip *chip, ///< Chip for concept, or NULL
+    const pmCell *cell ///< Cell for concept, or NULL
+    );
 /// Format a cell position concept, e.g., CELL.X0
+psMetadataItem *p_pmConceptFormat_Positions(const psMetadataItem *concept, ///< Concept to format
+                                            pmConceptSource source, ///< Source for concept
+        const psMetadata *cameraFormat, ///< Camera format definition
+        const pmFPA *fpa, ///< FPA for concept, or NULL
+        const pmChip *chip, ///< Chip for concept, or NULL
+        const pmCell *cell ///< Cell for concept, or NULL
+                                           );
+psMetadataItem *p_pmConceptFormat_Positions(
+    const psMetadataItem *concept, ///< Concept to format
+    pmConceptSource source, ///< Source for concept
+    const psMetadata *cameraFormat, ///< Camera format definition
+    const pmFPA *fpa, ///< FPA for concept, or NULL
+    const pmChip *chip, ///< Chip for concept, or NULL
+    const pmCell *cell ///< Cell for concept, or NULL
+    );
+/// Copy the time system only if not already set
+psMetadataItem *p_pmConceptCopy_TIMESYS(
+    const psMetadataItem *target,
+    const psMetadataItem *source,
+    const psMetadata *cameraFormat,
+    const pmFPA *fpa,
+    const pmChip *chip,
+    const pmCell *cell
+    );
 /// @}
 #endif

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

-              r18163
+              r23197
 #include "pmConcepts.h"
 #include "pmConceptsRead.h"
+#include "pmConceptsWrite.h"
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
 …
 bool p_pmConceptsWriteToDefaults(const psMetadata *specs, const pmFPA *fpa, const pmChip *chip,
                                  const pmCell *cell, psMetadata *concepts)
+                                 const pmCell *cell, const psMetadata *concepts)
+{
     PS_ASSERT_PTR_NON_NULL(specs, false);
 …
     #endif
+}
+// Write all registered concepts for the specified level
+static bool conceptsWrite(psMetadata **specs, // One of the concepts specifications
+                          const pmFPA *fpa,   // The FPA
+                          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
+                         )
+{
+    assert(specs);
+    assert(concepts);
+    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);
+    }
+    return true;
+}
+bool pmConceptsWriteFPA(const pmFPA *fpa, pmConceptSource source, 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);
+    if (propagateDown) {
+        psArray *chips = fpa->chips;        // Array of chips
+        for (long i = 0; i < chips->n; i++) {
+            pmChip *chip = chips->data[i];  // Chip of interest
+            if (chip && !chip->hdu) {
+                success &= pmConceptsWriteChip(chip, source, false, true, config);
+            }
+        }
+    }
+    return success;
+}
+bool pmConceptsWriteChip(const pmChip *chip, pmConceptSource source, bool propagateUp,
+                         bool propagateDown, pmConfig *config)
+{
+    PS_ASSERT_PTR_NON_NULL(chip, false);
+    psMetadata *conceptsChip = pmConceptsSpecs(PM_FPA_LEVEL_CHIP); // Concept specifications
+    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);
+    if (propagateUp && !fpa->hdu) {
+        psMetadata *conceptsFPA = pmConceptsSpecs(PM_FPA_LEVEL_FPA); // Concept specifications
+        success &= conceptsWrite(&conceptsFPA, fpa, chip, NULL, source, config, fpa->concepts);
+    }
+    if (propagateDown) {
+        psArray *cells = chip->cells;        // Array of cells
+        for (long i = 0; i < cells->n; i++) {
+            pmCell *cell = cells->data[i];  // Cell of interest
+            if (cell && !cell->hdu) {
+                success &= pmConceptsWriteCell(cell, source, false, config);
+            }
+        }
+    }
+    return success;
+}
+bool pmConceptsWriteCell(const pmCell *cell, pmConceptSource source, bool propagateUp, pmConfig *config)
+{
+    PS_ASSERT_PTR_NON_NULL(cell, false);
+    psMetadata *conceptsCell = pmConceptsSpecs(PM_FPA_LEVEL_CELL); // Concept specifications
+    psTrace("psModules.concepts", 5, "Writing cell concepts: %p %p\n", conceptsCell, cell->concepts);
+    pmChip *chip = cell->parent;        // Chip to which the cell belongs
+    pmFPA *fpa = chip->parent;          // FPA to which the chip belongs
+    bool success = conceptsWrite(&conceptsCell, fpa, chip, cell, source, 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);
+            if (!fpa->hdu) {
+                psMetadata *conceptsFPA = pmConceptsSpecs(PM_FPA_LEVEL_FPA); // Concept specifications
+                success &= conceptsWrite(&conceptsFPA, fpa, chip, cell, source, config, fpa->concepts);
+            }
+        }
+    }
+    return success;
+}

branches/cnb_branches/cnb_branch_20090215/psModules/src/concepts/pmConceptsWrite.h

-              r18163
+              r23197
 #ifndef PM_CONCEPTS_WRITE_H
 #define PM_CONCEPTS_WRITE_H
+#include <pslib.h>
+#include <pmFPA.h>
+#include <pmConfig.h>
+#include <pmConcepts.h>
 /// @addtogroup Concepts Data Abstraction Concepts
 …
                                  const psMetadata *concepts ///< The concepts
                                 );
+/// Write concepts for an FPA; optionally, write concepts at all lower levels.
+///
+/// This function writes all concepts for the FPA to the specified "source".  It also allows concepts to be
+/// written for all lower levels by iterating over the components.
+bool pmConceptsWriteFPA(const pmFPA *fpa,     ///< FPA for which to write concepts
+                        pmConceptSource source, ///< Source for concepts
+                        bool propagateDown, ///< Propagate to lower levels?
+                        pmConfig *config        ///< Configuration
+                       );
+/// Write concepts for a chip; optionally, write concepts at the FPA and cell levels.
+///
+/// This function writes all concepts for the chip to the specified "source".  It also allows concepts to be
+/// written for the FPA, and the cell level by iterating over the components.
+bool pmConceptsWriteChip(const pmChip *chip,  ///< Chip for which to write concepts
+                         pmConceptSource source, ///< Source for concepts
+                         bool propagateUp,///< Propagate to higher levels?
+                         bool propagateDown, ///< Propagate to lower levels?
+                         pmConfig *config       ///< Configuration
+                        );
+/// Write concepts for a cell; optionally, write concepts for the parents.
+///
+/// This function writes all concepts for the chip to the specified "source".  It also allows concepts to be
+/// written for the upper levels through the parents (note, it would not write concepts for all chips, but
+/// only the parent of this cell).
+bool pmConceptsWriteCell(const pmCell *cell,  ///< FPA for which to write concepts
+                         pmConceptSource source, ///< Source for concepts
+                         bool propagateUp, ///< Propagate to higher levels?
+                         pmConfig *config ///< Configuration
+                        );
 /// @}
 #endif

branches/cnb_branches/cnb_branch_20090215/psModules/src/config/pmConfigCamera.c

-              r20048
+              r23197
         psMetadata *translation = psMetadataAlloc(); // The TRANSLATION --- how to read the FITS headers
         psList *concepts;               // List of concepts for each level
         psListIterator *iter;           // Iterator for concepts
         psString name;                  // Concept name, from iteration
         concepts = pmConceptsList(PM_FPA_LEVEL_FPA); // FPA-level concepts
         iter = psListIteratorAlloc(concepts, PS_LIST_HEAD, false);
         while ((name = psListGetAndIncrement(iter))) {
             const char *new = skycellConceptName(name, skycellConceptsFPA, system); // Name for skycell
+        psMetadata *concepts;           // List of concepts for each level
+        psMetadataIterator *iter;       // Iterator for concepts
+        psMetadataItem *item;           // Concept specification item, from iteration
+        concepts = pmConceptsSpecs(PM_FPA_LEVEL_FPA); // FPA-level concepts
+        iter = psMetadataIteratorAlloc(concepts, PS_LIST_HEAD, NULL);
+        while ((item = psMetadataGetAndIncrement(iter))) {
+            const char *new = skycellConceptName(item->name, skycellConceptsFPA, system); // Name for skycell
             if (new) {
                 psMetadataAddStr(translation, PS_LIST_TAIL, name, 0, NULL, new);
+                psMetadataAddStr(translation, PS_LIST_TAIL, item->name, 0, NULL, new);
+            }
+        }
         psFree(iter);
+        psFree(concepts);
+        concepts = pmConceptsList(PM_FPA_LEVEL_CHIP);
+        iter = psListIteratorAlloc(concepts, PS_LIST_HEAD, false);
+        while ((name = psListGetAndIncrement(iter))) {
+            const char *new = skycellConceptName(name, skycellConceptsChip, system); // Name for skycell
+        concepts = pmConceptsSpecs(PM_FPA_LEVEL_CHIP);
+        iter = psMetadataIteratorAlloc(concepts, PS_LIST_HEAD, NULL);
+        while ((item = psMetadataGetAndIncrement(iter))) {
+            const char *new = skycellConceptName(item->name, skycellConceptsChip, system); // Name for skycell
             if (new) {
                 psMetadataAddStr(translation, PS_LIST_TAIL, name, 0, NULL, new);
+                psMetadataAddStr(translation, PS_LIST_TAIL, item->name, 0, NULL, new);
+            }
+        }
         psFree(iter);
+        psFree(concepts);
+        concepts = pmConceptsList(PM_FPA_LEVEL_CELL);
+        iter = psListIteratorAlloc(concepts, PS_LIST_HEAD, false);
+        while ((name = psListGetAndIncrement(iter))) {
+            const char *new = skycellConceptName(name, skycellConceptsCell, system); // Name for skycell
+        concepts = pmConceptsSpecs(PM_FPA_LEVEL_CELL);
+        iter = psMetadataIteratorAlloc(concepts, PS_LIST_HEAD, false);
+        while ((item = psMetadataGetAndIncrement(iter))) {
+            const char *new = skycellConceptName(item->name, skycellConceptsCell, system); // Name for skycell
             if (new) {
                 psMetadataAddStr(translation, PS_LIST_TAIL, name, 0, NULL, new);
+                psMetadataAddStr(translation, PS_LIST_TAIL, item->name, 0, NULL, new);
+            }
+        }
         psFree(iter);
-        psFree(concepts);
         psMetadataAddMetadata(format, PS_LIST_TAIL, "TRANSLATION", 0, "How to translate the FITS headers",

branches/cnb_branches/cnb_branch_20090215/psModules/src/detrend/pmFlatField.c

r21456	r23197
43	43
44	44	// Using i,j for image; x,y for flat.
45		for (int j = rowStart, y = yOffset; j < rowStop; j++, y++) {
	45	for (int j = rowStart, y = rowStart + yOffset; j < rowStop; j++, y++) {
46	46	for (int i = 0, x = xOffset; i < numCols; i++, x++) {
47	47	float flatValue = 1.0 / flatImage->data.F32[y][x];

branches/cnb_branches/cnb_branch_20090215/psModules/src/detrend/pmShutterCorrection.h

-              r21536
+              r23197
  * @author Paul Price, IfA
+ *
  * @version $Revision: 1.23.2.1 $ $Name: not supported by cvs2svn $
  * @date $Date: 2009-02-19 17:59:50 $
+ * @version $Revision: 1.24 $ $Name: not supported by cvs2svn $
+ * @date $Date: 2009-02-16 22:27:49 $
  * Copyright 2006 Institute for Astronomy, University of Hawaii
  */

branches/cnb_branches/cnb_branch_20090215/psModules/src/imcombine/pmSubtractionIO.c

r21536	r23197
8	8	#include "pmFPAfile.h"
9	9	#include "pmFPAfileFitsIO.h"
10		#include "pmConcepts.h"
	10	#include "pmConceptsRead.h"
11	11
12	12	#include "pmSubtraction.h"

branches/cnb_branches/cnb_branch_20090215/psModules/src/objects/pmModel.c

-              r21536
+              r23197
  *  @author EAM, IfA
+ *
  *  @version $Revision: 1.27.4.1 $ $Name: not supported by cvs2svn $
  *  @date $Date: 2009-02-19 17:59:50 $
+ *  @version $Revision: 1.28 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2009-02-16 22:30:26 $
+ *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
 …
     if (model->residuals) {
         DX = xBin*(image->col0 - xCenter - dx) + model->residuals->xCenter + 0.5;
         DY = yBin*(image->row0 - yCenter - dy) + model->residuals->yCenter + 0.5;
         Ro = (model->residuals->Ro)   ? model->residuals->Ro->data.F32 : NULL;
         Rx = (model->residuals->Rx)   ? model->residuals->Rx->data.F32 : NULL;
         Ry = (model->residuals->Ry)   ? model->residuals->Ry->data.F32 : NULL;
         Rm = (model->residuals->mask) ? model->residuals->mask->data.PS_TYPE_IMAGE_MASK_DATA : NULL;
         if (Ro) {
             NX = model->residuals->Ro->numCols;
             NY = model->residuals->Ro->numRows;
+        }
+        DX = xBin*(image->col0 - xCenter - dx) + model->residuals->xCenter + 0.5;
+        DY = yBin*(image->row0 - yCenter - dy) + model->residuals->yCenter + 0.5;
+        Ro = (model->residuals->Ro)   ? model->residuals->Ro->data.F32 : NULL;
+        Rx = (model->residuals->Rx)   ? model->residuals->Rx->data.F32 : NULL;
+        Ry = (model->residuals->Ry)   ? model->residuals->Ry->data.F32 : NULL;
+        Rm = (model->residuals->mask) ? model->residuals->mask->data.PS_TYPE_IMAGE_MASK_DATA : NULL;
+        if (Ro) {
+            NX = model->residuals->Ro->numCols;
+            NY = model->residuals->Ro->numRows;
+        }
+    }
 …
             // XXX should we use using 0.5 pixel offset?
             // Convert to coordinate in parent image, with offset (dx,dy)
+            // Convert to coordinate in parent image, with offset (dx,dy)
             imageCol = ix + image->col0 - dx;
             imageRow = iy + image->row0 - dy;
 …
                 float rx = xBin*ix + DX;
                 int rx0 = rx - 0.5;
                 int rx1 = rx + 0.5;
                 int ry0 = ry - 0.5;
                 int ry1 = ry + 0.5;
                 if (rx0 < 0) goto skip;
                 if (ry0 < 0) goto skip;
                 if (rx1 >= NX) goto skip;
                 if (ry1 >= NY) goto skip;
+                // these go from 0.0 to 1.0 between the centers of the pixels
                 float fx = rx - 0.5 - rx0;
                 float Fx = 1.0 - fx;
                 float fy = ry - 0.5 - ry0;
                 float Fy = 1.0 - fy;
                 // check the residual image mask (if set). give up if any of the 4 pixels are masked.
                 if (Rm) {
                     if (Rm[ry0][rx0]) goto skip;
                     if (Rm[ry0][rx1]) goto skip;
                     if (Rm[ry1][rx0]) goto skip;
                     if (Rm[ry1][rx1]) goto skip;
+                }
                 // a possible further optimization if we re-use these values
                 // XXX allow for masked pixels, and add pixel weights
                 float V0 = (Ro[ry0][rx0]*Fx + Ro[ry0][rx1]*fx);
                 float V1 = (Ro[ry1][rx0]*Fx + Ro[ry1][rx1]*fx);
                 float Vo = V0*Fy + V1*fy;
                 if (!isfinite(Vo)) goto skip;
                 float Vx = 0.0;
                 float Vy = 0.0;
                 // skip Rx,Ry if Ro is masked
                 if (Rx && Ry && (mode & PM_MODEL_OP_RES1)) {
                     V0 = (Rx[ry0][rx0]*Fx + Rx[ry0][rx1]*fx);
                     V1 = (Rx[ry1][rx0]*Fx + Rx[ry1][rx1]*fx);
                     Vx = V0*Fy + V1*fy;
                     V0 = (Ry[ry0][rx0]*Fx + Ry[ry0][rx1]*fx);
                     V1 = (Ry[ry1][rx0]*Fx + Ry[ry1][rx1]*fx);
                     Vy = V0*Fy + V1*fy;
+                }
                 if (!isfinite(Vx)) goto skip;
                 if (!isfinite(Vy)) goto skip;
                 // 2D residual variations are set for the true source position
                 pixelValue += Io*(Vo + XoSave*Vx + XoSave*Vy);
+                int rx0 = rx - 0.5;
+                int rx1 = rx + 0.5;
+                int ry0 = ry - 0.5;
+                int ry1 = ry + 0.5;
+                if (rx0 < 0) goto skip;
+                if (ry0 < 0) goto skip;
+                if (rx1 >= NX) goto skip;
+                if (ry1 >= NY) goto skip;
+                // these go from 0.0 to 1.0 between the centers of the pixels
+                float fx = rx - 0.5 - rx0;
+                float Fx = 1.0 - fx;
+                float fy = ry - 0.5 - ry0;
+                float Fy = 1.0 - fy;
+                // check the residual image mask (if set). give up if any of the 4 pixels are masked.
+                if (Rm) {
+                    if (Rm[ry0][rx0]) goto skip;
+                    if (Rm[ry0][rx1]) goto skip;
+                    if (Rm[ry1][rx0]) goto skip;
+                    if (Rm[ry1][rx1]) goto skip;
+                }
+                // a possible further optimization if we re-use these values
+                // XXX allow for masked pixels, and add pixel weights
+                float V0 = (Ro[ry0][rx0]*Fx + Ro[ry0][rx1]*fx);
+                float V1 = (Ro[ry1][rx0]*Fx + Ro[ry1][rx1]*fx);
+                float Vo = V0*Fy + V1*fy;
+                if (!isfinite(Vo)) goto skip;
+                float Vx = 0.0;
+                float Vy = 0.0;
+                // skip Rx,Ry if Ro is masked
+                if (Rx && Ry && (mode & PM_MODEL_OP_RES1)) {
+                    V0 = (Rx[ry0][rx0]*Fx + Rx[ry0][rx1]*fx);
+                    V1 = (Rx[ry1][rx0]*Fx + Rx[ry1][rx1]*fx);
+                    Vx = V0*Fy + V1*fy;
+                    V0 = (Ry[ry0][rx0]*Fx + Ry[ry0][rx1]*fx);
+                    V1 = (Ry[ry1][rx0]*Fx + Ry[ry1][rx1]*fx);
+                    Vy = V0*Fy + V1*fy;
+                }
+                if (!isfinite(Vx)) goto skip;
+                if (!isfinite(Vy)) goto skip;
+                // 2D residual variations are set for the true source position
+                pixelValue += Io*(Vo + XoSave*Vx + XoSave*Vy);
+            }
         skip:
+        skip:
             // add or subtract the value
             if (add) {

branches/cnb_branches/cnb_branch_20090215/psModules/src/objects/pmModel.h

-              r21536
+              r23197
  * @author EAM, IfA
+ *
  * @version $Revision: 1.18.8.1 $ $Name: not supported by cvs2svn $
  * @date $Date: 2009-02-19 17:59:50 $
+ * @version $Revision: 1.19 $ $Name: not supported by cvs2svn $
+ * @date $Date: 2009-02-16 22:30:50 $
+ *
  * Copyright 2004 Maui High Performance Computing Center, University of Hawaii
 …
     pmModel *model,                     ///< The input pmModel
     pmModelOpMode mode,                 ///< mode to control how the model is added into the image
     psImageMaskType maskVal             ///< Value to mask
+    psImageMaskType maskVal             ///< Value to mask
 );
 …
     pmModel *model,                     ///< The input pmModel
     pmModelOpMode mode,                 ///< mode to control how the model is added into the image
     psImageMaskType maskVal             ///< Value to mask
+    psImageMaskType maskVal             ///< Value to mask
 );

branches/cnb_branches/cnb_branch_20090215/psModules/src/objects/pmPeaks.c

-              r21536
+              r23197
  *  @author EAM, IfA: significant modifications.
+ *
  *  @version $Revision: 1.25.14.1 $ $Name: not supported by cvs2svn $
  *  @date $Date: 2009-02-19 17:59:50 $
+ *  @version $Revision: 1.26 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2009-02-16 22:30:14 $
+ *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
 …
 AddPeak(): A private function which allocates a psArray, if the peaks
 argument is NULL, otherwise it adds the peak to that array.
 XXX EAM : row,col now refer to image coords, NOT parent (since this is private)
+XXX EAM : row,col now refer to image coords, NOT parent (since this is private)
 XXX EAM : now also calculates fractional peak positions from 3x3 bicube region
 *****************************************************************************/
 …
         peak->yf = min.y + iy + image->row0;
+        // These errors are fractional errors, and should be scaled by the
         // error on the peak pixel (see, eg, psphotFindPeaks)
         peak->dx = min.xErr;
         peak->dy = min.yErr;
         // xf,yf must land on image with 0 pixel border
         peak->xf = PS_MAX (PS_MIN (peak->xf, image->numCols - 1), image->col0);
         peak->yf = PS_MAX (PS_MIN (peak->yf, image->numRows - 1), image->row0);
+        // These errors are fractional errors, and should be scaled by the
+        // error on the peak pixel (see, eg, psphotFindPeaks)
+        peak->dx = min.xErr;
+        peak->dy = min.yErr;
+        // xf,yf must land on image with 0 pixel border
+        peak->xf = PS_MAX (PS_MIN (peak->xf, image->numCols - 1), image->col0);
+        peak->yf = PS_MAX (PS_MIN (peak->yf, image->numRows - 1), image->row0);
     } else {
         peak->xf = ix;
         peak->yf = iy;
         peak->dx = NAN;
         peak->dy = NAN;
+        peak->dx = NAN;
+        peak->dy = NAN;
+    }
 …
 getRowVectorFromImage(): a private function which simply returns a
 psVector containing the specified row of data from the psImage.
 XXX: Is there a better way to do this?
 XXX EAM: does this really need to alloc a new vector???
 …
 above the given threshold.  Returns a vector of type PS_TYPE_U32 containing
 the location (x value) of all peaks.
 XXX: What types should be supported?  Only F32 is implemented.
 XXX: We currently step through the input vector twice; once to determine the
 size of the output vector, then to set the values of the output vector.
 …
 *****************************************************************************/
 psVector *pmPeaksInVector(const psVector *vector,
                          psF32 threshold)
+                         psF32 threshold)
+{
     psTrace("psModules.objects", 3, "---- %s() begin ----\n", __func__);
 …
 above the given threshold.  Returns a psArray containing location (x/y value)
 of all peaks.
 XXX: I'm not convinced the peak type definition in the SDRS is mutually
 exclusive.  Some peaks can have multiple types.  Edges for sure.  Also, a
 digonal line with the same value at each point will have a peak for every
 point on that line.
 XXX: This does not work if image has either a single row, or a single column.
 The peak is returned in the image parent coordinates

branches/cnb_branches/cnb_branch_20090215/psModules/src/objects/pmSource.c

-              r21536
+              r23197
  *  @author EAM, IfA: significant modifications.
+ *
  *  @version $Revision: 1.69.4.1 $ $Name: not supported by cvs2svn $
  *  @date $Date: 2009-02-19 17:59:50 $
+ *  @version $Revision: 1.70 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2009-02-16 22:29:59 $
+ *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
 …
         pmSource *source = (pmSource *) sources->data[i];
         // psf clumps are found for image subregions:
+        // skip sources not in this region
+        // psf clumps are found for image subregions:
+        // skip sources not in this region
         if (source->peak->x <  region->x0) continue;
         if (source->peak->x >= region->x1) continue;
         if (source->peak->y <  region->y0) continue;
         if (source->peak->y >= region->y1) continue;
         // should be set by pmSourceAlloc
+        if (source->peak->y >= region->y1) continue;
+        // should be set by pmSourceAlloc
         psAssert (source->type == PM_SOURCE_TYPE_UNKNOWN, "source type was not init-ed?");
 …
         if (!source->moments) {
             source->type = PM_SOURCE_TYPE_STAR;
             psAssert (source->mode & noMoments, "why is this source missing moments?");
+            psAssert (source->mode & noMoments, "why is this source missing moments?");
             Nstar++;
             continue;

branches/cnb_branches/cnb_branch_20090215/psModules/src/objects/pmSource.h

-              r21536
+              r23197
  * @author EAM, IfA; GLG, MHPCC
+ *
  * @version $Revision: 1.28.4.1 $ $Name: not supported by cvs2svn $
  * @date $Date: 2009-02-19 17:59:50 $
+ * @version $Revision: 1.29 $ $Name: not supported by cvs2svn $
+ * @date $Date: 2009-02-16 22:30:50 $
  * Copyright 2004 Maui High Performance Computing Center, University of Hawaii
  */
 …
 // bit flags to distinguish analysis results
 typedef enum {
     PM_SOURCE_MODE_DEFAULT          = 0x00000000, ///< Initial value: resets all bits
     PM_SOURCE_MODE_PSFMODEL         = 0x00000001, ///< Source fitted with a psf model (linear or non-linear)
     PM_SOURCE_MODE_EXTMODEL         = 0x00000002, ///< Source fitted with an extended-source model
     PM_SOURCE_MODE_FITTED           = 0x00000004, ///< Source fitted with non-linear model (PSF or EXT; good or bad)
     PM_SOURCE_MODE_FAIL             = 0x00000008, ///< Fit (non-linear) failed (non-converge, off-edge, run to zero)
     PM_SOURCE_MODE_POOR             = 0x00000010, ///< Fit succeeds, but low-SN, high-Chisq, or large (for PSF -- drop?)
     PM_SOURCE_MODE_PAIR             = 0x00000020, ///< Source fitted with a double psf
     PM_SOURCE_MODE_PSFSTAR          = 0x00000040, ///< Source used to define PSF model
     PM_SOURCE_MODE_SATSTAR          = 0x00000080, ///< Source model peak is above saturation
     PM_SOURCE_MODE_BLEND            = 0x00000100, ///< Source is a blend with other sourcers
     PM_SOURCE_MODE_EXTERNAL         = 0x00000200, ///< Source based on supplied input position
     PM_SOURCE_MODE_BADPSF           = 0x00000400, ///< Failed to get good estimate of object's PSF
     PM_SOURCE_MODE_DEFECT           = 0x00000800, ///< Source is thought to be a defect
     PM_SOURCE_MODE_SATURATED        = 0x00001000, ///< Source is thought to be saturated pixels (bleed trail)
     PM_SOURCE_MODE_CR_LIMIT         = 0x00002000, ///< Source has crNsigma above limit
     PM_SOURCE_MODE_EXT_LIMIT        = 0x00004000, ///< Source has extNsigma above limit
+    PM_SOURCE_MODE_DEFAULT          = 0x00000000, ///< Initial value: resets all bits
+    PM_SOURCE_MODE_PSFMODEL         = 0x00000001, ///< Source fitted with a psf model (linear or non-linear)
+    PM_SOURCE_MODE_EXTMODEL         = 0x00000002, ///< Source fitted with an extended-source model
+    PM_SOURCE_MODE_FITTED           = 0x00000004, ///< Source fitted with non-linear model (PSF or EXT; good or bad)
+    PM_SOURCE_MODE_FAIL             = 0x00000008, ///< Fit (non-linear) failed (non-converge, off-edge, run to zero)
+    PM_SOURCE_MODE_POOR             = 0x00000010, ///< Fit succeeds, but low-SN, high-Chisq, or large (for PSF -- drop?)
+    PM_SOURCE_MODE_PAIR             = 0x00000020, ///< Source fitted with a double psf
+    PM_SOURCE_MODE_PSFSTAR          = 0x00000040, ///< Source used to define PSF model
+    PM_SOURCE_MODE_SATSTAR          = 0x00000080, ///< Source model peak is above saturation
+    PM_SOURCE_MODE_BLEND            = 0x00000100, ///< Source is a blend with other sourcers
+    PM_SOURCE_MODE_EXTERNAL         = 0x00000200, ///< Source based on supplied input position
+    PM_SOURCE_MODE_BADPSF           = 0x00000400, ///< Failed to get good estimate of object's PSF
+    PM_SOURCE_MODE_DEFECT           = 0x00000800, ///< Source is thought to be a defect
+    PM_SOURCE_MODE_SATURATED        = 0x00001000, ///< Source is thought to be saturated pixels (bleed trail)
+    PM_SOURCE_MODE_CR_LIMIT         = 0x00002000, ///< Source has crNsigma above limit
+    PM_SOURCE_MODE_EXT_LIMIT        = 0x00004000, ///< Source has extNsigma above limit
     PM_SOURCE_MODE_MOMENTS_FAILURE  = 0x00008000, ///< could not measure the moments
     PM_SOURCE_MODE_SKY_FAILURE      = 0x00010000, ///< could not measure the local sky
 …
     pmSourceType type;                  ///< Best identification of object.
     pmSourceMode mode;                  ///< analysis flags set for object.
     pmSourceTmpF tmpFlags;              ///< internal-only flags
+    pmSourceTmpF tmpFlags;              ///< internal-only flags
     psArray *blends;                    ///< collection of sources thought to be confused with object
     float psfMag;                       ///< calculated from flux in modelPSF

branches/cnb_branches/cnb_branch_20090215/psModules/src/objects/pmSourceFitModel.c

r21536	r23197
6	6	* @author GLG, MHPCC
7	7	*
8		* @version $Revision: 1.3~~0.4.~~1 $ $Name: not supported by cvs2svn $
9		* @date $Date: 2009-02-1~~9 17:59:50~~ $
	8	* @version $Revision: 1.31 $ $Name: not supported by cvs2svn $
	9	* @date $Date: 2009-02-16 22:29:09 $
10	10	*
11	11	* Copyright 2004 Maui High Performance Computing Center, University of Hawaii

branches/cnb_branches/cnb_branch_20090215/psModules/src/objects/pmSourceIO.c

-              r21536
+              r23197
  *  @author EAM, IfA
+ *
  *  @version $Revision: 1.69.14.1 $ $Name: not supported by cvs2svn $
  *  @date $Date: 2009-02-19 17:59:50 $
+ *  @version $Revision: 1.70 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2009-02-16 22:30:50 $
+ *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
 …
 #include "pmFPAfile.h"
 #include "pmFPAfileFitsIO.h"
 #include "pmConcepts.h"
+#include "pmConceptsRead.h"
 #include "pmSpan.h"

branches/cnb_branches/cnb_branch_20090215/psModules/src/objects/pmSourceIO.h

r21536	r23197
4	4	* @author EAM, IfA; GLG, MHPCC
5	5	*
6		* @version $Revision: 1.~~19.16.1~~ $ $Name: not supported by cvs2svn $
7		* @date $Date: 2009-02-1~~9 17:59~~:50 $
	6	* @version $Revision: 1.20 $ $Name: not supported by cvs2svn $
	7	* @date $Date: 2009-02-16 22:30:50 $
8	8	* Copyright 2004 Maui High Performance Computing Center, University of Hawaii
9	9	*

branches/cnb_branches/cnb_branch_20090215/psModules/src/objects/pmSourceIO_CMF_PS1_V1.c

-              r21536
+              r23197
  *  @author EAM, IfA
+ *
  *  @version $Revision: 1.3.2.2 $ $Name: not supported by cvs2svn $
  *  @date $Date: 2009-02-19 17:59:50 $
+ *  @version $Revision: 1.3 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2009-02-18 02:44:19 $
+ *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
 …
 // followed by a zero-size matrix, followed by the table data
 bool pmSourcesWrite_CMF_PS1_V1 (psFits *fits, pmReadout *readout, psArray *sources,
                                 psMetadata *imageHeader, psMetadata *tableHeader, char *extname)
+bool pmSourcesWrite_CMF_PS1_V1 (psFits *fits, pmReadout *readout, psArray *sources,
+                                psMetadata *imageHeader, psMetadata *tableHeader, char *extname)
+{
     PS_ASSERT_PTR_NON_NULL(fits, false);
 …
     float zeroptErr = psMetadataLookupF32 (&status2, imageHeader, "ZPT_ERR");
     if (status1 && status2 && (exptime > 0.0)) {
         magOffset = zeropt + 2.5*log10(exptime);
+        magOffset = zeropt + 2.5*log10(exptime);
+    }
 …
     if (sources->n > 0) {
         pmSource *source = (pmSource *) sources->data[0];
         if (source->seq == -1) {
           // let's write these out in S/N order
           sources = psArraySort (sources, pmSourceSortBySN);
         } else {
           sources = psArraySort (sources, pmSourceSortBySeq);
+        }
+        if (source->seq == -1) {
+          // let's write these out in S/N order
+          sources = psArraySort (sources, pmSourceSortBySN);
+        } else {
+          sources = psArraySort (sources, pmSourceSortBySeq);
+        }
+    }
 …
         pmSource *source = (pmSource *) sources->data[i];
         // If source->seq is -1, source was generated in this analysis.  If source->seq is
         // not -1, source was read from elsewhere: in the latter case, preserve the source
         // ID.  source.seq is used instead of source.id since the latter is a const
         // generated on Alloc, and would thus be wrong for read in sources.
         if (source->seq == -1) {
           source->seq = i;
+        }
+        // If source->seq is -1, source was generated in this analysis.  If source->seq is
+        // not -1, source was read from elsewhere: in the latter case, preserve the source
+        // ID.  source.seq is used instead of source.id since the latter is a const
+        // generated on Alloc, and would thus be wrong for read in sources.
+        if (source->seq == -1) {
+          source->seq = i;
+        }
         // no difference between PSF and non-PSF model
 …
             xPos = PAR[PM_PAR_XPOS];
             yPos = PAR[PM_PAR_YPOS];
             if (source->mode & PM_SOURCE_MODE_NONLINEAR_FIT) {
               xErr = dPAR[PM_PAR_XPOS];
               yErr = dPAR[PM_PAR_YPOS];
             } else {
               // in linear-fit mode, there is no error on the centroid
               xErr = source->peak->dx;
               yErr = source->peak->dy;
+            }
             if (isfinite(PAR[PM_PAR_SXX]) && isfinite(PAR[PM_PAR_SXX]) && isfinite(PAR[PM_PAR_SXX])) {
                 axes = pmPSF_ModelToAxes (PAR, 20.0);
             } else {
                 axes.major = NAN;
                 axes.minor = NAN;
                 axes.theta = NAN;
+            }
             chisq = model->chisq;
             nDOF = model->nDOF;
             nPix = model->nPix;
             apRadius = model->radiusFit; // XXX should we really use the fitRadius for aperture Radius?
             errMag = model->dparams->data.F32[PM_PAR_I0] / model->params->data.F32[PM_PAR_I0];
+            if (source->mode & PM_SOURCE_MODE_NONLINEAR_FIT) {
+              xErr = dPAR[PM_PAR_XPOS];
+              yErr = dPAR[PM_PAR_YPOS];
+            } else {
+              // in linear-fit mode, there is no error on the centroid
+              xErr = source->peak->dx;
+              yErr = source->peak->dy;
+            }
+            if (isfinite(PAR[PM_PAR_SXX]) && isfinite(PAR[PM_PAR_SXX]) && isfinite(PAR[PM_PAR_SXX])) {
+                axes = pmPSF_ModelToAxes (PAR, 20.0);
+            } else {
+                axes.major = NAN;
+                axes.minor = NAN;
+                axes.theta = NAN;
+            }
+            chisq = model->chisq;
+            nDOF = model->nDOF;
+            nPix = model->nPix;
+            apRadius = model->radiusFit; // XXX should we really use the fitRadius for aperture Radius?
+            errMag = model->dparams->data.F32[PM_PAR_I0] / model->params->data.F32[PM_PAR_I0];
         } else {
             xPos = source->peak->xf;
 …
             axes.minor = NAN;
             axes.theta = NAN;
             chisq = NAN;
             nDOF = 0;
             nPix = 0;
             apRadius = NAN;
             errMag = NAN;
+        }
         float calMag = isfinite(magOffset) ? source->psfMag + magOffset : NAN;
+            chisq = NAN;
+            nDOF = 0;
+            nPix = 0;
+            apRadius = NAN;
+            errMag = NAN;
+        }
+        float calMag = isfinite(magOffset) ? source->psfMag + magOffset : NAN;
         float peakMag = (source->peak->flux > 0) ? -2.5*log10(source->peak->flux) : NAN;
         psS16 nImageOverlap = 1;
         psSphere ptSky = {0.0, 0.0, 0.0, 0.0};
         float posAngle = 0.0;
         float pltScale = 0.0;
         pmSourceLocalAstrometry (&ptSky, &posAngle, &pltScale, chip, xPos, yPos);
+        psSphere ptSky = {0.0, 0.0, 0.0, 0.0};
+        float posAngle = 0.0;
+        float pltScale = 0.0;
+        pmSourceLocalAstrometry (&ptSky, &posAngle, &pltScale, chip, xPos, yPos);
         row = psMetadataAlloc ();
 …
         psMetadataAdd (row, PS_LIST_TAIL, "PSF_NPIX",         PS_DATA_S32, "number of pixels in fit",                    nPix);
+        // distinguish moments measure from window vs S/N > XX ??
+        psMetadataAdd (row, PS_LIST_TAIL, "MOMENTS_XX",       PS_DATA_F32, "second moments (X^2)",                      source->moments->Mxx);
+        psMetadataAdd (row, PS_LIST_TAIL, "MOMENTS_XY",       PS_DATA_F32, "second moments (X*Y)",                      source->moments->Mxy);
+        psMetadataAdd (row, PS_LIST_TAIL, "MOMENTS_YY",       PS_DATA_F32, "second moments (Y*Y)",                      source->moments->Myy);
+        // distinguish moments measure from window vs S/N > XX ??
+        float mxx = source->moments ? source->moments->Mxx : NAN;
+        float mxy = source->moments ? source->moments->Mxy : NAN;
+        float myy = source->moments ? source->moments->Myy : NAN;
+        psMetadataAdd (row, PS_LIST_TAIL, "MOMENTS_XX",       PS_DATA_F32, "second moments (X^2)",                      mxx);
+        psMetadataAdd (row, PS_LIST_TAIL, "MOMENTS_XY",       PS_DATA_F32, "second moments (X*Y)",                      mxy);
+        psMetadataAdd (row, PS_LIST_TAIL, "MOMENTS_YY",       PS_DATA_F32, "second moments (Y*Y)",                      myy);
         psMetadataAdd (row, PS_LIST_TAIL, "FLAGS",            PS_DATA_U32, "psphot analysis flags",                      source->mode);
 …
         psFree (row);
         // EXT_NSIGMA will be NAN if: 1) contour ellipse is imaginary; 2) source is not
         // subtracted
         // CR_NSIGMA will be NAN if: 1) source is not subtracted; 2) source is on the image
+        // edge; 3) any pixels in the 3x3 peak region are masked;
+        // EXT_NSIGMA will be NAN if: 1) contour ellipse is imaginary; 2) source is not
+        // subtracted
+        // CR_NSIGMA will be NAN if: 1) source is not subtracted; 2) source is on the image
+        // edge; 3) any pixels in the 3x3 peak region are masked;
+    }
 …
         source->apMag     = psMetadataLookupF32 (&status, row, "AP_MAG");
+        // XXX this scaling is incorrect: does not include the 2 \pi AREA factor
         PAR[PM_PAR_I0]    = (isfinite(source->psfMag)) ? pow(10.0, -0.4*source->psfMag) : NAN;
         dPAR[PM_PAR_I0]   = (isfinite(source->psfMag)) ? PAR[PM_PAR_I0] * source->errMag : NAN;
+        // XXX this scaling is incorrect: does not include the 2 \pi AREA factor
+        PAR[PM_PAR_I0]    = (isfinite(source->psfMag)) ? pow(10.0, -0.4*source->psfMag) : NAN;
+        dPAR[PM_PAR_I0]   = (isfinite(source->psfMag)) ? PAR[PM_PAR_I0] * source->errMag : NAN;
         pmPSF_AxesToModel (PAR, axes);
 …
         float peakFlux    = (isfinite(peakMag)) ? pow(10.0, -0.4*peakMag) : NAN;
         // recreate the peak to match (xPos, yPos) +/- (xErr, yErr)
+        // recreate the peak to match (xPos, yPos) +/- (xErr, yErr)
         source->peak = pmPeakAlloc(PAR[PM_PAR_XPOS], PAR[PM_PAR_YPOS], peakFlux, PM_PEAK_LONE);
         source->peak->flux = peakFlux;
 …
         source->extNsigma = psMetadataLookupF32 (&status, row, "EXT_NSIGMA");
         // note that some older versions used PSF_PROBABILITY: this was not well defined.
         model->chisq      = psMetadataLookupF32 (&status, row, "PSF_CHISQ");
         model->nDOF       = psMetadataLookupS32 (&status, row, "PSF_NDOF");
         model->nPix       = psMetadataLookupS32 (&status, row, "PSF_NPIX");
+        // note that some older versions used PSF_PROBABILITY: this was not well defined.
+        model->chisq      = psMetadataLookupF32 (&status, row, "PSF_CHISQ");
+        model->nDOF       = psMetadataLookupS32 (&status, row, "PSF_NDOF");
+        model->nPix       = psMetadataLookupS32 (&status, row, "PSF_NPIX");
         model->radiusFit  = psMetadataLookupS32 (&status, row, "AP_MAG_RADIUS");
         source->moments = pmMomentsAlloc ();
+        source->moments = pmMomentsAlloc ();
         source->moments->Mxx = psMetadataLookupF32 (&status, row, "MOMENTS_XX");
         source->moments->Mxy = psMetadataLookupF32 (&status, row, "MOMENTS_XY");
 …
+}
 // XXX this layout is still the same as PS1_DEV_1
+// XXX this layout is still the same as PS1_DEV_1
 bool pmSourcesWrite_CMF_PS1_V1_XSRC (psFits *fits, psArray *sources, char *extname, psMetadata *recipe)
+{
 …
     // we write out all sources, regardless of quality.  the source flags tell us the state
     for (int i = 0; i < sources->n; i++) {
         // skip source if it is not a ext sourc
         // XXX we have two places that extended source parameters are measured:
         // psphotExtendedSources, which measures the aperture-like parameters and (potentially) the psf-convolved extended source models,
         // psphotFitEXT, which does the simple extended source model fit (not psf-convolved)
         // should we require both?
         pmSource *source = sources->data[i];
         // skip sources without measurements
         if (source->extpars == NULL) continue;
         // we require a PSF model fit (ignore the real crud)
         pmModel *model = source->modelPSF;
         if (model == NULL) continue;
         // XXX I need to split the extended models from the extended aperture measurements
         PAR = model->params->data.F32;
         dPAR = model->dparams->data.F32;
         xPos = PAR[PM_PAR_XPOS];
         yPos = PAR[PM_PAR_YPOS];
         xErr = dPAR[PM_PAR_XPOS];
         yErr = dPAR[PM_PAR_YPOS];
+        // skip source if it is not a ext sourc
+        // XXX we have two places that extended source parameters are measured:
+        // psphotExtendedSources, which measures the aperture-like parameters and (potentially) the psf-convolved extended source models,
+        // psphotFitEXT, which does the simple extended source model fit (not psf-convolved)
+        // should we require both?
+        pmSource *source = sources->data[i];
+        // skip sources without measurements
+        if (source->extpars == NULL) continue;
+        // we require a PSF model fit (ignore the real crud)
+        pmModel *model = source->modelPSF;
+        if (model == NULL) continue;
+        // XXX I need to split the extended models from the extended aperture measurements
+        PAR = model->params->data.F32;
+        dPAR = model->dparams->data.F32;
+        xPos = PAR[PM_PAR_XPOS];
+        yPos = PAR[PM_PAR_YPOS];
+        xErr = dPAR[PM_PAR_XPOS];
+        yErr = dPAR[PM_PAR_YPOS];
         row = psMetadataAlloc ();
 …
         psMetadataAdd (row, PS_LIST_TAIL, "Y_EXT_SIG",        PS_DATA_F32, "Sigma in EXT y coordinate",                  yErr);
         // Petrosian measurements
         // XXX insert header data: petrosian ref radius, flux ratio
         if (doPetrosian) {
             pmSourcePetrosianValues *petrosian = source->extpars->petrosian;
             if (petrosian) {
                 psMetadataAdd (row, PS_LIST_TAIL, "PETRO_MAG",        PS_DATA_F32, "Petrosian Magnitude",       petrosian->mag);
                 psMetadataAdd (row, PS_LIST_TAIL, "PETRO_MAG_ERR",    PS_DATA_F32, "Petrosian Magnitude Error", petrosian->magErr);
                 psMetadataAdd (row, PS_LIST_TAIL, "PETRO_RADIUS",     PS_DATA_F32, "Petrosian Radius",          petrosian->rad);
                 psMetadataAdd (row, PS_LIST_TAIL, "PETRO_RADIUS_ERR", PS_DATA_F32, "Petrosian Radius Error",    petrosian->radErr);
             } else {
                 psMetadataAdd (row, PS_LIST_TAIL, "PETRO_MAG",        PS_DATA_F32, "Petrosian Magnitude",       NAN);
                 psMetadataAdd (row, PS_LIST_TAIL, "PETRO_MAG_ERR",    PS_DATA_F32, "Petrosian Magnitude Error", NAN);
                 psMetadataAdd (row, PS_LIST_TAIL, "PETRO_RADIUS",     PS_DATA_F32, "Petrosian Radius",          NAN);
                 psMetadataAdd (row, PS_LIST_TAIL, "PETRO_RADIUS_ERR", PS_DATA_F32, "Petrosian Radius Error",    NAN);
+            }
+        }
         // Kron measurements
         if (doKron) {
             pmSourceKronValues *kron = source->extpars->kron;
             if (kron) {
                 psMetadataAdd (row, PS_LIST_TAIL, "KRON_MAG",        PS_DATA_F32, "Kron Magnitude",       kron->mag);
                 psMetadataAdd (row, PS_LIST_TAIL, "KRON_MAG_ERR",    PS_DATA_F32, "Kron Magnitude Error", kron->magErr);
                 psMetadataAdd (row, PS_LIST_TAIL, "KRON_RADIUS",     PS_DATA_F32, "Kron Radius",          kron->rad);
                 psMetadataAdd (row, PS_LIST_TAIL, "KRON_RADIUS_ERR", PS_DATA_F32, "Kron Radius Error",    kron->radErr);
             } else {
                 psMetadataAdd (row, PS_LIST_TAIL, "KRON_MAG",        PS_DATA_F32, "Kron Magnitude",       NAN);
                 psMetadataAdd (row, PS_LIST_TAIL, "KRON_MAG_ERR",    PS_DATA_F32, "Kron Magnitude Error", NAN);
                 psMetadataAdd (row, PS_LIST_TAIL, "KRON_RADIUS",     PS_DATA_F32, "Kron Radius",          NAN);
                 psMetadataAdd (row, PS_LIST_TAIL, "KRON_RADIUS_ERR", PS_DATA_F32, "Kron Radius Error",    NAN);
+            }
+        }
         // Isophot measurements
         // XXX insert header data: isophotal level
         if (doIsophotal) {
             pmSourceIsophotalValues *isophot = source->extpars->isophot;
             if (isophot) {
                 psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_MAG",        PS_DATA_F32, "Isophot Magnitude",       isophot->mag);
                 psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_MAG_ERR",    PS_DATA_F32, "Isophot Magnitude Error", isophot->magErr);
                 psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_RADIUS",     PS_DATA_F32, "Isophot Radius",          isophot->rad);
                 psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_RADIUS_ERR", PS_DATA_F32, "Isophot Radius Error",    isophot->radErr);
             } else {
                 psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_MAG",        PS_DATA_F32, "Isophot Magnitude",       NAN);
                 psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_MAG_ERR",    PS_DATA_F32, "Isophot Magnitude Error", NAN);
                 psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_RADIUS",     PS_DATA_F32, "Isophot Radius",          NAN);
                 psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_RADIUS_ERR", PS_DATA_F32, "Isophot Radius Error",    NAN);
+            }
+        }
         // Flux Annuli
         if (doAnnuli) {
             pmSourceAnnuli *annuli = source->extpars->annuli;
             if (annuli) {
                 psVector *fluxVal = annuli->flux;
                 psVector *fluxErr = annuli->fluxErr;
                 psVector *fluxVar = annuli->fluxVar;
                 for (int j = 0; j < fluxVal->n; j++) {
                     char name[32];
                     sprintf (name, "FLUX_VAL_R_%02d", j);
                     psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "flux value in annulus", fluxVal->data.F32[j]);
                     sprintf (name, "FLUX_ERR_R_%02d", j);
                     psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "flux error in annulus", fluxErr->data.F32[j]);
                     sprintf (name, "FLUX_VAR_R_%02d", j);
                     psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "flux stdev in annulus", fluxVar->data.F32[j]);
+                }
             } else {
                 for (int j = 0; j < radialBinsLower->n; j++) {
                     char name[32];
                     sprintf (name, "FLUX_VAL_R_%02d", j);
                     psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "flux value in annulus", NAN);
                     sprintf (name, "FLUX_ERR_R_%02d", j);
                     psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "flux error in annulus", NAN);
                     sprintf (name, "FLUX_VAR_R_%02d", j);
                     psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "flux stdev in annulus", NAN);
+                }
+            }
+        }
         psArrayAdd (table, 100, row);
         psFree (row);
+        // Petrosian measurements
+        // XXX insert header data: petrosian ref radius, flux ratio
+        if (doPetrosian) {
+            pmSourcePetrosianValues *petrosian = source->extpars->petrosian;
+            if (petrosian) {
+                psMetadataAdd (row, PS_LIST_TAIL, "PETRO_MAG",        PS_DATA_F32, "Petrosian Magnitude",       petrosian->mag);
+                psMetadataAdd (row, PS_LIST_TAIL, "PETRO_MAG_ERR",    PS_DATA_F32, "Petrosian Magnitude Error", petrosian->magErr);
+                psMetadataAdd (row, PS_LIST_TAIL, "PETRO_RADIUS",     PS_DATA_F32, "Petrosian Radius",          petrosian->rad);
+                psMetadataAdd (row, PS_LIST_TAIL, "PETRO_RADIUS_ERR", PS_DATA_F32, "Petrosian Radius Error",    petrosian->radErr);
+            } else {
+                psMetadataAdd (row, PS_LIST_TAIL, "PETRO_MAG",        PS_DATA_F32, "Petrosian Magnitude",       NAN);
+                psMetadataAdd (row, PS_LIST_TAIL, "PETRO_MAG_ERR",    PS_DATA_F32, "Petrosian Magnitude Error", NAN);
+                psMetadataAdd (row, PS_LIST_TAIL, "PETRO_RADIUS",     PS_DATA_F32, "Petrosian Radius",          NAN);
+                psMetadataAdd (row, PS_LIST_TAIL, "PETRO_RADIUS_ERR", PS_DATA_F32, "Petrosian Radius Error",    NAN);
+            }
+        }
+        // Kron measurements
+        if (doKron) {
+            pmSourceKronValues *kron = source->extpars->kron;
+            if (kron) {
+                psMetadataAdd (row, PS_LIST_TAIL, "KRON_MAG",        PS_DATA_F32, "Kron Magnitude",       kron->mag);
+                psMetadataAdd (row, PS_LIST_TAIL, "KRON_MAG_ERR",    PS_DATA_F32, "Kron Magnitude Error", kron->magErr);
+                psMetadataAdd (row, PS_LIST_TAIL, "KRON_RADIUS",     PS_DATA_F32, "Kron Radius",          kron->rad);
+                psMetadataAdd (row, PS_LIST_TAIL, "KRON_RADIUS_ERR", PS_DATA_F32, "Kron Radius Error",    kron->radErr);
+            } else {
+                psMetadataAdd (row, PS_LIST_TAIL, "KRON_MAG",        PS_DATA_F32, "Kron Magnitude",       NAN);
+                psMetadataAdd (row, PS_LIST_TAIL, "KRON_MAG_ERR",    PS_DATA_F32, "Kron Magnitude Error", NAN);
+                psMetadataAdd (row, PS_LIST_TAIL, "KRON_RADIUS",     PS_DATA_F32, "Kron Radius",          NAN);
+                psMetadataAdd (row, PS_LIST_TAIL, "KRON_RADIUS_ERR", PS_DATA_F32, "Kron Radius Error",    NAN);
+            }
+        }
+        // Isophot measurements
+        // XXX insert header data: isophotal level
+        if (doIsophotal) {
+            pmSourceIsophotalValues *isophot = source->extpars->isophot;
+            if (isophot) {
+                psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_MAG",        PS_DATA_F32, "Isophot Magnitude",       isophot->mag);
+                psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_MAG_ERR",    PS_DATA_F32, "Isophot Magnitude Error", isophot->magErr);
+                psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_RADIUS",     PS_DATA_F32, "Isophot Radius",          isophot->rad);
+                psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_RADIUS_ERR", PS_DATA_F32, "Isophot Radius Error",    isophot->radErr);
+            } else {
+                psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_MAG",        PS_DATA_F32, "Isophot Magnitude",       NAN);
+                psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_MAG_ERR",    PS_DATA_F32, "Isophot Magnitude Error", NAN);
+                psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_RADIUS",     PS_DATA_F32, "Isophot Radius",          NAN);
+                psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_RADIUS_ERR", PS_DATA_F32, "Isophot Radius Error",    NAN);
+            }
+        }
+        // Flux Annuli
+        if (doAnnuli) {
+            pmSourceAnnuli *annuli = source->extpars->annuli;
+            if (annuli) {
+                psVector *fluxVal = annuli->flux;
+                psVector *fluxErr = annuli->fluxErr;
+                psVector *fluxVar = annuli->fluxVar;
+                for (int j = 0; j < fluxVal->n; j++) {
+                    char name[32];
+                    sprintf (name, "FLUX_VAL_R_%02d", j);
+                    psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "flux value in annulus", fluxVal->data.F32[j]);
+                    sprintf (name, "FLUX_ERR_R_%02d", j);
+                    psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "flux error in annulus", fluxErr->data.F32[j]);
+                    sprintf (name, "FLUX_VAR_R_%02d", j);
+                    psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "flux stdev in annulus", fluxVar->data.F32[j]);
+                }
+            } else {
+                for (int j = 0; j < radialBinsLower->n; j++) {
+                    char name[32];
+                    sprintf (name, "FLUX_VAL_R_%02d", j);
+                    psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "flux value in annulus", NAN);
+                    sprintf (name, "FLUX_ERR_R_%02d", j);
+                    psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "flux error in annulus", NAN);
+                    sprintf (name, "FLUX_VAR_R_%02d", j);
+                    psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "flux stdev in annulus", NAN);
+                }
+            }
+        }
+        psArrayAdd (table, 100, row);
+        psFree (row);
+    }
     if (table->n == 0) {
         psFitsWriteBlank (fits, outhead, extname);
         psFree (outhead);
         psFree (table);
         return true;
+        psFitsWriteBlank (fits, outhead, extname);
+        psFree (outhead);
+        psFree (table);
+        return true;
+    }
     psTrace ("pmFPAfile", 5, "writing ext data %s\n", extname);
     if (!psFitsWriteTable (fits, outhead, table, extname)) {
         psError(PS_ERR_IO, false, "writing ext data %s\n", extname);
         psFree (outhead);
         psFree(table);
         return false;
+        psError(PS_ERR_IO, false, "writing ext data %s\n", extname);
+        psFree (outhead);
+        psFree(table);
+        return false;
+    }
     psFree (outhead);
 …
+}
 // XXX this layout is still the same as PS1_DEV_1
+// XXX this layout is still the same as PS1_DEV_1
 bool pmSourcesWrite_CMF_PS1_V1_XFIT (psFits *fits, psArray *sources, char *extname)
+{
 …
     int nParamMax = 0;
     for (int i = 0; i < sources->n; i++) {
         pmSource *source = sources->data[i];
         if (source->modelFits == NULL) continue;
         for (int j = 0; j < source->modelFits->n; j++) {
             pmModel *model = source->modelFits->data[j];
             assert (model);
             nParamMax = PS_MAX (nParamMax, model->params->n);
+        }
+        pmSource *source = sources->data[i];
+        if (source->modelFits == NULL) continue;
+        for (int j = 0; j < source->modelFits->n; j++) {
+            pmModel *model = source->modelFits->data[j];
+            assert (model);
+            nParamMax = PS_MAX (nParamMax, model->params->n);
+        }
+    }
 …
     for (int i = 0; i < sources->n; i++) {
         pmSource *source = sources->data[i];
         // XXX if no model fits are saved, write out modelEXT?
         if (source->modelFits == NULL) continue;
         // We have multiple sources : need to flag the one used to subtract the light (the 'best' model)
         for (int j = 0; j < source->modelFits->n; j++) {
             // choose the convolved EXT model, if available, otherwise the simple one
             pmModel *model = source->modelFits->data[j];
             assert (model);
             PAR = model->params->data.F32;
             dPAR = model->dparams->data.F32;
             xPos = PAR[PM_PAR_XPOS];
             yPos = PAR[PM_PAR_YPOS];
             xErr = dPAR[PM_PAR_XPOS];
             yErr = dPAR[PM_PAR_YPOS];
             axes = pmPSF_ModelToAxes (PAR, 20.0);
             row = psMetadataAlloc ();
             // XXX we are not writing out the mode (flags) or the type (psf, ext, etc)
             psMetadataAddU32 (row, PS_LIST_TAIL, "IPP_IDET",         0, "IPP detection identifier index",             source->seq);
             psMetadataAddF32 (row, PS_LIST_TAIL, "X_EXT",            0, "EXT model x coordinate",                     xPos);
             psMetadataAddF32 (row, PS_LIST_TAIL, "Y_EXT",            0, "EXT model y coordinate",                     yPos);
             psMetadataAddF32 (row, PS_LIST_TAIL, "X_EXT_SIG",        0, "Sigma in EXT x coordinate",                  xErr);
             psMetadataAddF32 (row, PS_LIST_TAIL, "Y_EXT_SIG",        0, "Sigma in EXT y coordinate",                  yErr);
             psMetadataAddF32 (row, PS_LIST_TAIL, "EXT_INST_MAG",     0, "EXT fit instrumental magnitude",             model->mag);
             psMetadataAddF32 (row, PS_LIST_TAIL, "EXT_INST_MAG_SIG", 0, "Sigma of PSF instrumental magnitude",        model->magErr);
             psMetadataAddF32 (row, PS_LIST_TAIL, "NPARAMS",          0, "number of model parameters",                 model->params->n);
             psMetadataAddStr (row, PS_LIST_TAIL, "MODEL_TYPE",       0, "name of model",                              pmModelClassGetName (model->type));
             // XXX these should be major and minor, not 'x' and 'y'
             psMetadataAddF32 (row, PS_LIST_TAIL, "EXT_WIDTH_MAJ",    0, "EXT width in x coordinate",                  axes.major);
             psMetadataAddF32 (row, PS_LIST_TAIL, "EXT_WIDTH_MIN",    0, "EXT width in y coordinate",                  axes.minor);
             psMetadataAddF32 (row, PS_LIST_TAIL, "EXT_THETA",        0, "EXT orientation angle",                      axes.theta);
             // write out the other generic parameters
             for (int k = 0; k < nParamMax; k++) {
                 if (k == PM_PAR_I0) continue;
                 if (k == PM_PAR_SKY) continue;
                 if (k == PM_PAR_XPOS) continue;
                 if (k == PM_PAR_YPOS) continue;
                 if (k == PM_PAR_SXX) continue;
                 if (k == PM_PAR_SXY) continue;
                 if (k == PM_PAR_SYY) continue;
                 snprintf (name, 64, "EXT_PAR_%02d", k);
                 if (k < model->params->n) {
                     psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "", model->params->data.F32[k]);
                 } else {
                     psMetadataAddF32 (row, PS_LIST_TAIL, name, PS_DATA_F32, "", NAN);
+                }
+            }
             // XXX other parameters which may be set.
             // XXX flag / value to define the model
             // XXX write out the model type, fit status flags
             psArrayAdd (table, 100, row);
             psFree (row);
+        }
+        pmSource *source = sources->data[i];
+        // XXX if no model fits are saved, write out modelEXT?
+        if (source->modelFits == NULL) continue;
+        // We have multiple sources : need to flag the one used to subtract the light (the 'best' model)
+        for (int j = 0; j < source->modelFits->n; j++) {
+            // choose the convolved EXT model, if available, otherwise the simple one
+            pmModel *model = source->modelFits->data[j];
+            assert (model);
+            PAR = model->params->data.F32;
+            dPAR = model->dparams->data.F32;
+            xPos = PAR[PM_PAR_XPOS];
+            yPos = PAR[PM_PAR_YPOS];
+            xErr = dPAR[PM_PAR_XPOS];
+            yErr = dPAR[PM_PAR_YPOS];
+            axes = pmPSF_ModelToAxes (PAR, 20.0);
+            row = psMetadataAlloc ();
+            // XXX we are not writing out the mode (flags) or the type (psf, ext, etc)
+            psMetadataAddU32 (row, PS_LIST_TAIL, "IPP_IDET",         0, "IPP detection identifier index",             source->seq);
+            psMetadataAddF32 (row, PS_LIST_TAIL, "X_EXT",            0, "EXT model x coordinate",                     xPos);
+            psMetadataAddF32 (row, PS_LIST_TAIL, "Y_EXT",            0, "EXT model y coordinate",                     yPos);
+            psMetadataAddF32 (row, PS_LIST_TAIL, "X_EXT_SIG",        0, "Sigma in EXT x coordinate",                  xErr);
+            psMetadataAddF32 (row, PS_LIST_TAIL, "Y_EXT_SIG",        0, "Sigma in EXT y coordinate",                  yErr);
+            psMetadataAddF32 (row, PS_LIST_TAIL, "EXT_INST_MAG",     0, "EXT fit instrumental magnitude",             model->mag);
+            psMetadataAddF32 (row, PS_LIST_TAIL, "EXT_INST_MAG_SIG", 0, "Sigma of PSF instrumental magnitude",        model->magErr);
+            psMetadataAddF32 (row, PS_LIST_TAIL, "NPARAMS",          0, "number of model parameters",                 model->params->n);
+            psMetadataAddStr (row, PS_LIST_TAIL, "MODEL_TYPE",       0, "name of model",                              pmModelClassGetName (model->type));
+            // XXX these should be major and minor, not 'x' and 'y'
+            psMetadataAddF32 (row, PS_LIST_TAIL, "EXT_WIDTH_MAJ",    0, "EXT width in x coordinate",                  axes.major);
+            psMetadataAddF32 (row, PS_LIST_TAIL, "EXT_WIDTH_MIN",    0, "EXT width in y coordinate",                  axes.minor);
+            psMetadataAddF32 (row, PS_LIST_TAIL, "EXT_THETA",        0, "EXT orientation angle",                      axes.theta);
+            // write out the other generic parameters
+            for (int k = 0; k < nParamMax; k++) {
+                if (k == PM_PAR_I0) continue;
+                if (k == PM_PAR_SKY) continue;
+                if (k == PM_PAR_XPOS) continue;
+                if (k == PM_PAR_YPOS) continue;
+                if (k == PM_PAR_SXX) continue;
+                if (k == PM_PAR_SXY) continue;
+                if (k == PM_PAR_SYY) continue;
+                snprintf (name, 64, "EXT_PAR_%02d", k);
+                if (k < model->params->n) {
+                    psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "", model->params->data.F32[k]);
+                } else {
+                    psMetadataAddF32 (row, PS_LIST_TAIL, name, PS_DATA_F32, "", NAN);
+                }
+            }
+            // XXX other parameters which may be set.
+            // XXX flag / value to define the model
+            // XXX write out the model type, fit status flags
+            psArrayAdd (table, 100, row);
+            psFree (row);
+        }
+    }
     if (table->n == 0) {
         psFitsWriteBlank (fits, outhead, extname);
         psFree (outhead);
         psFree (table);
         return true;
+        psFitsWriteBlank (fits, outhead, extname);
+        psFree (outhead);
+        psFree (table);
+        return true;
+    }
     psTrace ("pmFPAfile", 5, "writing ext data %s\n", extname);
     if (!psFitsWriteTable (fits, outhead, table, extname)) {
         psError(PS_ERR_IO, false, "writing ext data %s\n", extname);
         psFree (outhead);
         psFree(table);
         return false;
+        psError(PS_ERR_IO, false, "writing ext data %s\n", extname);
+        psFree (outhead);
+        psFree(table);
+        return false;
+    }
     psFree (outhead);
 …
     psPlaneTransformApply (&ptFP, chip->toFPA, &ptCH);
     psPlaneTransformApply (&ptTP_y, fpa->toTPA, &ptFP);
     // the resulting Tangent Plane coordinates are in TP pixels; convert to local Tangent Plane
     // degrees
 …
     *posAngle = NAN;
     *pltScale = NAN;
     return false;
+}

branches/cnb_branches/cnb_branch_20090215/psModules/src/objects/pmSourceIO_PS1_CAL_0.c

-              r21536
+              r23197
  *  @author EAM, IfA
+ *
  *  @version $Revision: 1.2.14.1 $ $Name: not supported by cvs2svn $
  *  @date $Date: 2009-02-19 17:59:50 $
+ *  @version $Revision: 1.3 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2009-02-16 22:30:50 $
+ *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
 …
 // XXX how do I generate the source tables which I need to send to PSPS?
 bool pmSourcesWrite_PS1_CAL_0 (psFits *fits, pmReadout *readout, psArray *sources,
                                psMetadata *imageHeader, psMetadata *tableHeader, char *extname)
+bool pmSourcesWrite_PS1_CAL_0 (psFits *fits, pmReadout *readout, psArray *sources,
+                               psMetadata *imageHeader, psMetadata *tableHeader, char *extname)
+{
     PS_ASSERT_PTR_NON_NULL(fits, false);
 …
     pmFPA  *fpa  = chip->parent;
     if (!chip->toFPA || !fpa->toTPA || !fpa->toSky) {
         psWarning ("astrometry calibration is missing, no calibrated coords");
+        psWarning ("astrometry calibration is missing, no calibrated coords");
+    }
 …
     float zeropt  = psMetadataLookupF32 (&status2, imageHeader, "ZPT_OBS");
     if (!status1 || !status2 || (exptime == 0.0)) {
         psWarning ("exposure time or measured zero point not found for a readout, no calibrated mags");
+        psWarning ("exposure time or measured zero point not found for a readout, no calibrated mags");
     } else {
         magOffset = zeropt + 2.5*log10(exptime);
+        magOffset = zeropt + 2.5*log10(exptime);
+    }
 …
     for (i = 0; i < sources->n; i++) {
         pmSource *source = (pmSource *) sources->data[i];
         if (source->seq == -1) {
             source->seq = i;
+        }
+        if (source->seq == -1) {
+            source->seq = i;
+        }
         // no difference between PSF and non-PSF model
 …
             xErr = dPAR[PM_PAR_XPOS];
             yErr = dPAR[PM_PAR_YPOS];
             if (isfinite(PAR[PM_PAR_SXX]) && isfinite(PAR[PM_PAR_SXX]) && isfinite(PAR[PM_PAR_SXX])) {
                 axes = pmPSF_ModelToAxes (PAR, 20.0);
             } else {
                 axes.major = NAN;
                 axes.minor = NAN;
                 axes.theta = NAN;
+            }
             chisq = model->chisq;
             // need to determine the PSF photometry error: source->errMag is the error on the 'best' model mag.
             errMag = model->dparams->data.F32[PM_PAR_I0] / model->params->data.F32[PM_PAR_I0];
+            if (isfinite(PAR[PM_PAR_SXX]) && isfinite(PAR[PM_PAR_SXX]) && isfinite(PAR[PM_PAR_SXX])) {
+                axes = pmPSF_ModelToAxes (PAR, 20.0);
+            } else {
+                axes.major = NAN;
+                axes.minor = NAN;
+                axes.theta = NAN;
+            }
+            chisq = model->chisq;
+            // need to determine the PSF photometry error: source->errMag is the error on the 'best' model mag.
+            errMag = model->dparams->data.F32[PM_PAR_I0] / model->params->data.F32[PM_PAR_I0];
         } else {
             xPos = source->peak->xf;
 …
             axes.minor = NAN;
             axes.theta = NAN;
             chisq = NAN;
             errMag = NAN;
+            chisq = NAN;
+            errMag = NAN;
+        }
         float calMag = source->psfMag + magOffset;
+        float calMag = source->psfMag + magOffset;
         float peakMag = (source->peak->flux > 0) ? -2.5*log10(source->peak->flux) : NAN;
         psS16 nImageOverlap = 1;
         // generate RA,DEC
         psPlane ptCH, ptFP, ptTP;
         psSphere ptSky;
         ptCH.x = xPos;
         ptCH.y = yPos;
         if (chip->toFPA && fpa->toTPA && fpa->toSky) {
             psPlaneTransformApply (&ptFP, chip->toFPA, &ptCH);
             psPlaneTransformApply (&ptTP, fpa->toTPA, &ptFP);
             psDeproject (&ptSky, &ptTP, fpa->toSky);
         } else {
             ptSky.r = NAN;
             ptSky.d = NAN;
+        }
+        // generate RA,DEC
+        psPlane ptCH, ptFP, ptTP;
+        psSphere ptSky;
+        ptCH.x = xPos;
+        ptCH.y = yPos;
+        if (chip->toFPA && fpa->toTPA && fpa->toSky) {
+            psPlaneTransformApply (&ptFP, chip->toFPA, &ptCH);
+            psPlaneTransformApply (&ptTP, fpa->toTPA, &ptFP);
+            psDeproject (&ptSky, &ptTP, fpa->toSky);
+        } else {
+            ptSky.r = NAN;
+            ptSky.d = NAN;
+        }
         row = psMetadataAlloc ();
 …
         psMetadataAdd (row, PS_LIST_TAIL, "RA_PSF",           PS_DATA_F32, "PSF RA coordinate (degrees)",                ptSky.r*PS_DEG_RAD);
         psMetadataAdd (row, PS_LIST_TAIL, "DEC_PSF",          PS_DATA_F32, "PSF DEC coordinate (degrees)",               ptSky.d*PS_DEG_RAD);
         // XXX need to do the error propagation correctly..
+        // XXX need to do the error propagation correctly..
         // psMetadataAdd (row, PS_LIST_TAIL, "RA_PSF_SIG",       PS_DATA_F32, "Sigma of PSF fit RA",                     dRA);
         // psMetadataAdd (row, PS_LIST_TAIL, "DEC_PSF_SIG",      PS_DATA_F32, "Sigma of PSF fit DEC",                    dDEC);
 …
         psMetadataAdd (row, PS_LIST_TAIL, "EXT_NSIGMA",       PS_DATA_F32,  "Nsigma deviations from PSF to EXT",         source->extNsigma);
         // EXT_NSIGMA will be NAN if: 1) contour ellipse is imaginary; 2) source is not
         // subtracted
         // CR_NSIGMA will be NAN if: 1) source is not subtracted; 2) source is on the image
+        // edge; 3) any pixels in the 3x3 peak region are masked;
+        // EXT_NSIGMA will be NAN if: 1) contour ellipse is imaginary; 2) source is not
+        // subtracted
+        // CR_NSIGMA will be NAN if: 1) source is not subtracted; 2) source is on the image
+        // edge; 3) any pixels in the 3x3 peak region are masked;
         // XXX these should be major and minor, not 'x' and 'y'
 …
         source->psfMag    = psMetadataLookupF32 (&status, row, "PSF_INST_MAG");
         source->errMag    = psMetadataLookupF32 (&status, row, "PSF_INST_MAG_SIG");
         PAR[PM_PAR_I0]    = (isfinite(source->psfMag)) ? pow(10.0, -0.4*source->psfMag) : NAN;
         dPAR[PM_PAR_I0]   = (isfinite(source->psfMag)) ? PAR[PM_PAR_I0] * source->errMag : NAN;
+        PAR[PM_PAR_I0]    = (isfinite(source->psfMag)) ? pow(10.0, -0.4*source->psfMag) : NAN;
+        dPAR[PM_PAR_I0]   = (isfinite(source->psfMag)) ? PAR[PM_PAR_I0] * source->errMag : NAN;
         pmPSF_AxesToModel (PAR, axes);
 …
         source->pixWeight = psMetadataLookupF32 (&status, row, "PSF_QF");
         // note that some older versions used PSF_PROBABILITY: this was not well defined.
+        // note that some older versions used PSF_PROBABILITY: this was not well defined.
         model->chisq      = psMetadataLookupF32 (&status, row, "PSF_CHISQ");
         source->crNsigma  = psMetadataLookupF32 (&status, row, "CR_NSIGMA");
 …
     pmFPA  *fpa  = chip->parent;
     if (!chip->toFPA || !fpa->toTPA || !fpa->toSky) {
         psWarning ("astrometry calibration is missing, no calibrated coords");
+        psWarning ("astrometry calibration is missing, no calibrated coords");
+    }
 …
     float zeropt  = psMetadataLookupF32 (&status2, imageHeader, "ZPT_OBS");
     if (!status1 || !status2 || (exptime == 0.0)) {
         psWarning ("exposure time or measured zero point not found for a readout, no calibrated mags");
+        psWarning ("exposure time or measured zero point not found for a readout, no calibrated mags");
     } else {
         magOffset = zeropt + 2.5*log10(exptime);
         calMags = true;
+        magOffset = zeropt + 2.5*log10(exptime);
+        calMags = true;
+    }
 …
     // we write out all sources, regardless of quality.  the source flags tell us the state
     for (int i = 0; i < sources->n; i++) {
         // skip source if it is not a ext sourc
         // XXX we have two places that extended source parameters are measured:
         // psphotExtendedSources, which measures the aperture-like parameters and (potentially) the psf-convolved extended source models,
         // psphotFitEXT, which does the simple extended source model fit (not psf-convolved)
         // should we require both?
         pmSource *source = sources->data[i];
         // skip sources without measurements
         if (source->extpars == NULL) continue;
         // we require a PSF model fit (ignore the real crud)
         pmModel *model = source->modelPSF;
         if (model == NULL) continue;
         // XXX I need to split the extended models from the extended aperture measurements
         PAR = model->params->data.F32;
         dPAR = model->dparams->data.F32;
         xPos = PAR[PM_PAR_XPOS];
         yPos = PAR[PM_PAR_YPOS];
         xErr = dPAR[PM_PAR_XPOS];
         yErr = dPAR[PM_PAR_YPOS];
         // generate RA,DEC
         psPlane ptCH, ptFP, ptTP;
         psSphere ptSky;
         ptCH.x = xPos;
         ptCH.y = yPos;
         if (chip->toFPA && fpa->toTPA && fpa->toSky) {
             psPlaneTransformApply (&ptFP, chip->toFPA, &ptCH);
             psPlaneTransformApply (&ptTP, fpa->toTPA, &ptFP);
             psDeproject (&ptSky, &ptTP, fpa->toSky);
         } else {
             ptSky.r = NAN;
             ptSky.d = NAN;
+        }
+        // skip source if it is not a ext sourc
+        // XXX we have two places that extended source parameters are measured:
+        // psphotExtendedSources, which measures the aperture-like parameters and (potentially) the psf-convolved extended source models,
+        // psphotFitEXT, which does the simple extended source model fit (not psf-convolved)
+        // should we require both?
+        pmSource *source = sources->data[i];
+        // skip sources without measurements
+        if (source->extpars == NULL) continue;
+        // we require a PSF model fit (ignore the real crud)
+        pmModel *model = source->modelPSF;
+        if (model == NULL) continue;
+        // XXX I need to split the extended models from the extended aperture measurements
+        PAR = model->params->data.F32;
+        dPAR = model->dparams->data.F32;
+        xPos = PAR[PM_PAR_XPOS];
+        yPos = PAR[PM_PAR_YPOS];
+        xErr = dPAR[PM_PAR_XPOS];
+        yErr = dPAR[PM_PAR_YPOS];
+        // generate RA,DEC
+        psPlane ptCH, ptFP, ptTP;
+        psSphere ptSky;
+        ptCH.x = xPos;
+        ptCH.y = yPos;
+        if (chip->toFPA && fpa->toTPA && fpa->toSky) {
+            psPlaneTransformApply (&ptFP, chip->toFPA, &ptCH);
+            psPlaneTransformApply (&ptTP, fpa->toTPA, &ptFP);
+            psDeproject (&ptSky, &ptTP, fpa->toSky);
+        } else {
+            ptSky.r = NAN;
+            ptSky.d = NAN;
+        }
         row = psMetadataAlloc ();
 …
         psMetadataAdd (row, PS_LIST_TAIL, "Y_EXT_SIG",        PS_DATA_F32, "Sigma in EXT y coordinate",                  yErr);
         // Petrosian measurements
         // XXX insert header data: petrosian ref radius, flux ratio
         if (doPetrosian) {
             pmSourcePetrosianValues *petrosian = source->extpars->petrosian;
             if (petrosian) {
                 if (calMags) {
                     psMetadataAdd (row, PS_LIST_TAIL, "PETRO_MAG_CAL",    PS_DATA_F32, "Petrosian Magnitude (calibrated)", petrosian->mag + magOffset);
                 } else {
                     psMetadataAdd (row, PS_LIST_TAIL, "PETRO_MAG_INST",   PS_DATA_F32, "Petrosian Magnitude (instrumental)", petrosian->mag);
+                }
                 psMetadataAdd (row, PS_LIST_TAIL, "PETRO_MAG_ERR",    PS_DATA_F32, "Petrosian Magnitude Error", petrosian->magErr);
                 psMetadataAdd (row, PS_LIST_TAIL, "PETRO_RADIUS",     PS_DATA_F32, "Petrosian Radius",          petrosian->rad);
                 psMetadataAdd (row, PS_LIST_TAIL, "PETRO_RADIUS_ERR", PS_DATA_F32, "Petrosian Radius Error",    petrosian->radErr);
             } else {
                 psMetadataAdd (row, PS_LIST_TAIL, "PETRO_MAG",        PS_DATA_F32, "Petrosian Magnitude",       NAN);
                 psMetadataAdd (row, PS_LIST_TAIL, "PETRO_MAG_ERR",    PS_DATA_F32, "Petrosian Magnitude Error", NAN);
                 psMetadataAdd (row, PS_LIST_TAIL, "PETRO_RADIUS",     PS_DATA_F32, "Petrosian Radius",          NAN);
                 psMetadataAdd (row, PS_LIST_TAIL, "PETRO_RADIUS_ERR", PS_DATA_F32, "Petrosian Radius Error",    NAN);
+            }
+        }
         // Kron measurements
         if (doKron) {
             pmSourceKronValues *kron = source->extpars->kron;
             if (kron) {
                 if (calMags) {
                     psMetadataAdd (row, PS_LIST_TAIL, "KRON_MAG_CAL",  PS_DATA_F32, "Kron Magnitude",     kron->mag + magOffset);
                 } else {
                     psMetadataAdd (row, PS_LIST_TAIL, "KRON_MAG_INST", PS_DATA_F32, "Kron Magnitude",     kron->mag);
+                }
                 psMetadataAdd (row, PS_LIST_TAIL, "KRON_MAG_ERR",    PS_DATA_F32, "Kron Magnitude Error", kron->magErr);
                 psMetadataAdd (row, PS_LIST_TAIL, "KRON_RADIUS",     PS_DATA_F32, "Kron Radius",          kron->rad);
                 psMetadataAdd (row, PS_LIST_TAIL, "KRON_RADIUS_ERR", PS_DATA_F32, "Kron Radius Error",    kron->radErr);
             } else {
                 psMetadataAdd (row, PS_LIST_TAIL, "KRON_MAG",        PS_DATA_F32, "Kron Magnitude",       NAN);
                 psMetadataAdd (row, PS_LIST_TAIL, "KRON_MAG_ERR",    PS_DATA_F32, "Kron Magnitude Error", NAN);
                 psMetadataAdd (row, PS_LIST_TAIL, "KRON_RADIUS",     PS_DATA_F32, "Kron Radius",          NAN);
                 psMetadataAdd (row, PS_LIST_TAIL, "KRON_RADIUS_ERR", PS_DATA_F32, "Kron Radius Error",    NAN);
+            }
+        }
         // Isophot measurements
         // XXX insert header data: isophotal level
         if (doIsophotal) {
             pmSourceIsophotalValues *isophot = source->extpars->isophot;
             if (isophot) {
                 if (calMags) {
                     psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_MAG_CAL",    PS_DATA_F32, "Isophot Magnitude (calibrated)",   isophot->mag + magOffset);
                 } else {
                     psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_MAG_INST",   PS_DATA_F32, "Isophot Magnitude (uncalibrated)", isophot->mag);
+                }
                 psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_MAG_ERR",    PS_DATA_F32, "Isophot Magnitude Error", isophot->magErr);
                 psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_RADIUS",     PS_DATA_F32, "Isophot Radius",          isophot->rad);
                 psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_RADIUS_ERR", PS_DATA_F32, "Isophot Radius Error",    isophot->radErr);
             } else {
                 psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_MAG",        PS_DATA_F32, "Isophot Magnitude",       NAN);
                 psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_MAG_ERR",    PS_DATA_F32, "Isophot Magnitude Error", NAN);
                 psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_RADIUS",     PS_DATA_F32, "Isophot Radius",          NAN);
                 psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_RADIUS_ERR", PS_DATA_F32, "Isophot Radius Error",    NAN);
+            }
+        }
         // Flux Annuli
         if (doAnnuli) {
             pmSourceAnnuli *annuli = source->extpars->annuli;
             if (annuli) {
                 psVector *fluxVal = annuli->flux;
                 psVector *fluxErr = annuli->fluxErr;
                 psVector *fluxVar = annuli->fluxVar;
                 for (int j = 0; j < fluxVal->n; j++) {
                     char name[32];
                     sprintf (name, "FLUX_VAL_R_%02d", j);
                     psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "flux value in annulus", fluxVal->data.F32[j]);
                     sprintf (name, "FLUX_ERR_R_%02d", j);
                     psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "flux error in annulus", fluxErr->data.F32[j]);
                     sprintf (name, "FLUX_VAR_R_%02d", j);
                     psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "flux stdev in annulus", fluxVar->data.F32[j]);
+                }
             } else {
                 for (int j = 0; j < radialBinsLower->n; j++) {
                     char name[32];
                     sprintf (name, "FLUX_VAL_R_%02d", j);
                     psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "flux value in annulus", NAN);
                     sprintf (name, "FLUX_ERR_R_%02d", j);
                     psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "flux error in annulus", NAN);
                     sprintf (name, "FLUX_VAR_R_%02d", j);
                     psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "flux stdev in annulus", NAN);
+                }
+            }
+        }
         psArrayAdd (table, 100, row);
         psFree (row);
+        // Petrosian measurements
+        // XXX insert header data: petrosian ref radius, flux ratio
+        if (doPetrosian) {
+            pmSourcePetrosianValues *petrosian = source->extpars->petrosian;
+            if (petrosian) {
+                if (calMags) {
+                    psMetadataAdd (row, PS_LIST_TAIL, "PETRO_MAG_CAL",    PS_DATA_F32, "Petrosian Magnitude (calibrated)", petrosian->mag + magOffset);
+                } else {
+                    psMetadataAdd (row, PS_LIST_TAIL, "PETRO_MAG_INST",   PS_DATA_F32, "Petrosian Magnitude (instrumental)", petrosian->mag);
+                }
+                psMetadataAdd (row, PS_LIST_TAIL, "PETRO_MAG_ERR",    PS_DATA_F32, "Petrosian Magnitude Error", petrosian->magErr);
+                psMetadataAdd (row, PS_LIST_TAIL, "PETRO_RADIUS",     PS_DATA_F32, "Petrosian Radius",          petrosian->rad);
+                psMetadataAdd (row, PS_LIST_TAIL, "PETRO_RADIUS_ERR", PS_DATA_F32, "Petrosian Radius Error",    petrosian->radErr);
+            } else {
+                psMetadataAdd (row, PS_LIST_TAIL, "PETRO_MAG",        PS_DATA_F32, "Petrosian Magnitude",       NAN);
+                psMetadataAdd (row, PS_LIST_TAIL, "PETRO_MAG_ERR",    PS_DATA_F32, "Petrosian Magnitude Error", NAN);
+                psMetadataAdd (row, PS_LIST_TAIL, "PETRO_RADIUS",     PS_DATA_F32, "Petrosian Radius",          NAN);
+                psMetadataAdd (row, PS_LIST_TAIL, "PETRO_RADIUS_ERR", PS_DATA_F32, "Petrosian Radius Error",    NAN);
+            }
+        }
+        // Kron measurements
+        if (doKron) {
+            pmSourceKronValues *kron = source->extpars->kron;
+            if (kron) {
+                if (calMags) {
+                    psMetadataAdd (row, PS_LIST_TAIL, "KRON_MAG_CAL",  PS_DATA_F32, "Kron Magnitude",     kron->mag + magOffset);
+                } else {
+                    psMetadataAdd (row, PS_LIST_TAIL, "KRON_MAG_INST", PS_DATA_F32, "Kron Magnitude",     kron->mag);
+                }
+                psMetadataAdd (row, PS_LIST_TAIL, "KRON_MAG_ERR",    PS_DATA_F32, "Kron Magnitude Error", kron->magErr);
+                psMetadataAdd (row, PS_LIST_TAIL, "KRON_RADIUS",     PS_DATA_F32, "Kron Radius",          kron->rad);
+                psMetadataAdd (row, PS_LIST_TAIL, "KRON_RADIUS_ERR", PS_DATA_F32, "Kron Radius Error",    kron->radErr);
+            } else {
+                psMetadataAdd (row, PS_LIST_TAIL, "KRON_MAG",        PS_DATA_F32, "Kron Magnitude",       NAN);
+                psMetadataAdd (row, PS_LIST_TAIL, "KRON_MAG_ERR",    PS_DATA_F32, "Kron Magnitude Error", NAN);
+                psMetadataAdd (row, PS_LIST_TAIL, "KRON_RADIUS",     PS_DATA_F32, "Kron Radius",          NAN);
+                psMetadataAdd (row, PS_LIST_TAIL, "KRON_RADIUS_ERR", PS_DATA_F32, "Kron Radius Error",    NAN);
+            }
+        }
+        // Isophot measurements
+        // XXX insert header data: isophotal level
+        if (doIsophotal) {
+            pmSourceIsophotalValues *isophot = source->extpars->isophot;
+            if (isophot) {
+                if (calMags) {
+                    psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_MAG_CAL",    PS_DATA_F32, "Isophot Magnitude (calibrated)",   isophot->mag + magOffset);
+                } else {
+                    psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_MAG_INST",   PS_DATA_F32, "Isophot Magnitude (uncalibrated)", isophot->mag);
+                }
+                psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_MAG_ERR",    PS_DATA_F32, "Isophot Magnitude Error", isophot->magErr);
+                psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_RADIUS",     PS_DATA_F32, "Isophot Radius",          isophot->rad);
+                psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_RADIUS_ERR", PS_DATA_F32, "Isophot Radius Error",    isophot->radErr);
+            } else {
+                psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_MAG",        PS_DATA_F32, "Isophot Magnitude",       NAN);
+                psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_MAG_ERR",    PS_DATA_F32, "Isophot Magnitude Error", NAN);
+                psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_RADIUS",     PS_DATA_F32, "Isophot Radius",          NAN);
+                psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_RADIUS_ERR", PS_DATA_F32, "Isophot Radius Error",    NAN);
+            }
+        }
+        // Flux Annuli
+        if (doAnnuli) {
+            pmSourceAnnuli *annuli = source->extpars->annuli;
+            if (annuli) {
+                psVector *fluxVal = annuli->flux;
+                psVector *fluxErr = annuli->fluxErr;
+                psVector *fluxVar = annuli->fluxVar;
+                for (int j = 0; j < fluxVal->n; j++) {
+                    char name[32];
+                    sprintf (name, "FLUX_VAL_R_%02d", j);
+                    psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "flux value in annulus", fluxVal->data.F32[j]);
+                    sprintf (name, "FLUX_ERR_R_%02d", j);
+                    psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "flux error in annulus", fluxErr->data.F32[j]);
+                    sprintf (name, "FLUX_VAR_R_%02d", j);
+                    psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "flux stdev in annulus", fluxVar->data.F32[j]);
+                }
+            } else {
+                for (int j = 0; j < radialBinsLower->n; j++) {
+                    char name[32];
+                    sprintf (name, "FLUX_VAL_R_%02d", j);
+                    psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "flux value in annulus", NAN);
+                    sprintf (name, "FLUX_ERR_R_%02d", j);
+                    psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "flux error in annulus", NAN);
+                    sprintf (name, "FLUX_VAR_R_%02d", j);
+                    psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "flux stdev in annulus", NAN);
+                }
+            }
+        }
+        psArrayAdd (table, 100, row);
+        psFree (row);
+    }
     if (table->n == 0) {
         psFitsWriteBlank (fits, outhead, extname);
         psFree (outhead);
         psFree (table);
         return true;
+        psFitsWriteBlank (fits, outhead, extname);
+        psFree (outhead);
+        psFree (table);
+        return true;
+    }
     psTrace ("pmFPAfile", 5, "writing ext data %s\n", extname);
     if (!psFitsWriteTable (fits, outhead, table, extname)) {
         psError(PS_ERR_IO, false, "writing ext data %s\n", extname);
         psFree (outhead);
         psFree(table);
         return false;
+        psError(PS_ERR_IO, false, "writing ext data %s\n", extname);
+        psFree (outhead);
+        psFree(table);
+        return false;
+    }
     psFree (outhead);
 …
     pmFPA  *fpa  = chip->parent;
     if (!chip->toFPA || !fpa->toTPA || !fpa->toSky) {
         psWarning ("astrometry calibration is missing, no calibrated coords");
+        psWarning ("astrometry calibration is missing, no calibrated coords");
+    }
 …
     float zeropt  = psMetadataLookupF32 (&status2, imageHeader, "ZPT_OBS");
     if (!status1 || !status2 || (exptime == 0.0)) {
         psWarning ("exposure time or measured zero point not found for a readout, no calibrated mags");
+        psWarning ("exposure time or measured zero point not found for a readout, no calibrated mags");
     } else {
         magOffset = zeropt + 2.5*log10(exptime);
+        magOffset = zeropt + 2.5*log10(exptime);
+    }
 …
     int nParamMax = 0;
     for (int i = 0; i < sources->n; i++) {
         pmSource *source = sources->data[i];
         if (source->modelFits == NULL) continue;
         for (int j = 0; j < source->modelFits->n; j++) {
             pmModel *model = source->modelFits->data[j];
             assert (model);
             nParamMax = PS_MAX (nParamMax, model->params->n);
+        }
+        pmSource *source = sources->data[i];
+        if (source->modelFits == NULL) continue;
+        for (int j = 0; j < source->modelFits->n; j++) {
+            pmModel *model = source->modelFits->data[j];
+            assert (model);
+            nParamMax = PS_MAX (nParamMax, model->params->n);
+        }
+    }
 …
     for (int i = 0; i < sources->n; i++) {
         pmSource *source = sources->data[i];
         // XXX if no model fits are saved, write out modelEXT?
         if (source->modelFits == NULL) continue;
         // We have multiple sources : need to flag the one used to subtract the light (the 'best' model)
         for (int j = 0; j < source->modelFits->n; j++) {
             // choose the convolved EXT model, if available, otherwise the simple one
             pmModel *model = source->modelFits->data[j];
             assert (model);
             PAR = model->params->data.F32;
             dPAR = model->dparams->data.F32;
             xPos = PAR[PM_PAR_XPOS];
             yPos = PAR[PM_PAR_YPOS];
             xErr = dPAR[PM_PAR_XPOS];
             yErr = dPAR[PM_PAR_YPOS];
             axes = pmPSF_ModelToAxes (PAR, 20.0);
             // generate RA,DEC
             psPlane ptCH, ptFP, ptTP;
             psSphere ptSky;
             ptCH.x = xPos;
             ptCH.y = yPos;
             if (chip->toFPA && fpa->toTPA && fpa->toSky) {
                 psPlaneTransformApply (&ptFP, chip->toFPA, &ptCH);
                 psPlaneTransformApply (&ptTP, fpa->toTPA, &ptFP);
                 psDeproject (&ptSky, &ptTP, fpa->toSky);
             } else {
                 ptSky.r = NAN;
                 ptSky.d = NAN;
+            }
             row = psMetadataAlloc ();
             // XXX we are not writing out the mode (flags) or the type (psf, ext, etc)
             psMetadataAddU32 (row, PS_LIST_TAIL, "IPP_IDET",         0, "IPP detection identifier index",             source->seq);
             psMetadataAddF32 (row, PS_LIST_TAIL, "RA_EXT",           0, "EXT model RA (degrees)",                     ptSky.r);
             psMetadataAddF32 (row, PS_LIST_TAIL, "DEC_EXT",          0, "EXT model DEC (degrees)",                    ptSky.d);
             psMetadataAddF32 (row, PS_LIST_TAIL, "X_EXT",            0, "EXT model x coordinate",                     xPos);
             psMetadataAddF32 (row, PS_LIST_TAIL, "Y_EXT",            0, "EXT model y coordinate",                     yPos);
             psMetadataAddF32 (row, PS_LIST_TAIL, "X_EXT_SIG",        0, "Sigma in EXT x coordinate",                  xErr);
             psMetadataAddF32 (row, PS_LIST_TAIL, "Y_EXT_SIG",        0, "Sigma in EXT y coordinate",                  yErr);
             psMetadataAddF32 (row, PS_LIST_TAIL, "EXT_CAL_MAG",      0, "EXT fit calibrated magnitude",               model->mag + magOffset);
             psMetadataAddF32 (row, PS_LIST_TAIL, "EXT_INST_MAG",     0, "EXT fit instrumental magnitude",             model->mag);
             psMetadataAddF32 (row, PS_LIST_TAIL, "EXT_INST_MAG_SIG", 0, "Sigma of PSF instrumental magnitude",        model->magErr);
             psMetadataAddF32 (row, PS_LIST_TAIL, "NPARAMS",          0, "number of model parameters",                 model->params->n);
             psMetadataAddStr (row, PS_LIST_TAIL, "MODEL_TYPE",       0, "name of model",                              pmModelClassGetName (model->type));
             // XXX these should be major and minor, not 'x' and 'y'
             psMetadataAddF32 (row, PS_LIST_TAIL, "EXT_WIDTH_MAJ",    0, "EXT width in x coordinate",                  axes.major);
             psMetadataAddF32 (row, PS_LIST_TAIL, "EXT_WIDTH_MIN",    0, "EXT width in y coordinate",                  axes.minor);
             psMetadataAddF32 (row, PS_LIST_TAIL, "EXT_THETA",        0, "EXT orientation angle",                      axes.theta);
             // write out the other generic parameters
             for (int k = 0; k < nParamMax; k++) {
                 if (k == PM_PAR_I0) continue;
                 if (k == PM_PAR_SKY) continue;
                 if (k == PM_PAR_XPOS) continue;
                 if (k == PM_PAR_YPOS) continue;
                 if (k == PM_PAR_SXX) continue;
                 if (k == PM_PAR_SXY) continue;
                 if (k == PM_PAR_SYY) continue;
                 snprintf (name, 64, "EXT_PAR_%02d", k);
                 if (k < model->params->n) {
                     psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "", model->params->data.F32[k]);
                 } else {
                     psMetadataAddF32 (row, PS_LIST_TAIL, name, PS_DATA_F32, "", NAN);
+                }
+            }
             // XXX other parameters which may be set.
             // XXX flag / value to define the model
             // XXX write out the model type, fit status flags
             psArrayAdd (table, 100, row);
             psFree (row);
+        }
+        pmSource *source = sources->data[i];
+        // XXX if no model fits are saved, write out modelEXT?
+        if (source->modelFits == NULL) continue;
+        // We have multiple sources : need to flag the one used to subtract the light (the 'best' model)
+        for (int j = 0; j < source->modelFits->n; j++) {
+            // choose the convolved EXT model, if available, otherwise the simple one
+            pmModel *model = source->modelFits->data[j];
+            assert (model);
+            PAR = model->params->data.F32;
+            dPAR = model->dparams->data.F32;
+            xPos = PAR[PM_PAR_XPOS];
+            yPos = PAR[PM_PAR_YPOS];
+            xErr = dPAR[PM_PAR_XPOS];
+            yErr = dPAR[PM_PAR_YPOS];
+            axes = pmPSF_ModelToAxes (PAR, 20.0);
+            // generate RA,DEC
+            psPlane ptCH, ptFP, ptTP;
+            psSphere ptSky;
+            ptCH.x = xPos;
+            ptCH.y = yPos;
+            if (chip->toFPA && fpa->toTPA && fpa->toSky) {
+                psPlaneTransformApply (&ptFP, chip->toFPA, &ptCH);
+                psPlaneTransformApply (&ptTP, fpa->toTPA, &ptFP);
+                psDeproject (&ptSky, &ptTP, fpa->toSky);
+            } else {
+                ptSky.r = NAN;
+                ptSky.d = NAN;
+            }
+            row = psMetadataAlloc ();
+            // XXX we are not writing out the mode (flags) or the type (psf, ext, etc)
+            psMetadataAddU32 (row, PS_LIST_TAIL, "IPP_IDET",         0, "IPP detection identifier index",             source->seq);
+            psMetadataAddF32 (row, PS_LIST_TAIL, "RA_EXT",           0, "EXT model RA (degrees)",                     ptSky.r);
+            psMetadataAddF32 (row, PS_LIST_TAIL, "DEC_EXT",          0, "EXT model DEC (degrees)",                    ptSky.d);
+            psMetadataAddF32 (row, PS_LIST_TAIL, "X_EXT",            0, "EXT model x coordinate",                     xPos);
+            psMetadataAddF32 (row, PS_LIST_TAIL, "Y_EXT",            0, "EXT model y coordinate",                     yPos);
+            psMetadataAddF32 (row, PS_LIST_TAIL, "X_EXT_SIG",        0, "Sigma in EXT x coordinate",                  xErr);
+            psMetadataAddF32 (row, PS_LIST_TAIL, "Y_EXT_SIG",        0, "Sigma in EXT y coordinate",                  yErr);
+            psMetadataAddF32 (row, PS_LIST_TAIL, "EXT_CAL_MAG",      0, "EXT fit calibrated magnitude",               model->mag + magOffset);
+            psMetadataAddF32 (row, PS_LIST_TAIL, "EXT_INST_MAG",     0, "EXT fit instrumental magnitude",             model->mag);
+            psMetadataAddF32 (row, PS_LIST_TAIL, "EXT_INST_MAG_SIG", 0, "Sigma of PSF instrumental magnitude",        model->magErr);
+            psMetadataAddF32 (row, PS_LIST_TAIL, "NPARAMS",          0, "number of model parameters",                 model->params->n);
+            psMetadataAddStr (row, PS_LIST_TAIL, "MODEL_TYPE",       0, "name of model",                              pmModelClassGetName (model->type));
+            // XXX these should be major and minor, not 'x' and 'y'
+            psMetadataAddF32 (row, PS_LIST_TAIL, "EXT_WIDTH_MAJ",    0, "EXT width in x coordinate",                  axes.major);
+            psMetadataAddF32 (row, PS_LIST_TAIL, "EXT_WIDTH_MIN",    0, "EXT width in y coordinate",                  axes.minor);
+            psMetadataAddF32 (row, PS_LIST_TAIL, "EXT_THETA",        0, "EXT orientation angle",                      axes.theta);
+            // write out the other generic parameters
+            for (int k = 0; k < nParamMax; k++) {
+                if (k == PM_PAR_I0) continue;
+                if (k == PM_PAR_SKY) continue;
+                if (k == PM_PAR_XPOS) continue;
+                if (k == PM_PAR_YPOS) continue;
+                if (k == PM_PAR_SXX) continue;
+                if (k == PM_PAR_SXY) continue;
+                if (k == PM_PAR_SYY) continue;
+                snprintf (name, 64, "EXT_PAR_%02d", k);
+                if (k < model->params->n) {
+                    psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "", model->params->data.F32[k]);
+                } else {
+                    psMetadataAddF32 (row, PS_LIST_TAIL, name, PS_DATA_F32, "", NAN);
+                }
+            }
+            // XXX other parameters which may be set.
+            // XXX flag / value to define the model
+            // XXX write out the model type, fit status flags
+            psArrayAdd (table, 100, row);
+            psFree (row);
+        }
+    }
     if (table->n == 0) {
         psFitsWriteBlank (fits, outhead, extname);
         psFree (outhead);
         psFree (table);
         return true;
+        psFitsWriteBlank (fits, outhead, extname);
+        psFree (outhead);
+        psFree (table);
+        return true;
+    }
     psTrace ("pmFPAfile", 5, "writing ext data %s\n", extname);
     if (!psFitsWriteTable (fits, outhead, table, extname)) {
         psError(PS_ERR_IO, false, "writing ext data %s\n", extname);
         psFree (outhead);
         psFree(table);
         return false;
+        psError(PS_ERR_IO, false, "writing ext data %s\n", extname);
+        psFree (outhead);
+        psFree(table);
+        return false;
+    }
     psFree (outhead);

branches/cnb_branches/cnb_branch_20090215/psModules/src/objects/pmSourceIO_PS1_DEV_1.c

-              r21536
+              r23197
  *  @author EAM, IfA
+ *
  *  @version $Revision: 1.14.14.1 $ $Name: not supported by cvs2svn $
  *  @date $Date: 2009-02-19 17:59:50 $
+ *  @version $Revision: 1.15 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2009-02-16 22:30:50 $
+ *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
 …
 // XXX how do I generate the source tables which I need to send to PSPS?
 bool pmSourcesWrite_PS1_DEV_1 (psFits *fits, psArray *sources,
                                psMetadata *imageHeader, psMetadata *tableHeader, char *extname)
+bool pmSourcesWrite_PS1_DEV_1 (psFits *fits, psArray *sources,
+                               psMetadata *imageHeader, psMetadata *tableHeader, char *extname)
+{
     PS_ASSERT_PTR_NON_NULL(fits, false);
 …
     for (i = 0; i < sources->n; i++) {
         pmSource *source = (pmSource *) sources->data[i];
         if (source->seq == -1) {
             source->seq = i;
+        }
+        if (source->seq == -1) {
+            source->seq = i;
+        }
         // no difference between PSF and non-PSF model
 …
             xErr = dPAR[PM_PAR_XPOS];
             yErr = dPAR[PM_PAR_YPOS];
             if (isfinite(PAR[PM_PAR_SXX]) && isfinite(PAR[PM_PAR_SXX]) && isfinite(PAR[PM_PAR_SXX])) {
                 axes = pmPSF_ModelToAxes (PAR, 20.0);
             } else {
                 axes.major = NAN;
                 axes.minor = NAN;
                 axes.theta = NAN;
+            }
             chisq = model->chisq;
             // need to determine the PSF photometry error: source->errMag is the error on the 'best' model mag.
             errMag = model->dparams->data.F32[PM_PAR_I0] / model->params->data.F32[PM_PAR_I0];
+            if (isfinite(PAR[PM_PAR_SXX]) && isfinite(PAR[PM_PAR_SXX]) && isfinite(PAR[PM_PAR_SXX])) {
+                axes = pmPSF_ModelToAxes (PAR, 20.0);
+            } else {
+                axes.major = NAN;
+                axes.minor = NAN;
+                axes.theta = NAN;
+            }
+            chisq = model->chisq;
+            // need to determine the PSF photometry error: source->errMag is the error on the 'best' model mag.
+            errMag = model->dparams->data.F32[PM_PAR_I0] / model->params->data.F32[PM_PAR_I0];
         } else {
             xPos = source->peak->xf;
 …
             axes.minor = NAN;
             axes.theta = NAN;
             chisq = NAN;
             errMag = NAN;
+            chisq = NAN;
+            errMag = NAN;
+        }
 …
         psMetadataAdd (row, PS_LIST_TAIL, "EXT_NSIGMA",       PS_DATA_F32,  "Nsigma deviations from PSF to EXT",         source->extNsigma);
         // EXT_NSIGMA will be NAN if: 1) contour ellipse is imaginary; 2) source is not
         // subtracted
         // CR_NSIGMA will be NAN if: 1) source is not subtracted; 2) source is on the image
+        // edge; 3) any pixels in the 3x3 peak region are masked;
+        // CR_NSIGMA and
+        // EXT_NSIGMA will be NAN if: 1) contour ellipse is imaginary; 2) source is not
+        // subtracted
+        // CR_NSIGMA will be NAN if: 1) source is not subtracted; 2) source is on the image
+        // edge; 3) any pixels in the 3x3 peak region are masked;
+        // CR_NSIGMA and
         // XXX these should be major and minor, not 'x' and 'y'
 …
         source->psfMag    = psMetadataLookupF32 (&status, row, "PSF_INST_MAG");
         source->errMag    = psMetadataLookupF32 (&status, row, "PSF_INST_MAG_SIG");
         PAR[PM_PAR_I0]    = (isfinite(source->psfMag)) ? pow(10.0, -0.4*source->psfMag) : NAN;
         dPAR[PM_PAR_I0]   = (isfinite(source->psfMag)) ? PAR[PM_PAR_I0] * source->errMag : NAN;
+        PAR[PM_PAR_I0]    = (isfinite(source->psfMag)) ? pow(10.0, -0.4*source->psfMag) : NAN;
+        dPAR[PM_PAR_I0]   = (isfinite(source->psfMag)) ? PAR[PM_PAR_I0] * source->errMag : NAN;
         pmPSF_AxesToModel (PAR, axes);
 …
         source->pixWeight = psMetadataLookupF32 (&status, row, "PSF_QF");
         // note that some older versions used PSF_PROBABILITY: this was not well defined.
+        // note that some older versions used PSF_PROBABILITY: this was not well defined.
         model->chisq      = psMetadataLookupF32 (&status, row, "PSF_CHISQ");
         source->crNsigma  = psMetadataLookupF32 (&status, row, "CR_NSIGMA");
 …
     // we write out all sources, regardless of quality.  the source flags tell us the state
     for (int i = 0; i < sources->n; i++) {
         // skip source if it is not a ext sourc
         // XXX we have two places that extended source parameters are measured:
         // psphotExtendedSources, which measures the aperture-like parameters and (potentially) the psf-convolved extended source models,
         // psphotFitEXT, which does the simple extended source model fit (not psf-convolved)
         // should we require both?
         pmSource *source = sources->data[i];
         // skip sources without measurements
         if (source->extpars == NULL) continue;
         // we require a PSF model fit (ignore the real crud)
         pmModel *model = source->modelPSF;
         if (model == NULL) continue;
         // XXX I need to split the extended models from the extended aperture measurements
         PAR = model->params->data.F32;
         dPAR = model->dparams->data.F32;
         xPos = PAR[PM_PAR_XPOS];
         yPos = PAR[PM_PAR_YPOS];
         xErr = dPAR[PM_PAR_XPOS];
         yErr = dPAR[PM_PAR_YPOS];
+        // skip source if it is not a ext sourc
+        // XXX we have two places that extended source parameters are measured:
+        // psphotExtendedSources, which measures the aperture-like parameters and (potentially) the psf-convolved extended source models,
+        // psphotFitEXT, which does the simple extended source model fit (not psf-convolved)
+        // should we require both?
+        pmSource *source = sources->data[i];
+        // skip sources without measurements
+        if (source->extpars == NULL) continue;
+        // we require a PSF model fit (ignore the real crud)
+        pmModel *model = source->modelPSF;
+        if (model == NULL) continue;
+        // XXX I need to split the extended models from the extended aperture measurements
+        PAR = model->params->data.F32;
+        dPAR = model->dparams->data.F32;
+        xPos = PAR[PM_PAR_XPOS];
+        yPos = PAR[PM_PAR_YPOS];
+        xErr = dPAR[PM_PAR_XPOS];
+        yErr = dPAR[PM_PAR_YPOS];
         row = psMetadataAlloc ();
 …
         psMetadataAdd (row, PS_LIST_TAIL, "Y_EXT_SIG",        PS_DATA_F32, "Sigma in EXT y coordinate",                  yErr);
         // Petrosian measurements
         // XXX insert header data: petrosian ref radius, flux ratio
         if (doPetrosian) {
             pmSourcePetrosianValues *petrosian = source->extpars->petrosian;
             if (petrosian) {
                 psMetadataAdd (row, PS_LIST_TAIL, "PETRO_MAG",        PS_DATA_F32, "Petrosian Magnitude",       petrosian->mag);
                 psMetadataAdd (row, PS_LIST_TAIL, "PETRO_MAG_ERR",    PS_DATA_F32, "Petrosian Magnitude Error", petrosian->magErr);
                 psMetadataAdd (row, PS_LIST_TAIL, "PETRO_RADIUS",     PS_DATA_F32, "Petrosian Radius",          petrosian->rad);
                 psMetadataAdd (row, PS_LIST_TAIL, "PETRO_RADIUS_ERR", PS_DATA_F32, "Petrosian Radius Error",    petrosian->radErr);
             } else {
                 psMetadataAdd (row, PS_LIST_TAIL, "PETRO_MAG",        PS_DATA_F32, "Petrosian Magnitude",       NAN);
                 psMetadataAdd (row, PS_LIST_TAIL, "PETRO_MAG_ERR",    PS_DATA_F32, "Petrosian Magnitude Error", NAN);
                 psMetadataAdd (row, PS_LIST_TAIL, "PETRO_RADIUS",     PS_DATA_F32, "Petrosian Radius",          NAN);
                 psMetadataAdd (row, PS_LIST_TAIL, "PETRO_RADIUS_ERR", PS_DATA_F32, "Petrosian Radius Error",    NAN);
+            }
+        }
         // Kron measurements
         if (doKron) {
             pmSourceKronValues *kron = source->extpars->kron;
             if (kron) {
                 psMetadataAdd (row, PS_LIST_TAIL, "KRON_MAG",        PS_DATA_F32, "Kron Magnitude",       kron->mag);
                 psMetadataAdd (row, PS_LIST_TAIL, "KRON_MAG_ERR",    PS_DATA_F32, "Kron Magnitude Error", kron->magErr);
                 psMetadataAdd (row, PS_LIST_TAIL, "KRON_RADIUS",     PS_DATA_F32, "Kron Radius",          kron->rad);
                 psMetadataAdd (row, PS_LIST_TAIL, "KRON_RADIUS_ERR", PS_DATA_F32, "Kron Radius Error",    kron->radErr);
             } else {
                 psMetadataAdd (row, PS_LIST_TAIL, "KRON_MAG",        PS_DATA_F32, "Kron Magnitude",       NAN);
                 psMetadataAdd (row, PS_LIST_TAIL, "KRON_MAG_ERR",    PS_DATA_F32, "Kron Magnitude Error", NAN);
                 psMetadataAdd (row, PS_LIST_TAIL, "KRON_RADIUS",     PS_DATA_F32, "Kron Radius",          NAN);
                 psMetadataAdd (row, PS_LIST_TAIL, "KRON_RADIUS_ERR", PS_DATA_F32, "Kron Radius Error",    NAN);
+            }
+        }
         // Isophot measurements
         // XXX insert header data: isophotal level
         if (doIsophotal) {
             pmSourceIsophotalValues *isophot = source->extpars->isophot;
             if (isophot) {
                 psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_MAG",        PS_DATA_F32, "Isophot Magnitude",       isophot->mag);
                 psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_MAG_ERR",    PS_DATA_F32, "Isophot Magnitude Error", isophot->magErr);
                 psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_RADIUS",     PS_DATA_F32, "Isophot Radius",          isophot->rad);
                 psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_RADIUS_ERR", PS_DATA_F32, "Isophot Radius Error",    isophot->radErr);
             } else {
                 psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_MAG",        PS_DATA_F32, "Isophot Magnitude",       NAN);
                 psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_MAG_ERR",    PS_DATA_F32, "Isophot Magnitude Error", NAN);
                 psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_RADIUS",     PS_DATA_F32, "Isophot Radius",          NAN);
                 psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_RADIUS_ERR", PS_DATA_F32, "Isophot Radius Error",    NAN);
+            }
+        }
         // Flux Annuli
         if (doAnnuli) {
             pmSourceAnnuli *annuli = source->extpars->annuli;
             if (annuli) {
                 psVector *fluxVal = annuli->flux;
                 psVector *fluxErr = annuli->fluxErr;
                 psVector *fluxVar = annuli->fluxVar;
                 for (int j = 0; j < fluxVal->n; j++) {
                     char name[32];
                     sprintf (name, "FLUX_VAL_R_%02d", j);
                     psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "flux value in annulus", fluxVal->data.F32[j]);
                     sprintf (name, "FLUX_ERR_R_%02d", j);
                     psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "flux error in annulus", fluxErr->data.F32[j]);
                     sprintf (name, "FLUX_VAR_R_%02d", j);
                     psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "flux stdev in annulus", fluxVar->data.F32[j]);
+                }
             } else {
                 for (int j = 0; j < radialBinsLower->n; j++) {
                     char name[32];
                     sprintf (name, "FLUX_VAL_R_%02d", j);
                     psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "flux value in annulus", NAN);
                     sprintf (name, "FLUX_ERR_R_%02d", j);
                     psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "flux error in annulus", NAN);
                     sprintf (name, "FLUX_VAR_R_%02d", j);
                     psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "flux stdev in annulus", NAN);
+                }
+            }
+        }
         psArrayAdd (table, 100, row);
         psFree (row);
+        // Petrosian measurements
+        // XXX insert header data: petrosian ref radius, flux ratio
+        if (doPetrosian) {
+            pmSourcePetrosianValues *petrosian = source->extpars->petrosian;
+            if (petrosian) {
+                psMetadataAdd (row, PS_LIST_TAIL, "PETRO_MAG",        PS_DATA_F32, "Petrosian Magnitude",       petrosian->mag);
+                psMetadataAdd (row, PS_LIST_TAIL, "PETRO_MAG_ERR",    PS_DATA_F32, "Petrosian Magnitude Error", petrosian->magErr);
+                psMetadataAdd (row, PS_LIST_TAIL, "PETRO_RADIUS",     PS_DATA_F32, "Petrosian Radius",          petrosian->rad);
+                psMetadataAdd (row, PS_LIST_TAIL, "PETRO_RADIUS_ERR", PS_DATA_F32, "Petrosian Radius Error",    petrosian->radErr);
+            } else {
+                psMetadataAdd (row, PS_LIST_TAIL, "PETRO_MAG",        PS_DATA_F32, "Petrosian Magnitude",       NAN);
+                psMetadataAdd (row, PS_LIST_TAIL, "PETRO_MAG_ERR",    PS_DATA_F32, "Petrosian Magnitude Error", NAN);
+                psMetadataAdd (row, PS_LIST_TAIL, "PETRO_RADIUS",     PS_DATA_F32, "Petrosian Radius",          NAN);
+                psMetadataAdd (row, PS_LIST_TAIL, "PETRO_RADIUS_ERR", PS_DATA_F32, "Petrosian Radius Error",    NAN);
+            }
+        }
+        // Kron measurements
+        if (doKron) {
+            pmSourceKronValues *kron = source->extpars->kron;
+            if (kron) {
+                psMetadataAdd (row, PS_LIST_TAIL, "KRON_MAG",        PS_DATA_F32, "Kron Magnitude",       kron->mag);
+                psMetadataAdd (row, PS_LIST_TAIL, "KRON_MAG_ERR",    PS_DATA_F32, "Kron Magnitude Error", kron->magErr);
+                psMetadataAdd (row, PS_LIST_TAIL, "KRON_RADIUS",     PS_DATA_F32, "Kron Radius",          kron->rad);
+                psMetadataAdd (row, PS_LIST_TAIL, "KRON_RADIUS_ERR", PS_DATA_F32, "Kron Radius Error",    kron->radErr);
+            } else {
+                psMetadataAdd (row, PS_LIST_TAIL, "KRON_MAG",        PS_DATA_F32, "Kron Magnitude",       NAN);
+                psMetadataAdd (row, PS_LIST_TAIL, "KRON_MAG_ERR",    PS_DATA_F32, "Kron Magnitude Error", NAN);
+                psMetadataAdd (row, PS_LIST_TAIL, "KRON_RADIUS",     PS_DATA_F32, "Kron Radius",          NAN);
+                psMetadataAdd (row, PS_LIST_TAIL, "KRON_RADIUS_ERR", PS_DATA_F32, "Kron Radius Error",    NAN);
+            }
+        }
+        // Isophot measurements
+        // XXX insert header data: isophotal level
+        if (doIsophotal) {
+            pmSourceIsophotalValues *isophot = source->extpars->isophot;
+            if (isophot) {
+                psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_MAG",        PS_DATA_F32, "Isophot Magnitude",       isophot->mag);
+                psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_MAG_ERR",    PS_DATA_F32, "Isophot Magnitude Error", isophot->magErr);
+                psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_RADIUS",     PS_DATA_F32, "Isophot Radius",          isophot->rad);
+                psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_RADIUS_ERR", PS_DATA_F32, "Isophot Radius Error",    isophot->radErr);
+            } else {
+                psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_MAG",        PS_DATA_F32, "Isophot Magnitude",       NAN);
+                psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_MAG_ERR",    PS_DATA_F32, "Isophot Magnitude Error", NAN);
+                psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_RADIUS",     PS_DATA_F32, "Isophot Radius",          NAN);
+                psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_RADIUS_ERR", PS_DATA_F32, "Isophot Radius Error",    NAN);
+            }
+        }
+        // Flux Annuli
+        if (doAnnuli) {
+            pmSourceAnnuli *annuli = source->extpars->annuli;
+            if (annuli) {
+                psVector *fluxVal = annuli->flux;
+                psVector *fluxErr = annuli->fluxErr;
+                psVector *fluxVar = annuli->fluxVar;
+                for (int j = 0; j < fluxVal->n; j++) {
+                    char name[32];
+                    sprintf (name, "FLUX_VAL_R_%02d", j);
+                    psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "flux value in annulus", fluxVal->data.F32[j]);
+                    sprintf (name, "FLUX_ERR_R_%02d", j);
+                    psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "flux error in annulus", fluxErr->data.F32[j]);
+                    sprintf (name, "FLUX_VAR_R_%02d", j);
+                    psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "flux stdev in annulus", fluxVar->data.F32[j]);
+                }
+            } else {
+                for (int j = 0; j < radialBinsLower->n; j++) {
+                    char name[32];
+                    sprintf (name, "FLUX_VAL_R_%02d", j);
+                    psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "flux value in annulus", NAN);
+                    sprintf (name, "FLUX_ERR_R_%02d", j);
+                    psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "flux error in annulus", NAN);
+                    sprintf (name, "FLUX_VAR_R_%02d", j);
+                    psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "flux stdev in annulus", NAN);
+                }
+            }
+        }
+        psArrayAdd (table, 100, row);
+        psFree (row);
+    }
     if (table->n == 0) {
         psFitsWriteBlank (fits, outhead, extname);
         psFree (outhead);
         psFree (table);
         return true;
+        psFitsWriteBlank (fits, outhead, extname);
+        psFree (outhead);
+        psFree (table);
+        return true;
+    }
     psTrace ("pmFPAfile", 5, "writing ext data %s\n", extname);
     if (!psFitsWriteTable (fits, outhead, table, extname)) {
         psError(PS_ERR_IO, false, "writing ext data %s\n", extname);
         psFree (outhead);
         psFree(table);
         return false;
+        psError(PS_ERR_IO, false, "writing ext data %s\n", extname);
+        psFree (outhead);
+        psFree(table);
+        return false;
+    }
     psFree (outhead);
 …
     int nParamMax = 0;
     for (int i = 0; i < sources->n; i++) {
         pmSource *source = sources->data[i];
         if (source->modelFits == NULL) continue;
         for (int j = 0; j < source->modelFits->n; j++) {
             pmModel *model = source->modelFits->data[j];
             assert (model);
             nParamMax = PS_MAX (nParamMax, model->params->n);
+        }
+        pmSource *source = sources->data[i];
+        if (source->modelFits == NULL) continue;
+        for (int j = 0; j < source->modelFits->n; j++) {
+            pmModel *model = source->modelFits->data[j];
+            assert (model);
+            nParamMax = PS_MAX (nParamMax, model->params->n);
+        }
+    }
 …
     for (int i = 0; i < sources->n; i++) {
         pmSource *source = sources->data[i];
         // XXX if no model fits are saved, write out modelEXT?
         if (source->modelFits == NULL) continue;
         // We have multiple sources : need to flag the one used to subtract the light (the 'best' model)
         for (int j = 0; j < source->modelFits->n; j++) {
             // choose the convolved EXT model, if available, otherwise the simple one
             pmModel *model = source->modelFits->data[j];
             assert (model);
             PAR = model->params->data.F32;
             dPAR = model->dparams->data.F32;
             xPos = PAR[PM_PAR_XPOS];
             yPos = PAR[PM_PAR_YPOS];
             xErr = dPAR[PM_PAR_XPOS];
             yErr = dPAR[PM_PAR_YPOS];
             axes = pmPSF_ModelToAxes (PAR, 20.0);
             row = psMetadataAlloc ();
             // XXX we are not writing out the mode (flags) or the type (psf, ext, etc)
             psMetadataAddU32 (row, PS_LIST_TAIL, "IPP_IDET",         0, "IPP detection identifier index",             source->seq);
             psMetadataAddF32 (row, PS_LIST_TAIL, "X_EXT",            0, "EXT model x coordinate",                     xPos);
             psMetadataAddF32 (row, PS_LIST_TAIL, "Y_EXT",            0, "EXT model y coordinate",                     yPos);
             psMetadataAddF32 (row, PS_LIST_TAIL, "X_EXT_SIG",        0, "Sigma in EXT x coordinate",                  xErr);
             psMetadataAddF32 (row, PS_LIST_TAIL, "Y_EXT_SIG",        0, "Sigma in EXT y coordinate",                  yErr);
             psMetadataAddF32 (row, PS_LIST_TAIL, "EXT_INST_MAG",     0, "EXT fit instrumental magnitude",             model->mag);
             psMetadataAddF32 (row, PS_LIST_TAIL, "EXT_INST_MAG_SIG", 0, "Sigma of PSF instrumental magnitude",        model->magErr);
             psMetadataAddF32 (row, PS_LIST_TAIL, "NPARAMS",          0, "number of model parameters",                 model->params->n);
             psMetadataAddStr (row, PS_LIST_TAIL, "MODEL_TYPE",       0, "name of model",                              pmModelClassGetName (model->type));
             // XXX these should be major and minor, not 'x' and 'y'
             psMetadataAddF32 (row, PS_LIST_TAIL, "EXT_WIDTH_MAJ",    0, "EXT width in x coordinate",                  axes.major);
             psMetadataAddF32 (row, PS_LIST_TAIL, "EXT_WIDTH_MIN",    0, "EXT width in y coordinate",                  axes.minor);
             psMetadataAddF32 (row, PS_LIST_TAIL, "EXT_THETA",        0, "EXT orientation angle",                      axes.theta);
             // write out the other generic parameters
             for (int k = 0; k < nParamMax; k++) {
                 if (k == PM_PAR_I0) continue;
                 if (k == PM_PAR_SKY) continue;
                 if (k == PM_PAR_XPOS) continue;
                 if (k == PM_PAR_YPOS) continue;
                 if (k == PM_PAR_SXX) continue;
                 if (k == PM_PAR_SXY) continue;
                 if (k == PM_PAR_SYY) continue;
                 snprintf (name, 64, "EXT_PAR_%02d", k);
                 if (k < model->params->n) {
                     psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "", model->params->data.F32[k]);
                 } else {
                     psMetadataAddF32 (row, PS_LIST_TAIL, name, PS_DATA_F32, "", NAN);
+                }
+            }
             // XXX other parameters which may be set.
             // XXX flag / value to define the model
             // XXX write out the model type, fit status flags
             psArrayAdd (table, 100, row);
             psFree (row);
+        }
+        pmSource *source = sources->data[i];
+        // XXX if no model fits are saved, write out modelEXT?
+        if (source->modelFits == NULL) continue;
+        // We have multiple sources : need to flag the one used to subtract the light (the 'best' model)
+        for (int j = 0; j < source->modelFits->n; j++) {
+            // choose the convolved EXT model, if available, otherwise the simple one
+            pmModel *model = source->modelFits->data[j];
+            assert (model);
+            PAR = model->params->data.F32;
+            dPAR = model->dparams->data.F32;
+            xPos = PAR[PM_PAR_XPOS];
+            yPos = PAR[PM_PAR_YPOS];
+            xErr = dPAR[PM_PAR_XPOS];
+            yErr = dPAR[PM_PAR_YPOS];
+            axes = pmPSF_ModelToAxes (PAR, 20.0);
+            row = psMetadataAlloc ();
+            // XXX we are not writing out the mode (flags) or the type (psf, ext, etc)
+            psMetadataAddU32 (row, PS_LIST_TAIL, "IPP_IDET",         0, "IPP detection identifier index",             source->seq);
+            psMetadataAddF32 (row, PS_LIST_TAIL, "X_EXT",            0, "EXT model x coordinate",                     xPos);
+            psMetadataAddF32 (row, PS_LIST_TAIL, "Y_EXT",            0, "EXT model y coordinate",                     yPos);
+            psMetadataAddF32 (row, PS_LIST_TAIL, "X_EXT_SIG",        0, "Sigma in EXT x coordinate",                  xErr);
+            psMetadataAddF32 (row, PS_LIST_TAIL, "Y_EXT_SIG",        0, "Sigma in EXT y coordinate",                  yErr);
+            psMetadataAddF32 (row, PS_LIST_TAIL, "EXT_INST_MAG",     0, "EXT fit instrumental magnitude",             model->mag);
+            psMetadataAddF32 (row, PS_LIST_TAIL, "EXT_INST_MAG_SIG", 0, "Sigma of PSF instrumental magnitude",        model->magErr);
+            psMetadataAddF32 (row, PS_LIST_TAIL, "NPARAMS",          0, "number of model parameters",                 model->params->n);
+            psMetadataAddStr (row, PS_LIST_TAIL, "MODEL_TYPE",       0, "name of model",                              pmModelClassGetName (model->type));
+            // XXX these should be major and minor, not 'x' and 'y'
+            psMetadataAddF32 (row, PS_LIST_TAIL, "EXT_WIDTH_MAJ",    0, "EXT width in x coordinate",                  axes.major);
+            psMetadataAddF32 (row, PS_LIST_TAIL, "EXT_WIDTH_MIN",    0, "EXT width in y coordinate",                  axes.minor);
+            psMetadataAddF32 (row, PS_LIST_TAIL, "EXT_THETA",        0, "EXT orientation angle",                      axes.theta);
+            // write out the other generic parameters
+            for (int k = 0; k < nParamMax; k++) {
+                if (k == PM_PAR_I0) continue;
+                if (k == PM_PAR_SKY) continue;
+                if (k == PM_PAR_XPOS) continue;
+                if (k == PM_PAR_YPOS) continue;
+                if (k == PM_PAR_SXX) continue;
+                if (k == PM_PAR_SXY) continue;
+                if (k == PM_PAR_SYY) continue;
+                snprintf (name, 64, "EXT_PAR_%02d", k);
+                if (k < model->params->n) {
+                    psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "", model->params->data.F32[k]);
+                } else {
+                    psMetadataAddF32 (row, PS_LIST_TAIL, name, PS_DATA_F32, "", NAN);
+                }
+            }
+            // XXX other parameters which may be set.
+            // XXX flag / value to define the model
+            // XXX write out the model type, fit status flags
+            psArrayAdd (table, 100, row);
+            psFree (row);
+        }
+    }
     if (table->n == 0) {
         psFitsWriteBlank (fits, outhead, extname);
         psFree (outhead);
         psFree (table);
         return true;
+        psFitsWriteBlank (fits, outhead, extname);
+        psFree (outhead);
+        psFree (table);
+        return true;
+    }
     psTrace ("pmFPAfile", 5, "writing ext data %s\n", extname);
     if (!psFitsWriteTable (fits, outhead, table, extname)) {
         psError(PS_ERR_IO, false, "writing ext data %s\n", extname);
         psFree (outhead);
         psFree(table);
         return false;
+        psError(PS_ERR_IO, false, "writing ext data %s\n", extname);
+        psFree (outhead);
+        psFree(table);
+        return false;
+    }
     psFree (outhead);

branches/cnb_branches/cnb_branch_20090215/psModules/src/objects/pmSourcePhotometry.c

-              r21536
+              r23197
  *  @author EAM, IfA; GLG, MHPCC
+ *
  *  @version $Revision: 1.49.4.1 $ $Name: not supported by cvs2svn $
  *  @date $Date: 2009-02-19 17:59:50 $
+ *  @version $Revision: 1.50 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2009-02-16 22:28:54 $
+ *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
 …
+        }
+    }
     model->nPix = Npix;
+    model->nPix = Npix;
     model->nDOF = Npix - 1;
     model->chisq = dC;
 …
 // measure centroid of unshifted gaussian (should be 16.0,16.0)
+        {
           psImage *image = source->pixels;
           float xo = 0.0;
           float yo = 0.0;
           float xo2 = 0.0;
           float yo2 = 0.0;
           float no = 0.0;
           for (int j = 0; j < image->numRows; j++)
+          {
             for (int i = 0; i < image->numCols; i++) {
               xo += i*image->data.F32[j][i];
               yo += j*image->data.F32[j][i];
               xo2 += i*i*image->data.F32[j][i];
               yo2 += j*j*image->data.F32[j][i];
               no += image->data.F32[j][i];
+            }
+          }
           xo /= no;
           yo /= no;
           xo2 = sqrt (xo2/no - xo*xo);
           yo2 = sqrt (yo2/no - yo*yo);
           fprintf (stderr, "pre-shift centroid: %f,%f, sigma: %f,%f: flux: %f\n", xo, yo, xo2, yo2, no);
+          psImage *image = source->pixels;
+          float xo = 0.0;
+          float yo = 0.0;
+          float xo2 = 0.0;
+          float yo2 = 0.0;
+          float no = 0.0;
+          for (int j = 0; j < image->numRows; j++)
+          {
+            for (int i = 0; i < image->numCols; i++) {
+              xo += i*image->data.F32[j][i];
+              yo += j*image->data.F32[j][i];
+              xo2 += i*i*image->data.F32[j][i];
+              yo2 += j*j*image->data.F32[j][i];
+              no += image->data.F32[j][i];
+            }
+          }
+          xo /= no;
+          yo /= no;
+          xo2 = sqrt (xo2/no - xo*xo);
+          yo2 = sqrt (yo2/no - yo*yo);
+          fprintf (stderr, "pre-shift centroid: %f,%f, sigma: %f,%f: flux: %f\n", xo, yo, xo2, yo2, no);
+        }
 // measure centroid of unshifted gaussian (should be 16.0,16.0)
+        {
           psImage *image = flux;
           float xo = 0.0;
           float yo = 0.0;
           float xo2 = 0.0;
           float yo2 = 0.0;
           float no = 0.0;
           for (int j = 0; j < image->numRows; j++)
+          {
             for (int i = 0; i < image->numCols; i++) {
               xo += i*image->data.F32[j][i];
               yo += j*image->data.F32[j][i];
               xo2 += i*i*image->data.F32[j][i];
               yo2 += j*j*image->data.F32[j][i];
               no += image->data.F32[j][i];
+            }
+          }
           xo /= no;
           yo /= no;
           xo2 = sqrt (xo2/no - xo*xo);
           yo2 = sqrt (yo2/no - yo*yo);
           fprintf (stderr, "pre-shift centroid: %f,%f, sigma: %f,%f: flux: %f\n", xo, yo, xo2, yo2, no);
+          psImage *image = flux;
+          float xo = 0.0;
+          float yo = 0.0;
+          float xo2 = 0.0;
+          float yo2 = 0.0;
+          float no = 0.0;
+          for (int j = 0; j < image->numRows; j++)
+          {
+            for (int i = 0; i < image->numCols; i++) {
+              xo += i*image->data.F32[j][i];
+              yo += j*image->data.F32[j][i];
+              xo2 += i*i*image->data.F32[j][i];
+              yo2 += j*j*image->data.F32[j][i];
+              no += image->data.F32[j][i];
+            }
+          }
+          xo /= no;
+          yo /= no;
+          xo2 = sqrt (xo2/no - xo*xo);
+          yo2 = sqrt (yo2/no - yo*yo);
+          fprintf (stderr, "pre-shift centroid: %f,%f, sigma: %f,%f: flux: %f\n", xo, yo, xo2, yo2, no);
+        }
 # endif

branches/cnb_branches/cnb_branch_20090215/psModules/src/objects/pmSourcePhotometry.h

-              r21536
+              r23197
  * @author EAM, IfA; GLG, MHPCC
+ *
  * @version $Revision: 1.12.8.1 $ $Name: not supported by cvs2svn $
  * @date $Date: 2009-02-19 17:59:50 $
+ * @version $Revision: 1.13 $ $Name: not supported by cvs2svn $
+ * @date $Date: 2009-02-16 22:28:54 $
  * Copyright 2004 Maui High Performance Computing Center, University of Hawaii
  */
 …
     psImage *image,                     ///< image pixels to be used
     psImage *mask,                      ///< mask of pixels to ignore
     psImageMaskType maskVal             ///< Value to mask
+    psImageMaskType maskVal             ///< Value to mask
 );

branches/cnb_branches/cnb_branch_20090215/psModules/src/psmodules.h

-              r22722
+              r23197
 // the following headers are from psModule:concepts
 #include <pmConcepts.h>
+#include <pmConceptsStandard.h>
 #include <pmConceptsRead.h>
-#include <pmConceptsStandard.h>
 #include <pmConceptsWrite.h>
+#include <pmConceptsCopy.h>
 #include <pmConceptsPhotcode.h>
 #include <pmConceptsAverage.h>

Context Navigation

Legend:

Download in other formats: