Changeset 28484 for branches/pap/psModules/src/objects/pmPSF_IO.c

Timestamp:

Jun 24, 2010, 2:59:09 PM (16 years ago)

Author:

Paul Price

Message:

Merging trunk in advance of reintegrating into trunk.

Location:

branches/pap

Files:

• . (modified) (1 prop)
• psModules (modified) (1 prop)
• psModules/src/objects/pmPSF_IO.c (modified) (14 diffs)

branches/pap/psModules/src/objects/pmPSF_IO.c

@@ -174 +174 @@
     PS_ASSERT_PTR_NON_NULL(chip, false);
 
-    if (!pmPSFmodelWrite(chip->analysis, view, file, config)) {
+    // We need the readout as well, because that has the PSF analysis data (e.g., clumps)
+    // There is only one, because photometry is done on chip-mosaicked data.
+    pmFPAview *roView = pmFPAviewAlloc(0); // View to readout
+    *roView = *view;
+    roView->cell = 0;
+    roView->readout = 0;
+    pmReadout *ro = pmFPAviewThisReadout(roView, chip->parent); // Readout with analysis data
+    psFree(roView);
+
+    if (!pmPSFmodelWrite(chip->analysis, ro ? ro->analysis : NULL, view, file, config)) {
         psError(psErrorCodeLast(), false, "Failed to write PSF for chip");
         return false;
@@ -189 +198 @@
 // else
 //   - psf table (+header) : FITS Table
-bool pmPSFmodelWrite (psMetadata *analysis, const pmFPAview *view,
+bool pmPSFmodelWrite (const psMetadata *chipAnalysis, const psMetadata *roAnalysis, const pmFPAview *view,
                       pmFPAfile *file, pmConfig *config)
 {
@@ -198 +207 @@
     char *headName, *tableName, *residName;
 
-    if (!analysis) {
+    if (!chipAnalysis) {
         psError(PM_ERR_PROG, true, "No analysis metadata for chip.");
         return false;
+    }
+    if (!roAnalysis) {
+        psWarning("No analysis metadata for PSF, clump parameters cannot be saved.");
     }
 
@@ -314 +326 @@
 
     // select the psf of interest
-    pmPSF *psf = psMetadataLookupPtr (&status, analysis, "PSPHOT.PSF");
+    pmPSF *psf = psMetadataLookupPtr (&status, chipAnalysis, "PSPHOT.PSF");
     if (!psf) {
         psError(PM_ERR_PROG, true, "missing PSF for this analysis metadata");
@@ -346 +358 @@
 
         // we now save clump parameters for each region : need to save all of those
-        int nRegions = psMetadataLookupS32 (&status, analysis, "PSF.CLUMP.NREGIONS");
-        psMetadataAddS32 (header, PS_LIST_TAIL, "PSF_CLN", PS_META_REPLACE, "number of psf clump regions", nRegions);
-        for (int i = 0; i < nRegions; i++) {
-            char regionName[64];
-            snprintf (regionName, 64, "PSF.CLUMP.REGION.%03d", i);
-            psMetadata *regionMD = psMetadataLookupPtr (&status, analysis, regionName);
-
-            psfClump.X  = psMetadataLookupF32 (&status, regionMD, "PSF.CLUMP.X");   assert (status);
-            psfClump.Y  = psMetadataLookupF32 (&status, regionMD, "PSF.CLUMP.Y");   assert (status);
-            psfClump.dX = psMetadataLookupF32 (&status, regionMD, "PSF.CLUMP.DX");  assert (status);
-            psfClump.dY = psMetadataLookupF32 (&status, regionMD, "PSF.CLUMP.DY");  assert (status);
-
-            char key[16];
-            snprintf (key, 9, "CLX_%03d", i);
-            psMetadataAddF32 (header, PS_LIST_TAIL, key, PS_META_REPLACE, "psf clump center", psfClump.X);
-            snprintf (key, 9, "CLY_%03d", i);
-            psMetadataAddF32 (header, PS_LIST_TAIL, key, PS_META_REPLACE, "psf clump center", psfClump.Y);
-            snprintf (key, 9, "CLDX_%03d", i);
-            psMetadataAddF32 (header, PS_LIST_TAIL, key, PS_META_REPLACE, "psf clump size", psfClump.dX);
-            snprintf (key, 9, "CLDY_%03d", i);
-            psMetadataAddF32 (header, PS_LIST_TAIL, key, PS_META_REPLACE, "psf clump size", psfClump.dY);
+        if (roAnalysis) {
+            int nRegions = psMetadataLookupS32 (&status, roAnalysis, "PSF.CLUMP.NREGIONS");
+            psMetadataAddS32 (header, PS_LIST_TAIL, "PSF_CLN", PS_META_REPLACE, "number of psf clump regions", nRegions);
+            for (int i = 0; i < nRegions; i++) {
+                char regionName[64];
+                snprintf (regionName, 64, "PSF.CLUMP.REGION.%03d", i);
+                psMetadata *regionMD = psMetadataLookupPtr (&status, roAnalysis, regionName);
+
+                psfClump.X  = psMetadataLookupF32 (&status, regionMD, "PSF.CLUMP.X");   assert (status);
+                psfClump.Y  = psMetadataLookupF32 (&status, regionMD, "PSF.CLUMP.Y");   assert (status);
+                psfClump.dX = psMetadataLookupF32 (&status, regionMD, "PSF.CLUMP.DX");  assert (status);
+                psfClump.dY = psMetadataLookupF32 (&status, regionMD, "PSF.CLUMP.DY");  assert (status);
+
+                char key[16];
+                snprintf (key, 9, "CLX_%03d", i);
+                psMetadataAddF32 (header, PS_LIST_TAIL, key, PS_META_REPLACE, "psf clump center", psfClump.X);
+                snprintf (key, 9, "CLY_%03d", i);
+                psMetadataAddF32 (header, PS_LIST_TAIL, key, PS_META_REPLACE, "psf clump center", psfClump.Y);
+                snprintf (key, 9, "CLDX_%03d", i);
+                psMetadataAddF32 (header, PS_LIST_TAIL, key, PS_META_REPLACE, "psf clump size", psfClump.dX);
+                snprintf (key, 9, "CLDY_%03d", i);
+                psMetadataAddF32 (header, PS_LIST_TAIL, key, PS_META_REPLACE, "psf clump size", psfClump.dY);
+            }
         }
 
@@ -492 +506 @@
 
         // write the residuals as planes of the image
-        psArray *images = psArrayAllocEmpty (1);
-        psArrayAdd (images, 1, psf->residuals->Ro);  // z = 0 is Ro
+        psArray *images = psArrayAllocEmpty (1);
+        psArrayAdd (images, 1, psf->residuals->Ro);  // z = 0 is Ro
 
         if (psf->residuals->Rx) {
             psArrayAdd (images, 1, psf->residuals->Rx);
             psArrayAdd (images, 1, psf->residuals->Ry);
-        }
-
-        // note that all N plane are implicitly of the same type, so we convert the mask
-        if (psf->residuals->mask) {
-            psImage *mask = psImageCopy (NULL, psf->residuals->mask, psf->residuals->Ro->type.type);
-            psArrayAdd (images, 1, mask);
-            psFree (mask);
-        }
-
-        // psFitsWriteImageCube (file->fits, header, images, residName);
-        // psFree (images);
-
-        if (!psFitsWriteImageCube (file->fits, header, images, residName)) {
+        }
+
+        // note that all N plane are implicitly of the same type, so we convert the mask
+        if (psf->residuals->mask) {
+            psImage *mask = psImageCopy (NULL, psf->residuals->mask, psf->residuals->Ro->type.type);
+            psArrayAdd (images, 1, mask);
+            psFree (mask);
+        }
+
+        // psFitsWriteImageCube (file->fits, header, images, residName);
+        // psFree (images);
+
+        if (!psFitsWriteImageCube (file->fits, header, images, residName)) {
             psError(psErrorCodeLast(), false, "Unable to write PSF residuals.");
             psFree(images);
@@ -728 +742 @@
     PS_ASSERT_PTR_NON_NULL(file->fpa, false);
 
-    if (!pmPSFmodelRead (chip->analysis, view, file, config)) {
+    // We need the readout as well, because that has the PSF analysis data (e.g., clumps)
+    // There may be only one, because photometry is done on chip-mosaicked data.
+    if (chip->cells->n != 1) {
+        psError(PM_ERR_PROG, true, "Chip to receive PSF has %ld cells (should be only one)",
+                chip->cells->n);
+        return false;
+    }
+    pmCell *cell = chip->cells->data[0]; // Cell to receive PSF
+    pmReadout *ro = NULL;                // Readout to receive PSF
+    if (cell->readouts->n == 0) {
+        ro = pmReadoutAlloc(cell);
+        psFree(ro);                     // Drop reference
+    } else if (cell->readouts->n != 1) {
+        psError(PM_ERR_PROG, true, "Cell to receive PSF has %ld readouts (should be only one)",
+                cell->readouts->n);
+        return false;
+    } else {
+        ro = cell->readouts->data[0];
+    }
+    PM_ASSERT_READOUT_NON_NULL(ro, false);
+    if (!ro->analysis) {
+        ro->analysis = psMetadataAlloc();
+    }
+
+    if (!pmPSFmodelRead(chip->analysis, ro->analysis, view, file, config)) {
         psError(psErrorCodeLast(), false, "Failed to write PSF for chip");
         return false;
@@ -737 +775 @@
 // for each Readout (ie, analysed image), we write out: header + table with PSF model parameters,
 // and header + image for the PSF residual images
-bool pmPSFmodelRead (psMetadata *analysis, const pmFPAview *view, pmFPAfile *file, const pmConfig *config)
+bool pmPSFmodelRead (psMetadata *chipAnalysis, psMetadata *roAnalysis, const pmFPAview *view, pmFPAfile *file, const pmConfig *config)
 {
+    PS_ASSERT_METADATA_NON_NULL(chipAnalysis, false);
     PS_ASSERT_PTR_NON_NULL(view, false);
     PS_ASSERT_PTR_NON_NULL(file, false);
@@ -803 +842 @@
 
     // read the psf clump data for each region
-    int nRegions = psMetadataLookupS32 (&status, header, "PSF_CLN");
-    if (!status) {
-        // read old-style psf clump data
-
-        char regionName[64];
-        snprintf (regionName, 64, "PSF.CLUMP.REGION.000");
-        psMetadataAddS32 (analysis, PS_LIST_TAIL, "PSF.CLUMP.NREGIONS",  PS_META_REPLACE, "psf clump regions", 1);
-
-        psMetadata *regionMD = psMetadataLookupPtr (&status, analysis, regionName);
-        if (!regionMD) {
-            regionMD = psMetadataAlloc();
-            psMetadataAddMetadata (analysis, PS_LIST_TAIL, regionName, PS_META_REPLACE, "psf clump region", regionMD);
-            psFree (regionMD);
-        }
-
-        // psf clump data
-        pmPSFClump psfClump;
-
-        psfClump.X  = psMetadataLookupF32 (&status, header, "PSF_CLX" );  assert(status);
-        psfClump.Y  = psMetadataLookupF32 (&status, header, "PSF_CLY" );  assert(status);
-        psfClump.dX = psMetadataLookupF32 (&status, header, "PSF_CLDX");  assert(status);
-        psfClump.dY = psMetadataLookupF32 (&status, header, "PSF_CLDY");  assert(status);
-
-        psMetadataAddF32 (regionMD, PS_LIST_TAIL, "PSF.CLUMP.X",  PS_META_REPLACE, "psf clump center", psfClump.X);
-        psMetadataAddF32 (regionMD, PS_LIST_TAIL, "PSF.CLUMP.Y",  PS_META_REPLACE, "psf clump center", psfClump.Y);
-        psMetadataAddF32 (regionMD, PS_LIST_TAIL, "PSF.CLUMP.DX", PS_META_REPLACE, "psf clump center", psfClump.dX);
-        psMetadataAddF32 (regionMD, PS_LIST_TAIL, "PSF.CLUMP.DY", PS_META_REPLACE, "psf clump center", psfClump.dY);
-    } else {
-        psMetadataAddS32 (analysis, PS_LIST_TAIL, "PSF.CLUMP.NREGIONS",  PS_META_REPLACE, "psf clump regions", nRegions);
-
-        for (int i = 0; i < nRegions; i++) {
-            char key[10];
+    if (roAnalysis) {
+        int nRegions = psMetadataLookupS32 (&status, header, "PSF_CLN");
+        if (!status) {
+            // read old-style psf clump data
+
             char regionName[64];
-            snprintf (regionName, 64, "PSF.CLUMP.REGION.%03d", i);
-
-            psMetadata *regionMD = psMetadataLookupPtr (&status, analysis, regionName);
+            snprintf (regionName, 64, "PSF.CLUMP.REGION.000");
+            psMetadataAddS32 (roAnalysis, PS_LIST_TAIL, "PSF.CLUMP.NREGIONS",  PS_META_REPLACE, "psf clump regions", 1);
+
+            psMetadata *regionMD = psMetadataLookupPtr (&status, roAnalysis, regionName);
             if (!regionMD) {
                 regionMD = psMetadataAlloc();
-                psMetadataAddMetadata (analysis, PS_LIST_TAIL, regionName, PS_META_REPLACE, "psf clump region", regionMD);
+                psMetadataAddMetadata (roAnalysis, PS_LIST_TAIL, regionName, PS_META_REPLACE, "psf clump region", regionMD);
                 psFree (regionMD);
             }
@@ -848 +861 @@
             pmPSFClump psfClump;
 
-            snprintf (key, 9, "CLX_%03d", i);
-            psfClump.X  = psMetadataLookupF32 (&status, header, key);  assert(status);
-            snprintf (key, 9, "CLY_%03d", i);
-            psfClump.Y  = psMetadataLookupF32 (&status, header, key);  assert(status);
-            snprintf (key, 9, "CLDX_%03d", i);
-            psfClump.dX = psMetadataLookupF32 (&status, header, key);  assert(status);
-            snprintf (key, 9, "CLDY_%03d", i);
-            psfClump.dY = psMetadataLookupF32 (&status, header, key);  assert(status);
+            psfClump.X  = psMetadataLookupF32 (&status, header, "PSF_CLX" );  assert(status);
+            psfClump.Y  = psMetadataLookupF32 (&status, header, "PSF_CLY" );  assert(status);
+            psfClump.dX = psMetadataLookupF32 (&status, header, "PSF_CLDX");  assert(status);
+            psfClump.dY = psMetadataLookupF32 (&status, header, "PSF_CLDY");  assert(status);
 
             psMetadataAddF32 (regionMD, PS_LIST_TAIL, "PSF.CLUMP.X",  PS_META_REPLACE, "psf clump center", psfClump.X);
@@ -861 +870 @@
             psMetadataAddF32 (regionMD, PS_LIST_TAIL, "PSF.CLUMP.DX", PS_META_REPLACE, "psf clump center", psfClump.dX);
             psMetadataAddF32 (regionMD, PS_LIST_TAIL, "PSF.CLUMP.DY", PS_META_REPLACE, "psf clump center", psfClump.dY);
+        } else {
+            psMetadataAddS32 (roAnalysis, PS_LIST_TAIL, "PSF.CLUMP.NREGIONS",  PS_META_REPLACE, "psf clump regions", nRegions);
+
+            for (int i = 0; i < nRegions; i++) {
+                char key[10];
+                char regionName[64];
+                snprintf (regionName, 64, "PSF.CLUMP.REGION.%03d", i);
+
+                psMetadata *regionMD = psMetadataLookupPtr (&status, roAnalysis, regionName);
+                if (!regionMD) {
+                    regionMD = psMetadataAlloc();
+                    psMetadataAddMetadata (roAnalysis, PS_LIST_TAIL, regionName, PS_META_REPLACE, "psf clump region", regionMD);
+                    psFree (regionMD);
+                }
+
+                // psf clump data
+                pmPSFClump psfClump;
+
+                snprintf (key, 9, "CLX_%03d", i);
+                psfClump.X  = psMetadataLookupF32 (&status, header, key);  assert(status);
+                snprintf (key, 9, "CLY_%03d", i);
+                psfClump.Y  = psMetadataLookupF32 (&status, header, key);  assert(status);
+                snprintf (key, 9, "CLDX_%03d", i);
+                psfClump.dX = psMetadataLookupF32 (&status, header, key);  assert(status);
+                snprintf (key, 9, "CLDY_%03d", i);
+                psfClump.dY = psMetadataLookupF32 (&status, header, key);  assert(status);
+
+                psMetadataAddF32 (regionMD, PS_LIST_TAIL, "PSF.CLUMP.X",  PS_META_REPLACE, "psf clump center", psfClump.X);
+                psMetadataAddF32 (regionMD, PS_LIST_TAIL, "PSF.CLUMP.Y",  PS_META_REPLACE, "psf clump center", psfClump.Y);
+                psMetadataAddF32 (regionMD, PS_LIST_TAIL, "PSF.CLUMP.DX", PS_META_REPLACE, "psf clump center", psfClump.dX);
+                psMetadataAddF32 (regionMD, PS_LIST_TAIL, "PSF.CLUMP.DY", PS_META_REPLACE, "psf clump center", psfClump.dY);
+            }
         }
     }
@@ -1019 +1060 @@
         }
 
-        // note that all N plane are implicitly of the same type, so we convert the mask
-        psImage *mask = psImageCopy(NULL, psf->residuals->mask, psf->residuals->Ro->type.type);
-        psImageInit (psf->residuals->mask, 0);
-        psImageInit (psf->residuals->Rx, 0.0);
-        psImageInit (psf->residuals->Ry, 0.0);
-        switch (Nz) {
-          case 1: // Ro only
-            break;
-          case 2: // Ro and mask
+        // note that all N plane are implicitly of the same type, so we convert the mask
+        psImage *mask = psImageCopy(NULL, psf->residuals->mask, psf->residuals->Ro->type.type);
+        psImageInit (psf->residuals->mask, 0);
+        psImageInit (psf->residuals->Rx, 0.0);
+        psImageInit (psf->residuals->Ry, 0.0);
+        switch (Nz) {
+          case 1: // Ro only
+            break;
+          case 2: // Ro and mask
             if (!psFitsReadImageBuffer(mask, file->fits, fullImage, 1)) {
                 psError(psErrorCodeLast(), false, "Unable to read PSF residual image.");
                 return false;
             }
-            psImageCopy (psf->residuals->mask, mask, PM_TYPE_RESID_MASK);
-            break;
-          case 3: // Ro, Rx and Ry, no mask
+            psImageCopy (psf->residuals->mask, mask, PM_TYPE_RESID_MASK);
+            break;
+          case 3: // Ro, Rx and Ry, no mask
             if (!psFitsReadImageBuffer(psf->residuals->Rx, file->fits, fullImage, 1)) {
                 psError(psErrorCodeLast(), false, "Unable to read PSF residual image.");
@@ -1043 +1084 @@
                 return false;
             }
-            break;
-          case 4: // Ro, Rx, Ry, and mask:
+            break;
+          case 4: // Ro, Rx, Ry, and mask:
             if (!psFitsReadImageBuffer(psf->residuals->Rx, file->fits, fullImage, 1)) {
                 psError(psErrorCodeLast(), false, "Unable to read PSF residual image.");
@@ -1057 +1098 @@
                 return false;
             }
-            psImageCopy (psf->residuals->mask, mask, PM_TYPE_RESID_MASK);
-            break;
-        }
-        psFree (mask);
-    }
-
-    psMetadataAdd (analysis, PS_LIST_TAIL, "PSPHOT.PSF",     PS_DATA_UNKNOWN,  "psphot psf", psf);
+            psImageCopy (psf->residuals->mask, mask, PM_TYPE_RESID_MASK);
+            break;
+        }
+        psFree (mask);
+    }
+
+    psMetadataAdd (chipAnalysis, PS_LIST_TAIL, "PSPHOT.PSF",     PS_DATA_UNKNOWN,  "psphot psf", psf);
     psFree (psf);